Tuple[Union[int, bool, str]]:\\n control_unit = ctypes.c_long(control_unit)\\n axis = int(axis)\\n axis = ctypes.c_long(axis)\\n sleep(time_ps_delay)\\n res = self.lib.PS90_GetAxisState(control_unit, axis)\\n error = self.__get_read_error_ps90(control_unit)\\n if error != 0:\\n res = False\\n return res, self._error_OWIS_ps90(error, 1)\",\n \"def __init__(self,options,pos):\\n self.options = options\\n numobjects = pos.shape[1]\\n plt.ion() # turn on interactive plotting mode\\n dpi=72.0 # set dpi (I think this is appropriate on mac)\\n # fig accepts size in inches\\n # so divide desired pixel width, height by dpi to get inches\\n w,h=(self.options.width/dpi,self.options.height/dpi)\\n fig = plt.figure(1,figsize=(w,h),dpi=dpi)\\n fig.clear()\\n\\n #w = self.options.width/fig.get_dpi() # desired width in inches\\n #h = self.options.height/fig.get_dpi() # desired height in inches\\n #fig.set_size_inches(w,h,forward=True) # last arg resizes the canvas to match\\n\\n self.ax = plt.axes()\\n self.ax.set_xlim(self.options.xmin,self.options.xmax)\\n self.ax.set_ylim(self.options.ymin,self.options.ymax)\\n #pyplot.axis('scaled')\\n\\n # I don't know why axis('scaled') doesn't work here\\n # But I think the next two commands are equivalent\\n self.ax.set_aspect('equal', adjustable='box', anchor='C')\\n self.ax.set_autoscale_on(False)\\n\\n #self.redraw()\\n\\n\\n #facecolors = [cm.jet(x) for x in np.random.rand(len(vicon_objects))]\\n facecolors = [cm.jet(x) for x in np.linspace(0,1,numobjects)]\\n if self.options.visualize_switch_xy:\\n if self.options.axis==1:\\n self.ax.axvline(linewidth=4, c='k')\\n else:\\n self.ax.axhline(linewidth=4, c='k')\\n self.col = plt.scatter(pos[:,1],pos[:,0],c=facecolors,s=3000)\\n else:\\n if self.options.axis==1:\\n self.ax.axhline(linewidth=4, c='k')\\n else:\\n self.ax.axvline(linewidth=4, c='k')\\n self.col = plt.scatter(pos[:,0],pos[:,1],c=facecolors,s=3000)\\n\\n # scores\\n self.tpos = self.ax.text(0.75*self.options.xmax,0.75*self.options.ymin,str(50),\\n size=72,color='k',ha='center',va='center')\\n self.tneg = self.ax.text(0.75*self.options.xmin,0.75*self.options.ymin,str(50),\\n size=72,color='k',ha='center',va='center')\\n\\n self.canvas = agg.FigureCanvasAgg(fig)\\n self.canvas.draw()\\n self.renderer = self.canvas.get_renderer()\\n raw_data = self.renderer.tostring_rgb()\\n\\n pygame.init()\\n \\n self.window = pygame.display.set_mode((options.width,options.height), DOUBLEBUF)\\n self.screen = pygame.display.get_surface()\\n\\n self.set_caption(\\\"Possession: Waiting for Vicon\\\")\\n \\n size = self.canvas.get_width_height()\\n \\n surf = pygame.image.fromstring(raw_data, size, \\\"RGB\\\")\\n self.screen.blit(surf, (0,0))\\n pygame.display.flip()\",\n \"def _update_ax(self):\\n raise NotImplementedError(\\\"Implement _update_ax(self) in subclass\\\")\",\n \"def reflect(self, axis):\\n if axis == \\\"x\\\":\\n self.y = - self.y\\n elif axis == \\\"y\\\":\\n self.x = - self.x\\n else:\\n print(\\\"The argument axis only accepts values 'x' and 'y'!\\\")\",\n \"def __init__(self, x_axis_p, y_axis_p, x_speed=0, y_speed=0, direction=0):\\r\\n self.__x_axis = x_axis_p\\r\\n self.__y_axis = y_axis_p\\r\\n self.__X_speed = x_speed\\r\\n self.__y_speed = y_speed\\r\\n self.__direction = direction\\r\\n self.__lives = 3\",\n \"def __init__(self):\\n\\n # The Microsoft XBox 360 Wired controller has 11 buttons and 8 axes.\\n # Buttons can be 0 (not pressed) or 1 (pressed)\\n # Axes are floats and range between -1 and 1. Note that for LT and RT, their \\\"not pressed\\\" value is 1 and for the others it is 0. Cross keys only have values -1, 0, and 1. The others have be any value in between -1 and 1.\\n num_buttons = 11\\n num_axes = 8\\n self.inputs = [0 for i in range(num_buttons + num_axes)]\\n self.inputs[JoyInput.LT] = self.inputs[JoyInput.RT] = 1\\n\\n # Dictionary of saved inputs. If an input is not currently saved, you must set it to None.\\n # For example, the LS_Y (\\\"left stick Y\\\") axis may be saved in self.saved[JoyInput.LS_Y]\\n self.saved = {\\n JoyInput.LS_Y: None,\\n Joystick.RS_ANGLE: None,\\n }\\n\\n # Field variables\\n self.depth_state = None # stores the depth state\\n self.depth_last_received = 0 # how long since the last depth state callback\\n self.depth_pwm_input = 0 # tracks pwm given to depth thrusters\\n\\n # ROS Subscribers\\n rospy.Subscriber(\\\"/joy\\\", Joy, self.joy_callback)\\n rospy.Subscriber(Topic.YAW_STATE, Float64, self.yaw_state_callback)\\n rospy.Subscriber(Topic.DEPTH_STATE, Float64, self.depth_state_callback)\\n rospy.Subscriber(Topic.YAW_SETPOINT, Float64, self.yaw_setpoint_callback)\\n rospy.Subscriber(Topic.DEPTH_SETPOINT, Int16, self.depth_setpoint_callback)\\n\\n # ROS Publishers\\n # self.topics is a dictionary of dictionaries.\\n # 'publisher' contains the rospy.Publisher()\\n # 'msg' contains the Int16(), Float64(), or Bool() related to the publisher\\n # Use self.publish() rather than using self.topics directly.\\n self.topics = {\\n Topic.YAW_PWM: {'publisher':rospy.Publisher(Topic.YAW_PWM, Int16, queue_size=10), 'msg':Int16()},\\n Topic.YAW_PWM_FEEDBACK: {'publisher':rospy.Publisher(Topic.YAW_PWM_FEEDBACK, Int16, queue_size=10), 'msg':Int16()},\\n Topic.YAW_PID: {'publisher':rospy.Publisher(Topic.YAW_PID, Bool, queue_size=10), 'msg':Bool()},\\n Topic.YAW_SETPOINT: {'publisher':rospy.Publisher(Topic.YAW_SETPOINT, Float64, queue_size=10), 'msg':Float64()},\\n\\n Topic.DEPTH_PWM: {'publisher':rospy.Publisher(Topic.DEPTH_PWM, Int16, queue_size=10), 'msg':Int16()},\\n Topic.DEPTH_PID: {'publisher':rospy.Publisher(Topic.DEPTH_PID, Bool, queue_size=10), 'msg':Bool()},\\n Topic.DEPTH_SETPOINT: {'publisher':rospy.Publisher(Topic.DEPTH_SETPOINT, Int16, queue_size=10), 'msg':Int16()},\\n }\",\n \"def listen(self):\\n\\n if not self.axis_data:\\n self.axis_data = {}\\n\\n if not self.button_data:\\n self.button_data = {}\\n for i in range(self.controller.get_numbuttons()):\\n self.button_data[i] = False\\n\\n if not self.hat_data:\\n self.hat_data = {}\\n for i in range(self.controller.get_numhats()):\\n self.hat_data[i] = (0, 0)\\n\\n for event in pygame.event.get():\\n if event.type == pygame.JOYAXISMOTION:\\n self.axis_data[event.axis] = round(event.value,2)\\n elif event.type == pygame.JOYBUTTONDOWN:\\n self.button_data[event.button] = True\\n elif event.type == pygame.JOYBUTTONUP:\\n self.button_data[event.button] = False\\n elif event.type == pygame.JOYHATMOTION:\\n self.hat_data[event.hat] = event.value\\n\\n axis=self.axis_data\\n\\n if 0 in axis:\\n self.x=axis[0]\\n self.y=-axis[1]\\n\\n # Turbo\\n if self.button_data[7]:\\n self.x*=2\\n self.y*=2\\n # Start Camera\\n if self.button_data[3]:\\n subprocess.Popen([\\\"firefox\\\",otraip+\\\"/html\\\"],\\n stdout=subprocess.PIPE,\\n stdin=subprocess.PIPE,\\n stderr=subprocess.PIPE)\\n return \\\"camera\\\"\\n\\n # Measure\\n if self.button_data[1]:\\n return \\\"measure\\\"\\n\\n # Exit\\n if self.button_data[2]:\\n return \\\"exit\\\"\\n return \\\"move \\\"+str(self.x)+\\\" \\\"+str(self.y)+\\\"\\\\n\\\"\",\n \"def _appendAxisDefinition(self, axis):\\n length = len(axis)\\n\\n self.na_dict[\\\"NX\\\"].append(length)\\n self.na_dict[\\\"XNAME\\\"].append(xarray_utils.getBestName(axis))\\n\\n # If only one item in axis values\\n if length < 2:\\n self.na_dict[\\\"DX\\\"].append(0)\\n self.na_dict[\\\"NXDEF\\\"].append(length)\\n self.na_dict[\\\"X\\\"].append(axis.data.tolist()) \\n return\\n\\n incr = xarray_utils.get_interval(axis, 0, 1)\\n\\n for i in range(1, length):\\n if (axis[i] - axis[i - 1]) != incr:\\n self.na_dict[\\\"DX\\\"].append(0)\\n self.na_dict[\\\"NXDEF\\\"].append(length)\\n self.na_dict[\\\"X\\\"].append(axis.data.tolist())\\n break\\n\\n else: # If did not break out of the loop\\n max_length = length\\n if length > 3: \\n max_length = 3\\n\\n self.na_dict[\\\"DX\\\"].append(incr)\\n self.na_dict[\\\"NXDEF\\\"].append(max_length)\\n self.na_dict[\\\"X\\\"].append(axis[:max_length])\",\n \"def getAxis(self,axis):\\n\\n\\t\\tif axis == \\\"u\\\":\\n\\t\\t\\tif len(self.usr) != 0:\\n\\t\\t\\t\\treturn np.append([0], self.usr)\\n\\n\\t\\tif axis == \\\"s\\\":\\n\\t\\t\\tif len(self.seg) != 0:\\n\\t\\t\\t\\tif self.radiograph:\\n\\t\\t\\t\\t\\treturn self.seg\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tfirst = self.seg[0] - 1.\\n\\t\\t\\t\\t\\treturn np.append([first], self.seg)\\n\\n\\t\\tif axis == \\\"c\\\":\\n\\t\\t\\tif len(self.cos) != 0:\\n\\t\\t\\t\\tif self.radiograph:\\n\\t\\t\\t\\t\\treturn self.cos\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tfirst = -1.\\n\\t\\t\\t\\t\\treturn np.append([first], self.cos)\\n\\n\\t\\tif axis == \\\"e\\\":\\n\\t\\t\\tif len(self.erg) != 0:\\n\\t\\t\\t\\tfirst = self.erg[0] - 1.\\n\\t\\t\\t\\treturn np.append([first], self.erg)\\n\\n\\t\\tif axis == \\\"t\\\":\\n\\t\\t\\tif len(self.tim) != 0:\\n\\t\\t\\t\\tfirst = self.tim[0] - 1.\\n\\t\\t\\t\\treturn np.append([first], self.tim)\\n\\n\\t\\tif axis == \\\"i\\\":\\n\\t\\t\\treturn self.cora\\n\\n\\t\\tif axis == \\\"j\\\":\\n\\t\\t\\treturn self.corb\\n\\n\\t\\tif axis == \\\"k\\\":\\n\\t\\t\\treturn self.corc\\n\\n\\t\\treturn []\",\n \"def axes_coupled(robot):\\n\\n target_ctrl_path = get_target_ctrl_path(robot)\\n attr_name = 'axisCoupling'\\n\\n attr_path = target_ctrl_path + '.' + attr_name\\n\\n if not pm.objExists(attr_path):\\n return False\\n else:\\n return pm.getAttr(attr_path)\",\n \"def _use_data_bounds_changed_for_axes(self):\\n self.update_pipeline()\",\n \"def rotate_axis(self):\\n try:\\n self.obj.rotate(angle=self.rotation_speed * self.time_scale / self.refresh_rate, axis=vector(0, 1, 0))\\n except ZeroDivisionError:\\n print(\\\"ERROR: REFRESH_RATE is 0\\\")\\n except (AttributeError, TypeError):\\n print(\\\"ERROR: wrong arguments type while initializing!!\\\")\",\n \"def axes(self,a_len,b_len,c_len,beta):\\n self.a = np.array([0,0,a_len])\\n self.b = np.array([0,b_len,0])\\n self.c = Ry(-beta) @ np.array([0,0,c_len])\",\n \"def axis(self):\\r\\n return self._arm.axis\",\n \"def __init__(self):\\n #Call the base class constructor\\n inkex.Effect.__init__(self)\\n \\n #Define custom namespace\\n inkex.NSS['TimeAnalysis'] = 'http://www.arcex.no/workpackage/basin-analysis/'\\n \\n #Define string options\\n self.OptionParser.add_option('-t', '--AxisType', action = 'store',\\n type = 'string', dest = 'AxisType', default = '',\\n help = 'Which axis would you like to define?')\\n self.OptionParser.add_option('-s', '--AxisScale', action = 'store',\\n type = 'string', dest = 'AxisScale', default = '',\\n help = 'Is the axis logaritmic or linear?')\\n self.OptionParser.add_option('-d', '--AxisDescription', action = 'store',\\n type = 'string', dest = 'AxisDescription', default = '',\\n help = 'How would you the describe the axis?')\\n self.OptionParser.add_option('-u', '--AxisUnit', action = 'store',\\n type = 'string', dest = 'AxisUnit', default = '',\\n help = 'What unit is represented by you axis?')\\n self.OptionParser.add_option('-l', '--AxisLabel', action = 'store',\\n type = 'string', dest = 'AxisLabel', default = '',\\n help = 'What would you like to call your axis')\\n self.OptionParser.add_option('-x', '--AxisMaxValue', action = 'store',\\n type = 'string', dest = 'AxisMaxValue', default = '',\\n help = 'What is the maximum value represented by you axis?')\\n self.OptionParser.add_option('-i', '--AxisMinValue', action = 'store',\\n type = 'string', dest = 'AxisMinValue', default = '',\\n help = 'What is the minimum value represented by you axis?')\\n self.OptionParser.add_option('-a', '--Notebook', action = 'store',\\n type = 'string', dest = 'Notebook', default = '',\\n help = 'What is the minimum value represented by you axis?')\",\n \"def setupVariableAxes(self):\\n if self.var is None:\\n return\\n \\n if (self.axisList is None):\\n self.axisList = self.var.getAxisList()\\n self.axisOrder = range(len(self.axisList))\\n\\n self.clear() \\n self.setAxesNames()\\n \\n # Iterate through the variables axes & init each axis widget\\n axisIndex = 0\\n for axis, axisName in zip(self.axisList, self.axesNames):\\n # Create the axis widget\\n axisWidget = QAxis(axis, axisName, axisIndex, self)\\n axisWidget.setAxisButtonText(axisName)\\n self.axisWidgets.append(axisWidget)\\n\\n # Setup the layout for each axis\\n row = self.gridLayout.rowCount()\\n self.gridLayout.addWidget(axisWidget.getAxisButton(), row, 0)\\n self.gridLayout.addWidget(axisWidget, row, 1) \\n self.gridLayout.addWidget(axisWidget.getAxisOperationsButton(), row, 2)\\n\\n # Create separator line between each axis widget\\n vline = QtGui.QFrame()\\n vline.setFrameStyle(QtGui.QFrame.HLine | QtGui.QFrame.Sunken)\\n self.gridLayout.addWidget(vline, row+1, 0, 1,\\n self.gridLayout.columnCount())\\n\\n axisIndex += 1\\n\\n self.gridLayout.setRowStretch(self.gridLayout.rowCount(), 1)\",\n \"def get_axis_vals(self):\\n return self._x_axis, self._y_axis\",\n \"def get_axis(self):\\n self.current_axis = self.gui.comboBox_axis.currentText()\\n self.logger.debug('current axis:' + str(self.current_axis))\\n\\n if 'Stepper' in self.current_axis:\\n #self.gui.groupBox_configurate.setEnabled(True)\\n self.gui.groupBox_configurate.setStyleSheet(\\\"QGroupBox#Colored_configure {border: 1px solid blue; border-radius: 9px;}\\\")\\n\\n self.gui.groupBox_actions.setStyleSheet(\\\"QGroupBox default\\\")\\n\\n self.gui.stackedWidget_actions.setCurrentWidget(self.gui.page_configure_stepper)\\n self.gui.stackedWidget_stepper.setCurrentWidget(self.gui.stackedWidgetMoving)\\n self.gui.stackedWidgetMoving.setEnabled(False)\\n\\n if 'Z' in self.current_axis:\\n #Disable the xy groupboxes, enable the z groupboxes,\\n # choose the page_amplZ of the stackedWidget_configure\\n self.gui.groupBox_XY.setEnabled(False)\\n self.gui.groupBox_Z.setEnabled(True)\\n\\n self.gui.stackedWidget_configure.setCurrentWidget(self.gui.page_amplZ)\\n\\n self.gui.pushButton_up.setEnabled(False)\\n self.gui.pushButton_down.setEnabled(False)\\n self.gui.pushButton_left.setText('closer')\\n self.gui.pushButton_right.setText('away')\\n else:\\n #Enable the xy groupboxes, disable the z groupboxes,\\n # choose the page_amplXY of the stackedWidget_configure.\\n\\n self.gui.groupBox_XY.setEnabled(True)\\n self.gui.groupBox_Z.setEnabled(False)\\n\\n self.gui.stackedWidget_configure.setCurrentWidget(self.gui.page_amplXY)\\n\\n self.gui.pushButton_up.setEnabled(True)\\n self.gui.pushButton_down.setEnabled(True)\\n self.gui.pushButton_left.setText('left')\\n self.gui.pushButton_right.setText('right')\\n\\n elif 'Scanner' in self.current_axis:\\n #Choose the page_move_scanner of the stackedWidget_actions and the stackedWidgetEmpty of the stackedWidget_stepper\\n self.gui.stackedWidget_actions.setCurrentWidget(self.gui.page_move_scanner)\\n self.gui.stackedWidget_stepper.setCurrentWidget(self.gui.stackedWidgetempty)\\n\\n #Give the configurate box a border and the action box none\\n self.gui.groupBox_configurate.setStyleSheet(\\\"QGroupBox#Colored_configure {border: 1px solid blue; border-radius: 9px;}\\\")\\n self.gui.groupBox_actions.setStyleSheet(\\\"QGroupBox default\\\")\\n\\n #Choose either the page_scannerZ or page_scannerXY of the stackedWidget_voltScanner\\n if 'Z' in self.current_axis:\\n self.gui.stackedWidget_voltScanner.setCurrentWidget(self.gui.page_scannerZ)\\n else:\\n self.gui.stackedWidget_voltScanner.setCurrentWidget(self.gui.page_scannerXY)\",\n \"def test_config(self):\\n\\n p = SyncProto(packet_port, None)\\n\\n d = make_axes(500, .1, usteps=16, steps_per_rotation=200)\\n p.config(4, 18, 32, False, False, axes=d['axes1']);\\n p.info()\\n\\n d = make_axes(1000, .2, usteps=16, steps_per_rotation=200,\\n output_mode=OutMode.OUTPUT_OPENDRAIN, highval=OutVal.LOW)\\n p.config(4, 7, 9, False, False, axes=d['axes1']);\\n p.info()\",\n \"def _UpdatePlotImpl( self ):\\n if self.ax is not None:\\n self.axline = None\\n self.cursorLine = \\\\\\n self.cursorLine2 = None\\n\\n# self.ax.clear()\\n# if hasattr( self, 'ax2' ) and self.ax2 is not None:\\n# self.ax2.clear()\\n self.fig.clear()\\n self._InitAxes()\\n\\n#\\t\\t-- Scale fonts\\n#\\t\\t--\\n wd, ht = self.GetClientSize()\\n label_font_size = 14\\n tick_font_size = 12\\n self.titleFontSize = 16\\n if 'wxMac' not in wx.PlatformInfo and wd < 800:\\n\\tdecr = (800 - wd) / 50.0\\n\\tlabel_font_size -= decr\\n\\ttick_font_size -= decr\\n\\tself.titleFontSize -= decr\\n\\n# self.ax.grid(\\n# True, 'both', 'both',\\n#\\t color = '#c8c8c8', linestyle = ':', linewidth = 1\\n#\\t )\\n self._DoUpdatePlot( wd, ht )\\n self._DoUpdateRedraw()\\n self.canvas.draw()\\n #end if\",\n \"def noAxisSystem():\\n dislin.nograf()\",\n \"def updatePlot(self,*args):\\n # set x limits\\n timeDisplayOptions = {'10 minutes':10,'1 hour':60,'6 hours':6*60,'24 hours':24*60,'All':0}\\n try:\\n lastDatetime = mpl.dates.num2date(self.stage60K.get_xdata()[-1])\\n firstDatetime = mpl.dates.num2date(self.stage60K.get_xdata()[0])\\n except IndexError: # no data yet\\n now = datetime.datetime.utcnow().toordinal()\\n firstDatetime = mpl.dates.num2date(now)\\n lastDatetime = firstDatetime\\n xMin = lastDatetime-datetime.timedelta(minutes=timeDisplayOptions[self.wScale.get()])\\n xMin = max([ firstDatetime, xMin ])\\n if self.wScale.get() == 'All':\\n xMin = firstDatetime\\n xMinIndex = numpy.searchsorted( self.stage60K.get_xdata(), mpl.dates.date2num(xMin) )\\n # rescale axes, with the x being scaled by the slider\\n if self.toolbar._active == 'HOME' or self.toolbar._active == None:\\n ymin,ymax = 10000000, -10000000\\n lineAndVar = { self.stage60K: self.t60K,\\n self.stage03K: self.t3K,\\n self.stageGGG: self.tGGG,\\n self.stageFAA: self.tFAA }\\n if len(self.stage60K.get_xdata()) > 1:\\n for line in lineAndVar.keys():\\n if lineAndVar[line].get() == 0:\\n line.set_visible(False)\\n else:\\n line.set_visible(True)\\n ydata = line.get_ydata()[xMinIndex:-1]\\n try:\\n ymin = min(ymin, numpy.nanmin(ydata))\\n ymax = max(ymax, numpy.nanmax(ydata))\\n except ValueError as e:\\n pass\\n self.ax.set_xlim(xMin,lastDatetime)\\n self.ax.set_ylim(ymin - (ymax-ymin)/10, ymax + (ymax-ymin)/10)\\n hfmt = mpl.dates.DateFormatter('%H:%M:%S', tz=tz.tzlocal())\\n self.ax.xaxis.set_major_formatter(hfmt)\\n self.fig.autofmt_xdate()\\n self.fig.tight_layout()\\n #draw\\n self.canvas.draw()\",\n \"def on_click(event):\\n ax = event.inaxes\\n \\n if ax is None:\\n # Occurs when a region not in an axis is clicked...\\n return\\n \\n if self.current_plot == 'single':\\n if event.button is 1:\\n if not self.ax_zoomed:\\n # Change over to a single baseline plot\\n try:\\n self.ax_zoomed = True\\n self.current_ax = ax\\n ax.set_position([0.1, 0.05, 0.85, 0.80])\\n ax.set_xlabel(\\\"Frequency\\\")\\n #ax.set_ylabel(\\\"Time\\\")\\n \\n for axis in self.sp_fig.axes:\\n if axis is not ax:\\n axis.set_visible(False)\\n \\n except ValueError:\\n raise\\n self.sp_fig.canvas.mpl_disconnect(self.fig_connect)\\n \\n elif event.button is 3:\\n if self.ax_zoomed:\\n self.ax_zoomed = False\\n #self.sp_fig.canvas.mpl_disconnect(self.fig_connect)\\n self.updatePlot()\\n \\n else:\\n # No need to re-draw the canvas if it's not a left or right click\\n return\\n \\n elif self.current_plot == 'multi':\\n if ax is None:\\n # Occurs when a region not in an axis is clicked...\\n return\\n if event.button is 1:\\n if not self.ax_zoomed:\\n # Change over to a single baseline plot\\n try:\\n ant1, ant2 = ax.get_title().split(\\\" \\\")\\n except:\\n ant1 = int(ax.get_title().strip('Tile').strip('Antenna').strip('Stand'))\\n ant2 = ant1 \\n try:\\n self.spin_ref_ant.setValue(int(ant1))\\n self.spin_ref_ant2.setValue(int(ant2))\\n self.plot_select.setCurrentIndex(0)\\n self.current_plot = 'single'\\n \\n self.updatePlot()\\n except:\\n raise\\n self.sp_fig.canvas.mpl_disconnect(self.fig_connect)\\n \\n elif event.button is 3:\\n if not self.ax_zoomed:\\n ax.set_position([0.1, 0.1, 0.85, 0.85])\\n # TODO: fix labelling of zoom plots\\n ax.set_xlabel(\\\"Frequency\\\")\\n #ax.set_ylabel(\\\"Time\\\")\\n self.orig_position = ax.get_position()\\n for axis in event.canvas.figure.axes:\\n # Hide all the other axes...\\n if axis is not ax:\\n axis.set_visible(False)\\n self.ax_zoomed=True\\n else:\\n self.updatePlot()\\n \\n else:\\n # No need to re-draw the canvas if it's not a left or right click\\n return\\n \\n event.canvas.draw()\",\n \"def update_flags(self):\\n # view mode, filled vs wirefrom\\n if self.view['wireframe']:\\n gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_LINE)\\n else:\\n gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_FILL)\\n\\n # set fullscreen or windowed\\n self.set_fullscreen(fullscreen=self.view['fullscreen'])\\n\\n # backface culling on or off\\n if self.view['cull']:\\n gl.glEnable(gl.GL_CULL_FACE)\\n else:\\n gl.glDisable(gl.GL_CULL_FACE)\\n\\n # case where we WANT an axis and NO vertexlist\\n # is stored internally\\n if self.view['axis'] and self._axis is None:\\n from .. import creation\\n # create an axis marker sized relative to the scene\\n axis = creation.axis(origin_size=self.scene.scale / 100)\\n # create ordered args for a vertex list\\n args = rendering.mesh_to_vertexlist(axis)\\n # store the axis as a reference\\n self._axis = self.batch.add_indexed(*args)\\n\\n # case where we DON'T want an axis but a vertexlist\\n # IS stored internally\\n elif not self.view['axis'] and self._axis is not None:\\n # remove the axis from the rendering batch\\n self._axis.delete()\\n # set the reference to None\\n self._axis = None\",\n \"def update(self):\\n\\t\\tprint(\\\"Plotting \\\" + str(str(self.values[\\\"Trial1\\\"][1]) + \\\" at \\\" + str(self.values[\\\"Trial1\\\"][0]) + \\\"\\\\n\\\"))\\n\\t\\tif self.clear:\\n\\t\\t\\tself.stream1.write(dict(x=[], y=[]))\\n\\t\\t\\tself.stream2.write(dict(x=[], y=[]))\\n\\t\\t\\tself.stream3.write(dict(x=[], y=[]))\\n\\t\\telse:\\n\\t\\t\\tself.stream1.write(dict(x=self.values[\\\"Trial1\\\"][0], y=self.values[\\\"Trial1\\\"][1]))#, trace=Bar)\\n\\t\\t\\tself.stream2.write(dict(x=self.values[\\\"Trial2\\\"][0], y=self.values[\\\"Trial2\\\"][1]))\\n\\t\\t\\tself.stream3.write(dict(x=self.values[\\\"Trial3\\\"][0], y=self.values[\\\"Trial3\\\"][1]))\",\n \"def xaxis ( self ) :\\n return self.__xaxis\",\n \"def xaxis ( self ) :\\n return self.__xaxis\",\n \"def update(self):\\n\\t\\tprint(\\\"Plotting \\\" + str(str(self.values[\\\"Trial\\\"][1]) + \\\" at \\\" + str(self.values[\\\"Trial\\\"][0]) + \\\"\\\\n\\\"))\\n\\t\\tif self.clear:\\n\\t\\t\\tself.stream.write(dict(x=[], y=[]))\\n\\t\\telse:\\n\\t\\t\\tself.stream.write(dict(x=self.values[\\\"Trial\\\"][0], y=self.values[\\\"Trial\\\"][1]))\",\n \"def xaxis ( self ) :\\n return self.__xaxis\",\n \"def status(self,axis):\\n \\n if not self.enabled:\\n return (False,False)\\n \\n enabled = True\\n self.send_cmd(axis, ' PRINT MVG')\\n\\n flag = self.ser.read(100)\\n moving = True\\n \\n if flag[:4] == b'FALS': \\n moving = False\\n elif flag[:4] == b'TRUE':\\n moving = True\\n\\n non_moving = not moving\\n return (enabled, non_moving)\",\n \"def ready(self):\\n plt.ion()\\n self.figure = plt.figure()\\n axes = self.figure.add_subplot(111)\\n self.line, = axes.plot(self.xs, self._get_y_data(), self.colour)\\n\\n if self.y_range is not None:\\n plt.ylim(*self.y_range)\\n plt.xlim(self.x.lower, self.x.upper)\\n\\n plt.xlabel(self.x.tex_name if self.use_tex else self.x.name)\\n plt.ylabel(self.y.tex_name if self.use_tex else self.y.name)\\n\\n self.figure.canvas.draw()\",\n \"def updatePlot(self):\\n if len(self.baslin):\\n X = list(t[0] for t in self.baslin)\\n Y = list(t[1] for t in self.baslin)\\n self.BLplt.set_xdata(X)\\n self.BLplt.set_ydata(Y)\\n if self.BLtyp == 'S':\\n if self.BL is None:\\n self.BL, = self.axes.plot(self.data[0], self.data[2], linestyle='-', color='green')\\n else:\\n self.BL.set_ydata(self.data[2])\\n self.canvas.draw()\",\n \"def initialize_axes(self):\\r\\n self.x_lim = np.array([self.vals[:, 0].min(), self.vals[:, 0].max()])\\r\\n self.y_lim = np.array([self.vals[:, 1].min(), self.vals[:, 1].max()])\\r\\n self.z_lim = np.array([self.vals[:, 2].min(), self.vals[:, 2].max()])\",\n \"def listen_and_send(self):\\n hadEvent = False\\n\\n if not self.axis_data:\\n self.axis_data = {}\\n\\n if not self.button_data:\\n self.button_data = {}\\n for i in range(self.controller.get_numbuttons()):\\n self.button_data[i] = False\\n\\n if not self.hat_data:\\n self.hat_data = {}\\n for i in range(self.controller.get_numhats()):\\n self.hat_data[i] = (0, 0)\\n\\n while True:\\n for event in pygame.event.get():\\n if event.type == pygame.JOYAXISMOTION:\\n self.axis_data[event.axis] = round(event.value, 2)\\n elif event.type == pygame.JOYBUTTONDOWN:\\n self.button_data[event.button] = True\\n elif event.type == pygame.JOYBUTTONUP:\\n self.button_data[event.button] = False\\n elif event.type == pygame.JOYHATMOTION:\\n self.hat_data[event.hat] = event.value\\n\\n if event.type == pygame.JOYBUTTONDOWN:\\n # A button on the joystick just got pushed down\\n hadEvent = True\\n elif event.type == pygame.JOYAXISMOTION:\\n # A joystick has been moved\\n hadEvent = True\\n\\n if hadEvent:\\n\\n # If platform is linux we need to change some values in axis_data\\n os.system('clear')\\n print(\\\"Axis before\\\")\\n pprint.pprint(self.axis_data)\\n if sys.platform == 'linux':\\n #self.axis_data[2], self.axis_data[3], self.axis_data[4] = self.axis_data[4], self.axis_data[2], self.axis_data[3]\\n temp2 = self.axis_data[2]\\n temp3 = self.axis_data[3]\\n temp4 = self.axis_data[4]\\n self.axis_data[2] = temp4\\n self.axis_data[3] = temp2\\n self.axis_data[4] = temp3\\n\\n\\n self.event_dict['axis'] = self.axis_data\\n self.event_dict['button'] = self.button_data\\n message = pickle.dumps(self.event_dict, protocol=4)\\n message = bytes(f\\\"{len(message):<{HEADERSIZE}}\\\", 'utf-8') + message\\n self.sock.sendall(message)\\n\\n #if self.button_data[4]:\\n # self.verbose = not self.verbose\\n\\n if self.verbose:\\n\\n # print(\\\"Button \\\")\\n # pprint.pprint(self.button_data)\\n print(\\\"Axis \\\")\\n pprint.pprint(self.axis_data)\\n # print(\\\"Motion \\\")\\n # pprint.pprint(self.hat_data)\",\n \"def update_velocities(self, wx, wy):\\r\\n self.wx = wx\\r\\n self.wy = wy\",\n \"def set_axis(self, axis_list):\\n if self.table_ready:\\n final_axis_list = []\\n for i, axis in enumerate(axis_list):\\n if axis:\\n final_axis_list.append(\\\"1 \\\" + str(i + 1))\\n else:\\n final_axis_list.append(\\\"0 \\\" + str(i + 1))\\n\\n command = self.build_command(\\n self.device, (\\\"set_axis\\\", final_axis_list), single_commands=True\\n )\\n self.vcw.write(self.device, command)\",\n \"def plot_config(self):\\n self.dynamic.current_plot.setTitle(\\n \\\"Dynamic IV waiting time analysis\\\", **self.titleStyle\\n )\\n self.dynamic.current_plot.setLabel(\\n \\\"left\\\", \\\"current\\\", units=\\\"A\\\", **self.labelStyle\\n )\\n self.dynamic.current_plot.setLabel(\\n \\\"bottom\\\", \\\"time\\\", units=\\\"s\\\", **self.labelStyle\\n )\\n self.dynamic.current_plot.showAxis(\\\"top\\\", show=True)\\n self.dynamic.current_plot.showAxis(\\\"right\\\", show=True)\\n self.dynamic.current_plot.plotItem.showGrid(x=True, y=True)\\n self.dynamic.current_plot.getPlotItem().invertY(True)\\n\\n change_axis_ticks(self.dynamic.current_plot, self.ticksStyle)\",\n \"def x_axis_changed(self):\\n\\t\\tx_coord_cbox = self.ui.findChild(QWidget, \\\"x_coord_cbox\\\")\\n\\t\\tnew_axis = x_coord_cbox.currentText()\\n\\t\\tprint new_axis\",\n \"def setup_datavault(self, x_axis, y_axis):\\n\\n yield self.dv.cd(['', self.name], True)\\n\\n # datasets for each laser\\n self.dataset = yield self.dv.new(self.name + ' ML', [( 't', 'num')], [('GHz', '', 'num')])\",\n \"def centerAxis():\\n dislin.center()\",\n \"def show_axes(self):\\n if hasattr(self, 'axes_widget'):\\n self.axes_widget.EnabledOn()\\n self.axes_widget.SetCurrentRenderer(self)\\n else:\\n self.add_axes()\\n self.Modified()\",\n \"def __init__(self, *args, **kwargs):\\n # Set tick length to zero so azimuthal labels are not too offset\\n # Change default radial axis formatter but keep default theta one\\n super().__init__(*args, **kwargs)\\n formatter = axistools.Formatter('auto')\\n self.yaxis.set_major_formatter(formatter)\\n self.yaxis.isDefault_majfmt = True\\n for axis in (self.xaxis, self.yaxis):\\n axis.set_tick_params(which='both', size=0)\",\n \"def __init__(self):\\n self.wnd = WindSensor()\",\n \"def __init__(self, x):\\n self.W = np.zeros((x+1,10))\\n self.alpha = 0.00000001\\n self.epochs = 100\\n self.reg_const = 0.01\",\n \"def __init__(self, ax=None):\\n\\n if ax is None:\\n f = plt.figure()\\n self.ax = f.add_subplot(111)\\n else:\\n self.ax = ax\\n\\n self.e2 = [] # list to store RMS error results\\n self.labels = []\\n self.colors = []\",\n \"def tick(self):\\r\\n pass\",\n \"def get_toggle_axes_args(self,comArgs):\\n params, flags = self.get_params(comArgs)\\n args = [flags, False]\\n return args\",\n \"def init(self, info):\\r\\n# info.object.mpl_setup()\\r\\n return True\",\n \"def __init__(self, slit_width_xaxis, slit_height_zaxis):\\n super(SwScreen, self).__init__()\\n self.sw = self.create_instance()\\n\\n self.set_output_files(fwrite=0, f_angle=0) #write all, TODO: remove\\n\\n n_screen = 1\\n i_screen = np.array([1, 0, 0, 0, 0, 0, 0, 0, 0, 0])\\n i_abs = np.zeros(10)\\n i_slit = np.zeros(10)\\n i_stop = np.zeros(10)\\n k_slit = np.zeros(10)\\n thick = np.zeros(10)\\n file_abs = np.array(['', '', '', '', '', '', '', '', '', ''])\\n rx_slit = np.zeros(10)\\n rz_slit = np.zeros(10)\\n sl_dis = np.zeros(10)\\n file_src_ext = np.array(['', '', '', '', '', '', '', '', '', ''])\\n cx_slit = np.zeros(10)\\n cz_slit = np.zeros(10)\\n\\n i_abs[0] = 0 # NO ABSORPTION\\n i_slit[0] = 0 # APERTURING\\n i_stop[0] = 0 # SLIT\\n k_slit[0] = 0 # RECTANGULAR\\n\\n rx_slit[0] = slit_width_xaxis\\n rz_slit[0] = slit_height_zaxis\\n cx_slit[0] = 0.0\\n cz_slit[0] = 0.0\\n\\n self.sw._oe.set_screens(n_screen,\\n i_screen,\\n i_abs,\\n sl_dis,\\n i_slit,\\n i_stop,\\n k_slit,\\n thick,\\n file_abs,\\n rx_slit,\\n rz_slit,\\n cx_slit,\\n cz_slit,\\n file_src_ext)\",\n \"def drawAxis(image, cameraMatrix, distCoeffs, rvec, tvec, length):\\n pass\",\n \"def set_data(self, x = None, y = None):\\n self.x_axis = x\\n self.y_axis = y\",\n \"def __init__(self):\\n self.Robot = Robot()\\n self.Omega = matrix()\\n # self.Omega.value[0][0] = 1.0\\n # self.Omega.value[1][1] = 1.0\\n self.Xi = matrix()\\n # Xi.value[0][0] = 0.0\\n # Xi.value[1][0] = 0.0\\n self.measure = {}\\n self.landMarkCount = 0\\n self.init = False\\n self.bearing = 0\\n self.x = 0\\n self.y = 0\\n \\n # TODO\",\n \"def plotWavelet(self):\\n\\n a = 0\\n if(self.axQT is not None):\\n self._bxPlot()\\n a += 1\\n if(self.bxQT is not None):\\n self._cxPlot()\\n a += 1\\n\\n if(a > 0):\\n return\\n\\n self._setupPlot()\\n self._axPlot()\\n self._bxPlot()\\n self._cxPlot()\\n self._dxPlot()\\n self._endingPlot()\",\n \"def __init__(self, ds, check_dims=True, x_periodic=True, y_periodic=True,\\n z_periodic=False):\\n self._ds = ds\\n self._check_dims = check_dims\\n self._periodic = {'X': x_periodic, 'Y': y_periodic, 'Z': z_periodic}\\n\\n self._axes = OrderedDict()\\n for ax in ['X', 'Y']:\\n # figure out what the grid dimensions are\\n coord_names = comodo.get_axis_coords(ds, ax)\\n ncoords = len(coord_names)\\n if ncoords == 0:\\n # didn't find anything for this axis\\n pass\\n else:\\n if ncoords != 2:\\n raise ValueError('Must have two different %s coordinates. '\\n 'Instead got %s' % (ax, repr(coord_names)))\\n axis_data = OrderedDict()\\n for name in coord_names:\\n coord = ds[name]\\n axis_shift = coord.attrs.get('c_grid_axis_shift')\\n if (axis_shift is None) or (axis_shift == 0):\\n # we found the center coordinate\\n axis_data['c'] = name\\n axis_data['c_coord'] = coord\\n elif (axis_shift==0.5) or (axis_shift==-0.5):\\n # we found the face coordinate\\n axis_data['g'] = name\\n axis_data['g_coord'] = coord\\n # TODO: clearly document the sign convention\\n axis_data['shift'] = 1 if axis_shift==0.5 else -1\\n else:\\n raise ValueError('Invalid c_grid_axis_shift (%g) for '\\n 'coord %s' % (axis_shift, name))\\n self._axes[ax] = axis_data\\n\\n # check grid size consistency\\n # we can deal with two cases:\\n # * the c dim and g dim are the same size\\n # * the g dim is one element longer than the c dim\\n # define a slice used to subset\\n for ax, info in iteritems(self._axes):\\n clen = len(info['c_coord'])\\n glen = len(info['g_coord'])\\n if clen==glen:\\n # all good\\n self._axes[ax]['pad'] = 0\\n elif clen==(glen - 1):\\n self._axes[ax]['pad'] = 1\\n else:\\n raise ValueError(\\\"Incompatible c and g dimension lengths on \\\"\\n \\\"axis %s (%g, %g)\\\" % (ax, clen, glen))\",\n \"def initRunningVals(self):\\n self.r_Vm = [0.0]*self.mirror.dataPoints\\n self.r_Va = [0.0]*self.mirror.dataPoints\",\n \"def __init__(self):\\n\\n self.__name = '{}_{}'.format(type(self).__name__, id(self))\\n self.__xax = 0\\n self.__yax = 0\\n\\n self.addListener('zax', self.__name, self.__zaxChanged, immediate=True)\\n self.__zaxChanged()\",\n \"def init_axes(self):\\n plt.switch_backend(\\\"cairo\\\")\\n fig = plt.figure(figsize=(15,10))\\n ax = fig.add_axes([0.05, 0.15, 0.9, 0.80,])\\n return (fig, ax)\",\n \"def reset(self):\\n # Don't reset axis labels\\n self.range = ((0, 2, 1),) * self.ndim\\n self.current_step = (0,) * self.ndim\\n self.order = tuple(range(self.ndim))\",\n \"def __init__(self, x_0, y_0, initX, initY,h=5):\\n self.x_0=x_0\\n self.y_0=y_0\\n self.x_init=initX\\n self.y_init=initY\\n self.step=h\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6247041","0.6213832","0.6022709","0.602028","0.5989789","0.59698653","0.59595746","0.5930603","0.5922851","0.5920339","0.58486426","0.5825133","0.57882136","0.5785074","0.5751861","0.57397544","0.57143","0.5657272","0.56560445","0.5648683","0.56252724","0.5620141","0.5607352","0.56034017","0.55876297","0.5564904","0.5549435","0.55394316","0.55391467","0.55177075","0.5506144","0.54896486","0.54881406","0.5482634","0.54634494","0.5451611","0.5445422","0.5445422","0.54396534","0.54368556","0.54267716","0.5417533","0.5408815","0.5401683","0.5399429","0.5391471","0.5388643","0.53855836","0.5374117","0.53591186","0.5355355","0.5335805","0.5332584","0.532594","0.532482","0.53234994","0.5323361","0.53086084","0.52901417","0.5273782","0.5272496","0.52706426","0.525273","0.5248996","0.5246375","0.5240455","0.5228327","0.52179444","0.52179444","0.5217278","0.5216129","0.5205658","0.5201598","0.51980513","0.519299","0.5192254","0.518811","0.5184326","0.51769227","0.51725215","0.5170558","0.5169305","0.51564753","0.5147242","0.51471615","0.51418364","0.513279","0.5130735","0.513003","0.512716","0.51182646","0.511391","0.50975055","0.5097046","0.50955075","0.5094579","0.5086688","0.5085638","0.5085628","0.5079593","0.50771314"],"string":"[\n \"0.6247041\",\n \"0.6213832\",\n \"0.6022709\",\n \"0.602028\",\n \"0.5989789\",\n \"0.59698653\",\n \"0.59595746\",\n \"0.5930603\",\n \"0.5922851\",\n \"0.5920339\",\n \"0.58486426\",\n \"0.5825133\",\n \"0.57882136\",\n \"0.5785074\",\n \"0.5751861\",\n \"0.57397544\",\n \"0.57143\",\n \"0.5657272\",\n \"0.56560445\",\n \"0.5648683\",\n \"0.56252724\",\n \"0.5620141\",\n \"0.5607352\",\n \"0.56034017\",\n \"0.55876297\",\n \"0.5564904\",\n \"0.5549435\",\n \"0.55394316\",\n \"0.55391467\",\n \"0.55177075\",\n \"0.5506144\",\n \"0.54896486\",\n \"0.54881406\",\n \"0.5482634\",\n \"0.54634494\",\n \"0.5451611\",\n \"0.5445422\",\n \"0.5445422\",\n \"0.54396534\",\n \"0.54368556\",\n \"0.54267716\",\n \"0.5417533\",\n \"0.5408815\",\n \"0.5401683\",\n \"0.5399429\",\n \"0.5391471\",\n \"0.5388643\",\n \"0.53855836\",\n \"0.5374117\",\n \"0.53591186\",\n \"0.5355355\",\n \"0.5335805\",\n \"0.5332584\",\n \"0.532594\",\n \"0.532482\",\n \"0.53234994\",\n \"0.5323361\",\n \"0.53086084\",\n \"0.52901417\",\n \"0.5273782\",\n \"0.5272496\",\n \"0.52706426\",\n \"0.525273\",\n \"0.5248996\",\n \"0.5246375\",\n \"0.5240455\",\n \"0.5228327\",\n \"0.52179444\",\n \"0.52179444\",\n \"0.5217278\",\n \"0.5216129\",\n \"0.5205658\",\n \"0.5201598\",\n \"0.51980513\",\n \"0.519299\",\n \"0.5192254\",\n \"0.518811\",\n \"0.5184326\",\n \"0.51769227\",\n \"0.51725215\",\n \"0.5170558\",\n \"0.5169305\",\n \"0.51564753\",\n \"0.5147242\",\n \"0.51471615\",\n \"0.51418364\",\n \"0.513279\",\n \"0.5130735\",\n \"0.513003\",\n \"0.512716\",\n \"0.51182646\",\n \"0.511391\",\n \"0.50975055\",\n \"0.5097046\",\n \"0.50955075\",\n \"0.5094579\",\n \"0.5086688\",\n \"0.5085638\",\n \"0.5085628\",\n \"0.5079593\",\n \"0.50771314\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":486,"cells":{"query":{"kind":"string","value":"ne on, hgcd on, ff off, doHartmann, ne off, hgcd off"},"document":{"kind":"string","value":"def test_goto_field_boss_hartmann(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doSlew = False\n cmdState.doCalibs = False\n cmdState.arcTime = 0\n cmdState.flatTime = 0\n cmdState.doGuider = False\n self._goto_field_boss(5, 29, 0, 0, cmdState)"},"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 genfb_py(h, n, u, v, f, dt, dx, dy, du,dv,dn, gridu,gridv,gridn, threadblock, beta=0.281105, eps=0.013, gamma=0.0880, mu=0.3, nu=0, dudt_x=dudt, dvdt_x=dvdt, dndt_x=dndt, grav=True, cori=True, advx=True, advy=True, attn=True, ): # generalized forward backward feedback timestep\n \n p5 = np.float32(0.5)\n one = np.float32(1)\n p32 = np.float32(1.5)\n beta = np.float32(beta)\n eps = np.float32(eps)\n gamma= np.float32(gamma)\n mu = np.float32(mu)\n \n dn_m1,dn_m2,dn_m0 = dn # dn[0], dn[1], dn[2] # unpack\n if dn_m1 is dn_m2 or dn_m1 is dn_m0:\n print (\"error dn_m1\")\n if dn_m2 is dn_m0: \n print (\"error dn_m0\")\n print( dn_m1[280,5],dn_m2[280,5],dn_m0[280,5]) \n# hn = n.copy_to_host()\n# print ('n', hn.shape,n.shape, np.argmax(hn),np.max(hn),np.argmin(hn),np.min(hn))\n# hn = u.copy_to_host()\n# print ('u', hn.shape,n.shape, np.argmax(hn),np.max(hn),np.argmin(hn),np.min(hn))\n# hn = v.copy_to_host()\n# print ('v', hn.shape,n.shape, np.argmax(hn),np.max(hn),np.argmin(hn),np.min(hn))\n dndt_x[gridn, threadblock](h, n, u, v, dx, dy, dn_m0)\n \n # must do the following before the u and v !\n #n1 = n + ((p32+beta)* dn_m0 - (p5+beta+beta)* dn_m1+ (beta)* dn_m2)*dt\n# n_m0 = dn_m0.copy_to_host()\n# print ('dn_m0',dn_m0.shape,np.argmax(n_m0),np.max(n_m0),np.argmin(n_m0),np.min(n_m0))\n# lincomb4_cuda[gridn,threadblock](n, dn_m0, dn_m1, dn_m2, one, (p32+beta)*dt, -(p5+beta+beta)*dt, (beta)*dt, n)\n \n h_n = n.copy_to_host()\n hn_m0 = dn_m0.copy_to_host()\n hn_m1 = dn_m1.copy_to_host()\n hn_m2 = dn_m2.copy_to_host()\n h_n = h_n+(p32+beta)*dt*hn_m0 -(p5+beta+beta)*dt*hn_m0+(beta)*dt*hn_m0\n n[:]=h_n\n \n \n \n du_m0,du_m1,du_m2,du_p1 = du # du[0], du[1], du[2], du[3] # unpack\n# if du_p1 is du_m0 or du_p1 is du_m1 or du_p1 is du_m2:\n# print (\"error du_p1\")\n# if du_m0 is du_m2 or du_m0 is du_m1 :\n# print (\"error du_m0\")\n# if du_m2 is du_m1:\n# print (\"error du_m1\")\n print( du_m0[280,5],du_m1[280,5],du_m2[280,5],du_p1[280,5]) \n dudt_x[gridu, threadblock](h, n, f, u, v, dx, dy, du_p1, grav, cori, advx, advy, attn,nu,mu)\n\n dv_m0,dv_m1,dv_m2,dv_p1 = dv #dv[0], dv[1], dv[2], dv[3] # unpack \n print( dv_m0[280,5],dv_m1[280,5],dv_m2[280,5],dv_p1[280,5]) \n dvdt_x[gridv, threadblock](h, n, f, u, v, dx, dy, dv_p1, grav, cori, advx, advy, attn,nu,mu)\n \n #u1 = u+ ((p5+gamma+eps+eps)*du_p1 +(p5-gamma-gamma-eps-eps-eps)*du_m0 +gamma*du_m1+eps*du_m2)*dt\n # lincomb5_cuda[gridu,threadblock](u, du_p1, du_m0, du_m1, du_m2, one, (p5+gamma+eps+eps)*dt, (p5-gamma-gamma-eps-eps-eps)*dt, gamma*dt, eps*dt, u)\n lincomb5_cuda[gridu,threadblock](u, du_p1, du_m0, du_m1, du_m2, one, one*dt, np.float32(0.0), np.float32(0.0), np.float32(0.0), u)\n\n #v1 = v+ ((p5+gamma+eps+eps)*dv_p1 +(p5-gamma-gamma-eps-eps-eps)*dv_m0 +gamma*dv_m1+eps*dv_m2)*dt\n # lincomb5_cuda[gridv,threadblock](v, dv_p1, dv_m0, dv_m1, dv_m2, one, (p5+gamma+eps+eps)*dt, (p5-gamma-gamma-eps-eps-eps)*dt, gamma*dt, eps*dt, v)\n lincomb5_cuda[gridv,threadblock](v, dv_p1, dv_m0, dv_m1, dv_m2, one, one*dt, np.float32(0.0), np.float32(0.0), np.float32(0.0), v)\n \n\n dv = [ dv_p1,dv_m0,dv_m1,dv_m2 ]\n du = [ du_p1,du_m0,du_m1,du_m2 ]\n dn = [ dn_m0,dn_m1,dn_m2 ]\n return du, dv, dn","def fredkin(ha, hb, hc):\n\n return controlled_U(ha, swap(hb, hc))","def genfb(h, n, u, v, f, dt, dx, dy, du,dv,dn, beta=0.281105, eps=0.013, gamma=0.0880, mu=0.3, nu=0, dudt_x=dudt, dvdt_x=dvdt, dndt_x=dndt, grav=True, cori=True, advx=True, advy=True, attn=True): # generalized forward backward feedback timestep\n \n beta = np.float32(beta)\n eps = np.float32(eps)\n gamma = np.float32(gamma)\n mu = np.float32(mu)\n \n \n dn_m1,dn_m2,dn_m0 = dn # unpack\n dndt_x(h, n, u, v, dx, dy, dn_m0)\n \n# test_out = dn_m0.copy()\n# dndt(h, n, u, v, dx, dy, test_out)\n \n# test_dif = dn_m0-test_out\n# if np.max(np.abs(test_dif[1:-1,1:-1] )) >1E-5 :\n# test_dif[1:-1,5][np.abs(test_dif[1:-1,5] ) <1E-5]=0.0\n# print (\"dn diff 2\")\n# print (test_dif[:,5])\n \n #dn_m0[:]=test_out \n\n # must do the following before the u and v !\n n1 = n + ((p32+beta)* dn_m0 - (p5+beta+beta)* dn_m1+ (beta)* dn_m2)*dt\n #del dn_m2\n du_m0,du_m1,du_m2,du_p1 = du # unpack\n dudt_x(h, n1, f, u, v, dx, dy, du_p1, grav=grav, cori=cori, advx=advx, advy=advy, attn=attn,nu=nu,mu=mu)\n\n dv_m0,dv_m1,dv_m2,dv_p1 = dv # unpack \n dvdt_x(h, n1, f, u, v, dx, dy, dv_p1, grav=grav, cori=cori, advx=advx, advy=advy, attn=attn,nu=nu,mu=mu)\n \n# test_out = du_p1.copy()\n# dudt(h, n1, f, u, v, dx, dy, test_out)\n \n# test_dif = du_p1-test_out\n# if np.max(np.abs(test_dif[1:-1,5] )) >1E-5 :\n# test_dif[1:-1,5][np.abs(test_dif[1:-1,5] ) <1E-5]=0.0\n# print (\"du diff\")\n# print (test_dif[:,5])\n \n# #du_p1[:] = test_out\n\n# test_out = dv_p1.copy()\n# dvdt(h, n1, f, u, v, dx, dy, test_out)\n \n# test_dif = dv_p1-test_out\n# if np.max(np.abs(test_dif[1:-1,5] )) >1E-5 :\n# test_dif[1:-1,5][np.max(test_dif[1:-1,5] ) <1E-5]=0.0\n# print (\"dv diff\")\n# print (test_dif[:,5])\n \n #dv_p1[:] = test_out\n \n u1 = u+ ((p5+gamma+eps+eps)*du_p1 +(p5-gamma-gamma-eps-eps-eps)*du_m0 +gamma*du_m1+eps*du_m2)*dt\n # del du_m2\n v1 = v+ ((p5+gamma+eps+eps)*dv_p1 +(p5-gamma-gamma-eps-eps-eps)*dv_m0 +gamma*dv_m1+eps*dv_m2)*dt\n # del dv_m2\n\n\n \n \n dv = [ dv_p1,dv_m0,dv_m1,dv_m2 ]\n du = [ du_p1,du_m0,du_m1,du_m2 ]\n dn = [ dn_m0,dn_m1,dn_m2 ]\n# n[:,:], u[:,:], v[:,:], = n1, u1, v1\n return n1, u1, v1, du,dv,dn","def test_G_H(self):\r\n chkmtx = (numpy.dot(golay.DEFAULT_G, golay.DEFAULT_H.T) % 2)\r\n self.assertTrue((chkmtx == 0).all())","def __init__(self, N: int, P: int, H: int, csdfg_fwd: CompiledSDFG,\n csdfg_bwd: CompiledSDFG):\n super().__init__()\n\n class DaceMHAFunction(torch.autograd.Function):\n @staticmethod\n def forward(ctx, Q, K, V, WQ, WK, WV, WO, BQ, BK, BV, BO, scaler):\n B, SN, N = Q.shape\n _, SM, _ = K.shape\n output = torch.empty([B, SN, N], device=Q.device)\n csdfg_fwd(k=K.contiguous(),\n q=Q.contiguous(),\n v=V.contiguous(),\n __return=output,\n wk=WK.contiguous(),\n wq=WQ.contiguous(),\n wv=WV.contiguous(),\n wo=WO.contiguous(),\n bk=BK.contiguous(),\n bq=BQ.contiguous(),\n bv=BV.contiguous(),\n bo=BO.contiguous(),\n scaler=scaler.item(),\n B=B,\n P=P,\n H=H,\n N=H * P,\n SN=SN,\n SM=SM)\n ctx.save_for_backward(Q, K, V, output)\n return output\n\n @staticmethod\n def backward(ctx, grads):\n # ctx.saved_tensors\n output = torch.empty_like(K, device='cuda')\n gK, gQ, gV, gWK, gWQ, gWV = [\n torch.empty(grads.shape, grads.dtype) for _ in range(6)\n ]\n csdfg_bwd(output=output,\n gK=gK,\n gQ=gQ,\n gV=gV,\n gWK=gWK,\n gWQ=gWQ,\n gWV=gWV)\n return gK, gQ, gV, gWK, gWQ, gWV\n\n self.P = P\n self.H = H\n self.N = N\n\n self.op = DaceMHAFunction\n self.WK = torch.nn.Parameter(torch.Tensor(P, H, P * H))\n self.WQ = torch.nn.Parameter(torch.Tensor(P, H, P * H))\n self.WV = torch.nn.Parameter(torch.Tensor(P, H, P * H))\n self.WO = torch.nn.Parameter(torch.Tensor(P, H, P * H))\n self.BK = torch.nn.Parameter(torch.Tensor(P, H))\n self.BQ = torch.nn.Parameter(torch.Tensor(P, H))\n self.BV = torch.nn.Parameter(torch.Tensor(P, H))\n self.BO = torch.nn.Parameter(torch.Tensor(N))\n self.scaler = torch.tensor([P**-0.5], dtype=torch_dtype)\n\n # Initialize parameters\n xavier_uniform_(self.WK)\n xavier_uniform_(self.WQ)\n xavier_uniform_(self.WV)\n xavier_uniform_(self.WO)\n\n uniform_(self.BK)\n uniform_(self.BQ)\n uniform_(self.BV)\n uniform_(self.BO)","def main():\n regexham = r'\\s+\\((\\d+,\\s*\\d+)\\)\\s+([\\-+]?\\d+\\.\\d+[eEdD]?[\\-+]?\\d+)' #to extract the Hamiltonian.\n root = '.'\n #fname = 'output_files/'\n ciffci = CIFlow_Reader('testfci.dat', regexp = regexham , read_ham= True)\n ciffcipar = CIFlow_Reader( 'psi0_output10outputfci.dat', regexp = regexham , read_ham = True)\n #print ciffci.calc_overlap(cifdoci)\n #print e.get_groundstate('00000000000011|00000000000011') \n\n psir = rp.PsiReader('psi0_output10.dat', isbig = False, numorbs = -1 , read_ints = False)\n\n detlist = dw.cimain(psir.values['nalpha'],psir.values['nbeta'], psir.values['norb'], [range(1,psir.values['nalpha']+psir.values['nbeta']), []], [] , fname = 'determinants.dat' ,ref = [lambda x , y , z : psir.get_hf_orbs()] , add_frozen = 0, write = False) #CISDDOCI\n count = 0\n for det in detlist:\n for det2 in detlist:\n #+ because the eigenvectors have already a different phasefactor of 1.\n if abs(ciffci.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) - ciffcipar.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) ) > 1e-10 :\n print 'difference in hamiltonian row: ' , det[0]+'|'+det[1] , \" col: \" , det2[0]+'|'+det2[1] , 'fci: ', ciffci.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) , 'fciaddres: ' , ciffcipar.get_mat_element(det[0]+'|'+det[1],det2[0]+'|'+det2[1]) \n count += 1\n print 'There were ' , count , ' different elements'","def hemianopsia_hard(hemi='left',dprime_fnc=dprime_basic):\n def hemianopsia_fnc(distance):\n if (hemi == 'left' and distance[0] < 0) or (hemi == 'right' and distance[0] > 0):\n return SMALL_FLOAT\n else:\n return dprime_fnc(distance)\n return hemianopsia_fnc","def exp_mod(a, b, nbr):\n bina = [int(x) for x in bin(a)[2:]]\n #binb = [int(x) for x in bin(b)[2:]]\n binn = [int(x) for x in bin(nbr)[2:]]\n #while len(binn)<len(bina):\n # binn = [0]+binn\n #print(bina, binn)\n binn.reverse()\n bina.reverse()\n n = len(bina)+len(binn)*4+1\n na = len(bina)\n nan = len(bina)+len(binn) # debut de Y\n nany = len(bina)+2*len(binn)+1 # debut de \"A\" (ici c'est b)\n nanya = len(bina)+3*len(binn)+1 # debut de \"APOW\" (ce qui doit etre mesuré)\n q = QuantumRegister(n+2, 'q') # +lost+lost2\n circ = QuantumCircuit(q)\n for i in range(na):\n if bina[i]:\n circ.x(q[i])\n for i in range(len(binn)):\n if binn[i]:\n circ.x(q[na+i])\n expmod(circ, q, # X, a, A, APOW, Y, n, N, binn, lost, lost2)\n [q[i] for i in range(len(bina))],\n b%nbr,\n [q[i+nany] for i in range(len(binn))],\n [q[i+nanya] for i in range(len(binn))],\n [q[i+nan] for i in range(len(binn)+1)],\n nbr,\n [q[i+na] for i in range(len(binn))],\n binn,\n q[n],\n q[n+1])\n if len(bina)%2:\n circ_m = measure(circ, q, [i for i in range(nan,nany)])\n else:\n circ_m = measure(circ, q, [i for i in range(nanya,n)])\n #circ_m = measure(circ, q, [i for i in range(n)])\n return circ_m","def chk_hamming(data):\n pass","def zzx_heu_gcd(f, g, **flags):\n def interpolate(h, x):\n f = []\n\n while h:\n g = h % x\n\n if g > x // 2:\n g -= x\n\n f.insert(0, g)\n h = (h-g) // x\n\n return f\n\n def finalize(h, cff, cfg, gcd):\n h = zzx_mul_const(h, gcd)\n return h, cff, cfg\n\n if not (f or g):\n return [], [], []\n elif not f:\n return g, [], [1]\n elif not g:\n return f, [1], []\n\n df = zzx_degree(f)\n dg = zzx_degree(g)\n\n cf = zzx_content(f)\n cg = zzx_content(g)\n\n gcd = igcd(cf, cg)\n\n f = [ c // gcd for c in f ]\n g = [ c // gcd for c in g ]\n\n if df == 0 or dg == 0:\n return [gcd], f, g\n\n f_norm = zzx_max_norm(f)\n g_norm = zzx_max_norm(g)\n\n B = 2*min(f_norm, g_norm) + 29\n\n x = max(min(B, 99*INT_TYPE(isqrt(B))),\n 2*min(f_norm // abs(poly_LC(f)),\n g_norm // abs(poly_LC(g))) + 2)\n\n for i in xrange(0, 6):\n ff = zzx_eval(f, x)\n gg = zzx_eval(g, x)\n\n if ff and gg:\n h = igcd(ff, gg)\n\n cff = ff // h\n cfg = gg // h\n\n h = interpolate(h, x)\n h = zzx_primitive(h)[1]\n\n cff_, r = zzx_div(f, h)\n\n if not r:\n cfg_, r = zzx_div(g, h)\n\n if not r:\n return finalize(h, cff_, cfg_, gcd)\n\n cff = interpolate(cff, x)\n\n h, r = zzx_div(f, cff)\n\n if not r:\n cfg_, r = zzx_div(g, h)\n\n if not r:\n return finalize(h, cff, cfg_, gcd)\n\n cfg = interpolate(cfg, x)\n\n h, r = zzx_div(g, cfg)\n\n if not r:\n cff_, r = zzx_div(f, h)\n\n if not r:\n return finalize(h, cff_, cfg, gcd)\n\n x = INT_TYPE(2.7319*x*isqrt(isqrt(x)))\n\n raise HeuristicGCDFailed('no luck')","def distcalc(z,h=0.70,omegalambda=0.7,omegam=0.3,omegak=0.0):\n\n H0 = 100 * h # this is in units of km/s/Mpc\n\n H0freq = H0 * constants.kilo/(constants.mega * constants.parsec) # this is H0 is units of Hz\n \n hubbletime = 1.0/H0freq # in seconds\n hubbletimeyr = hubbletime / constants.year\n\n #hubble distance\n dh = constants.c / H0freq # in meters\n\n #now i can calculate the comoving distance (line of sight) using hogg eqn 15\n dc = dh * integrate.quad(dcintegrand,0,z,(omegalambda,omegam,omegak))[0]\n\n #now i can find the transverse comoving distance using hogg eqn 16\n if omegak == 0:\n dm = dc\n elif omegak > 0:\n dm = dh/np.sqrt(omegak) * np.sinh(dc * np.sqrt(omegak) / dh)\n else:\n dm = dh/np.sqrt(abs(omegak)) * np.sin(dc * np.sqrt(abs(omegak)) / dh)\n\n\n #now i will calculate the angular diameter distance (hogg eqn 18)\n da = dm/(1+z)\n \n #now i will calculate scale in kpc/arcsec, since this is commonly used\n scale = da * constants.arcsec / (constants.kilo * constants.parsec)\n\n #now i will calculate the luminosity distance (hog eqn 21)\n dl = (1+z)*dm\n \n #now i will calculate lookback time and \n #time from the begining of the universe to that redshift using hogg eqn 30\n \n tlookback = hubbletimeyr * integrate.quad(timeintegrand,0,z,(omegalambda,omegam,omegak))[0]\n \n tz = hubbletimeyr * integrate.quad(timeintegrand,z,np.inf,(omegalambda,omegam,omegak))[0]\n \n #all sky co-moving volume out to redshift z (hogg eqn 30)\n if omegak == 0:\n vc = 4 * np.pi * dm**3 / 3\n elif omegak > 0:\n vc = ( 4 * np.pi * dh**3 / (2 * omegak) ) * ( dm * np.sqrt(1 + omegak * dm**2 / dh**2) / dh - \n np.arcsinh( np.sqrt(omegak) * dm / dh ) / np.sqrt(omegak) )\n else:\n vc = ( 4 * np.pi * dh**3 / (2 * omegak) ) * ( dm * np.sqrt(1 + omegak * dm**2 / dh**2) / dh - \n np.arcsin( np.sqrt(abs(omegak)) * dm / dh ) / np.sqrt(abs(omegak)) )\n\n #for output, i will make a dictionary\n output = dict(dh=dh, dc=dc, dm=dm, da=da, scale=scale, dl=dl, tlookback = tlookback, tz=tz, vc=vc)\n\n return output","def global_fn(self, h, e, g_state):\n N, K, _ = h.shape\n\n # Concatenate all relevant inputs.\n h = h.sum(dim=1)\n\n mask = torch.ones(1, K, K, 1)\n if torch.cuda.is_available():\n mask = mask.cuda()\n for kx1 in range(K):\n for kx2 in range(K):\n if kx1 != kx2-1:\n mask[:, kx1, kx2, :] = 0.\n #if kx1 == kx2:\n # mask[:, kx1, kx2, :] = 0.\n e = torch.sum(e*mask, dim=[1,2])\n\n x = torch.cat([h, e], dim=1).view(-1, 1, 2*self.n_hidden)\n output, g_n = self.G_gru(input=x,\n hx=g_state)\n output = output.view(N, self.n_hidden)\n return output, g_n","def Gamma01ph(ne,ng):\r\n\r\n return d(ne,ng)**2*domega(ne,ng)**3/(3*np.pi*epsilon_0*hbar*c**3)","def pollard_rho(g: int, h: int, n: int, order: int = None):\n x = {0: 1}\n a = {0: 0}\n b = {0: 0}\n\n import ressources.multGroup as multGroup\n\n if order is None:\n order = multGroup.multiplicativeOrder(g, n)\n\n # from a, b and c, partitioning the field\n def step_xab(x, a, b, g, h, order, n):\n s = x % 3\n\n # S1\n if s == 1:\n x = x * h % n\n b = (b + 1) % order\n\n # S2\n if s == 0:\n x = square_and_multiply(x, 2, n)\n a = 2 * a % order\n b = 2 * b % order\n\n # S3\n if s == 2:\n x = x * g % n\n a = (a + 1) % order\n\n return x, a, b\n\n # returns x, a, b for a given i using memoization\n def get_xab(i):\n\n if i not in x:\n _x, _a, _b = get_xab(i - 1)\n\n x[i], a[i], b[i] = step_xab(_x, _a, _b, g, h, order, n)\n\n return x[i], a[i], b[i]\n\n def naturals_from(i):\n while True:\n # yield is a keyword that is used like return, except the function will return a generator.\n # https://www.google.com/search?client=firefox-b-d&q=yield+python\n yield i\n i += 1\n\n for i in naturals_from(1):\n\n x_i, a_i, b_i = get_xab(i)\n x_2i, a_2i, b_2i = get_xab(2 * i)\n\n if x_i == x_2i:\n\n r = (b_i - b_2i) % order\n\n if r == 0:\n return False\n\n return multGroup.inv(r, order) * (a_2i - a_i) % order","def compute_gcd(first, second, n, gcd_factor): \n a = QuantumRegister(n, \"aq\")\n b = QuantumRegister(n, \"bq\")\n anc = QuantumRegister(2, \"ancq\")\n res = QuantumRegister(n, \"resq\")\n zero = QuantumRegister(2, \"zq\")\n anc_cl = ClassicalRegister(2, \"anccl\")\n zero_cl = ClassicalRegister(2, \"zcl\")\n a_cl = ClassicalRegister(n, \"acl\")\n b_cl = ClassicalRegister(n, \"bcl\") \n res_cl = ClassicalRegister(n, \"cl\")\n qc = QuantumCircuit(a, b, anc, res, zero, anc_cl, zero_cl, \n res_cl, a_cl, b_cl, name=\"qc\")\n\n for i in range(0, n):\n if first[i] == \"1\":\n qc.x(a[n-(i+1)])\n \n for i in range(0, n):\n if second[i] == \"1\":\n qc.x(b[n-(i+1)])\n\n for i in range(0, n):\n if gcd_factor[i] == \"1\":\n qc.x(res[n-(i+1)]) \n\n qc.measure(a,res_cl)\n qc.x(zero[0]).c_if(res_cl, 0)\n qc.measure(b, res_cl)\n qc.x(zero[1]).c_if(res_cl, 0)\n qc.measure(zero, zero_cl)\n #Resetting the zero qreg to 0, with zero_cl holding the zero status \n qc.x(zero[0]).c_if(res_cl, 0) \n qc.measure(a,res_cl) \n qc.x(zero[1]).c_if(res_cl, 0) \n #Resetting res_cl to zero again.\n for i in range(n):\n qc.measure(zero[0], res_cl[i]) \n\n #Checking for equality\n args = [a[x] for x in range(n)] + [b[x] for x in range(n)]\n csub = CompositeGate(\"csub\", [math.pi], args, circuit =\"qc\")\n csub = subtract.subtract(qc, n, math.pi, a, b, csub, -1)\n qc.measure(a, res_cl)\n qc.x(zero[0]).c_if(res_cl, 0)\n cadd = CompositeGate(\"csub\", [math.pi], args, circuit =\"qc\")\n cadd = subtract.subtract(qc, n, math.pi, a, b, cadd, 1)\n\n #Checking if either b, a or both are zero - if they are, then swap\n #the 1 in res_q out for a zero\n qc.swap(res[0], zero[0]).c_if(zero_cl, 1)\n qc.swap(res[0], zero[0]).c_if(zero_cl, 2)\n qc.swap(res[0], zero[0]).c_if(zero_cl, 3)\n #flip the 1 in zero_q to make zero_q on the zero state again.\n qc.x(zero[0]).c_if(zero_cl, 1)\n qc.x(zero[0]).c_if(zero_cl, 2)\n qc.x(zero[0]).c_if(zero_cl, 3) \n\n zero_status, gcd_factor, b_value, equality_status, a_value = \\\n gcd_main.gcd(qc, a, b, res, anc, zero, zero_cl, anc_cl, res_cl,\n n, a_cl, b_cl)\n\n return zero_status, gcd_factor, b_value, equality_status, a_value","def exotic(double[:] v, redshifts, in_terms, double H0):\n\n cdef double t = v[0]\n cdef double a = v[1]\n cdef double ombar_m = v[2]\n cdef double ombar_r = v[3]\n cdef double ombar_de = v[4]\n cdef double z = v[5]\n cdef double dl = v[6]\n cdef double gamma = in_terms[0]\n cdef double zeta = in_terms[1]\n\n cdef double Hz = H0 * (ombar_m +ombar_r +ombar_de)**(0.5)\n\n# if ombar_m < 0 or ombar_de < 0:\n# print('exotic')\n# print('z = %s, Hz = %s, gamma = %s, zeta = %s'% (z, Hz, gamma, zeta))\n# print('ombar_m = %s, ombar_r = %s, ombar_de = %s'\n# % (ombar_m, ombar_r, ombar_de))\n\n if math.isnan(Hz):\n print('exotic')\n print('z = %s, Hz = %s, gamma = %s, zeta = %s'% (z, Hz, gamma, zeta))\n print('ombar_m = %s, ombar_r = %s, ombar_de = %s'\n % (ombar_m, ombar_r, ombar_de))\n\n cdef double dtdz = -1.0/((1.0+z) * Hz)\n cdef double dadz = -(1.0+z)**(-2.0)\n cdef double domdz = (3.0*ombar_m +gamma*ombar_m*ombar_r /Hz) /(1.0+z)\n cdef double dordz = (4.0*ombar_r -(gamma*ombar_m*ombar_r -zeta*ombar_r*ombar_de) /Hz ) /(1.0+z)\n cdef double dodedz = -zeta*ombar_r*ombar_de/(1.0+z) /Hz\n cdef double ddldz = 1.0/Hz\n\n # first derivatives of functions I want to find:\n f = [dtdz,# dt/dz (= f.d wrt z of time)\n dadz,# d(a)/dz (= f.d wrt z of scale factor)\n domdz,# dw = 0, (ombar_m)/dz (= f.d wrt z of density_m(t) / crit density(t0))\n dordz,# w = 1/3, d(ombar_r)/dz (= f.d wrt z of density_r(t) / crit density(t0))\n dodedz,# w = -1, d(ombar_de)/dz (= f.d wrt z of density_de(t) / crit density(t0))\n 1.0,# d(z)/dz (= f.d wrt z of redshift)\n ddldz]# d(dl)/dz (= f.d wrt z of luminosty distance) # H + Hdz*(1+z)\n\n return f","def test_init_hebbian_2(self):\n v_one = [1, -1, -1, -1, 1, -1, -1, -1, 1]\n v_two = [-1, -1, -1, 1, 1, 1, -1, -1, -1]\n network = HopfieldNetwork([v_one, v_two])\n expected = np.array([\n [0, 0, 0, -2, 0, -2, 0, 0, 2],\n [0, 0, 2, 0, -2, 0, 2, 2, 0],\n [0, 2, 0, 0, -2, 0, 2, 2, 0],\n [-2, 0, 0, 0, 0, 2, 0, 0, -2],\n [0, -2, -2, 0, 0, 0, -2, -2, 0],\n [-2, 0, 0, 2, 0, 0, 0, 0, -2],\n [0, 2, 2, 0, -2, 0, 0, 2, 0],\n [0, 2, 2, 0, -2, 0, 2, 0, 0],\n [2, 0, 0, -2, 0, -2, 0, 0, 0]\n ], np.int64)\n npt.assert_equal(network.weight_matrix, expected)","def hEqn(g, e, h, f, Gescape, Gform, EHdecay, FHloss, stepsize):\n hchange = (g * Gescape\n - h * e * EHdecay\n - h * f * FHloss\n - e * h * Gform)\n return hchange * stepsize","def zzX_heu_gcd(f, g, **flags):\n if poly_univariate_p(f):\n return zzx_heu_gcd(f, g, **flags)\n\n def interpolate(h, x):\n f = []\n\n while not zzX_zero_p(h):\n g = zzX_zz_trunc(h, x)\n f.insert(0, g)\n h = zzX_sub(h, g)\n h = zzX_quo_const(h, x)\n\n return f\n\n def finalize(h, cff, cfg, gcd):\n if zzX_zz_LC(h) > 0:\n h = zzX_mul_const(h, gcd)\n else:\n h = zzX_mul_const(h, -gcd)\n cff = zzX_neg(cff)\n cfg = zzX_neg(cfg)\n\n return h, cff, cfg\n\n zero_f = zzX_zero_p(f)\n zero_g = zzX_zero_p(g)\n\n l = poly_level(f)\n z = zzX_zero(l)\n\n if zero_f and zero_g:\n return z, z, z\n elif zero_f:\n return g, z, zzX_const(l, 1)\n elif zero_g:\n return f, zzX_const(l, 1), z\n\n df = zzX_degree(f)\n dg = zzX_degree(g)\n\n cf = zzX_zz_content(f)\n cg = zzX_zz_content(g)\n\n gcd = igcd(cf, cg)\n\n f = zzX_quo_const(f, gcd)\n g = zzX_quo_const(g, gcd)\n\n f_norm = zzX_max_norm(f)\n g_norm = zzX_max_norm(g)\n\n B = 2*min(f_norm, g_norm) + 29\n\n x = max(min(B, 99*INT_TYPE(isqrt(B))),\n 2*min(f_norm // abs(zzX_zz_LC(f)),\n g_norm // abs(zzX_zz_LC(g))) + 2)\n\n for i in xrange(0, 6):\n ff = zzX_eval(f, x)\n gg = zzX_eval(g, x)\n\n if not (zzX_zero_p(ff) or zzX_zero_p(gg)):\n h, cff, cfg = zzX_heu_gcd(ff, gg, **flags)\n\n h = interpolate(h, x)\n h = zzX_zz_primitive(h)[1]\n\n cff_, r = zzX_div(f, h)\n\n if zzX_zero_p(r):\n cfg_, r = zzX_div(g, h)\n\n if zzX_zero_p(r):\n return finalize(h, cff_, cfg_, gcd)\n\n cff = interpolate(cff, x)\n\n h, r = zzX_div(f, cff)\n\n if zzX_zero_p(r):\n cfg_, r = zzX_div(g, h)\n\n if zzX_zero_p(r):\n return finalize(h, cff, cfg_, gcd)\n\n cfg = interpolate(cfg, x)\n\n h, r = zzX_div(g, cfg)\n\n if zzX_zero_p(r):\n cff_, r = zzX_div(f, h)\n\n if zzX_zero_p(r):\n return finalize(h, cff_, cfg, gcd)\n\n x = INT_TYPE(2.7319*x*isqrt(isqrt(x)))\n\n raise HeuristicGCDFailed('no luck')","def zzx_cofactors(f, g, **flags):\n return zzx_heu_gcd(f, g, **flags)","def __pow__(G, H):\n return NotImplemented","def apply_fhd(self, gfhd):\n for bl in self.data.keys():\n i,j = bl\n p1,p2 = self.pol\n G = gfhd[p1][i]*gfhd[p2][j].conj()\n ind = np.where(G != 0)[0]\n self.data[bl][self.pol][:,ind] /= G[ind]","def ldos_defect(h,v,e=0.0,delta=0.001,n=1):\n raise # still not finished\n import green\n # number of repetitions\n rep = 2*n +1\n # calculate pristine green function\n g,selfe = green.supercell_selfenergy(h,e=e,delta=delta,nk=100,nsuper=rep)\n # now calculate defected green function \n ez = e + 1j*delta # complex energy\n emat = np.matrix(np.identity(len(g)))*ez # E +i\\delta \n import supercell\n pintra = supercell.intra_super2d(h,n=rep) # pristine\n vintra = supercell.intra_super2d(h,n=rep,central=v) # defective\n selfe = emat - pintra - g.I # dyson euqation, get selfenergy\n gv = (emat - vintra -selfe).I # Green function of a vacancy, with selfener\n return","def pohlig_hellman(g: int, h: int, n: int):\n\n def group_of_prime_power_order(g, h, n=tuple):\n # n = (p, e) prime factor exponent times he appears\n p, e = n\n n = square_and_multiply(p, e)\n\n x = 0\n # By Lagrange's theorem, this element has order p.\n y = square_and_multiply(g, square_and_multiply(p, e - 1, n), n)\n\n for k in range(e):\n hk = square_and_multiply(\n square_and_multiply(g, -x, n) * h,\n square_and_multiply(p, e - 1 - k, n),\n n,\n )\n dk = pollard_rho(y, hk, n)\n x += dk * square_and_multiply(p, k, n)\n\n return x\n\n pFactors = findPrimeFactors(n, True)\n integers, modulis = [], []\n\n for p, e in pFactors.items():\n ni = square_and_multiply(p, e)\n gi = square_and_multiply(g, (n // ni), n)\n hi = square_and_multiply(h, (n // ni), n)\n\n xi = group_of_prime_power_order(gi, hi, (p, e))\n\n integers.append(xi)\n modulis.append(ni)\n\n return ChineseRemainder(integers, modulis)","def k_HF(T, n, h=1e-3):\n mu_p, _ = physics_solver_mu(n * (1 + h), T)\n mu_m, _ = physics_solver_mu(n * (1 - h), T)\n dn_dmu = 2 * h / (mu_p - mu_m) # second order diff\n return dn_dmu / n","def test_loss_hamiltonian_incomplete(self):\n g = nx.lollipop_graph(4, 1).to_directed()\n edge_weight_data = {edge: (i + 1) * 0.5 for i, edge in enumerate(g.edges)}\n for k, v in edge_weight_data.items():\n g[k[0]][k[1]][\"weight\"] = v\n h = loss_hamiltonian(g)\n\n expected_ops = [\n qml.PauliZ(0),\n qml.PauliZ(1),\n qml.PauliZ(2),\n qml.PauliZ(3),\n qml.PauliZ(4),\n qml.PauliZ(5),\n qml.PauliZ(6),\n qml.PauliZ(7),\n qml.PauliZ(8),\n qml.PauliZ(9),\n qml.PauliZ(10),\n qml.PauliZ(11),\n qml.PauliZ(12),\n qml.PauliZ(13),\n ]\n expected_coeffs = [\n np.log(0.5),\n np.log(1),\n np.log(1.5),\n np.log(2),\n np.log(2.5),\n np.log(3),\n np.log(3.5),\n np.log(4),\n np.log(4.5),\n np.log(5),\n np.log(5.5),\n np.log(6),\n np.log(6.5),\n np.log(7),\n ]\n\n assert expected_coeffs == h.coeffs\n assert all([op.wires == exp.wires for op, exp in zip(h.ops, expected_ops)])\n assert all([type(op) is type(exp) for op, exp in zip(h.ops, expected_ops)])","def get_34cohom_dim(v,l, even_e):\n op1 = OrdinaryGraphComplex.ContractEdgesGO.generate_operator(v,l, even_e)\n op2 = OrdinaryGraphComplex.ContractEdgesGO.generate_operator(v+1,l, even_e)\n fullvs = op1.domain\n fullvs2 = op2.domain\n \n vs34 = Valence34Mask(fullvs)\n vs342 = Valence34Mask(fullvs2)\n\n D34rank = 0\n if op1.is_valid():\n D = op1.get_matrix()\n # P34 = vs34.get_P34()\n # D34 = D * P34 \n i34 = vs34.get_34index_list()\n D34 = D[:, i34]\n D34rank = D34.rank()\n\n DD34rank = 0\n DD5rank = 0\n if op2.is_valid():\n DD = op2.get_matrix()\n # PP34 = vs342.get_P34()\n ii34 = vs342.get_34index_list()\n # DD34 = DD * PP34 \n DD34 = DD[:,ii34]\n DD34rank = DD34.rank()\n\n # P5 = vs34.get_P5()\n # DD5 = P5 * DD * PP34\n i5 = vs34.get_5index_list()\n DD5 = DD[i5, ii34]\n DD5rank = DD5.rank()\n\n\n return vs34.get_34dimension() - D34rank -DD34rank + DD5rank","def test_superposition_ud_cnot():\n program = dedent(\n \"\"\"\\\n register q0[0]\n register q1[1]\n H q1\n CNOT q1 q0\n \"\"\"\n )\n\n result = run(program, run_gate_array, return_distribution=True)\n assert isclose(result, [0.5, 0.0, 0.0, 0.5]).all()","def lstmcell_grad_h(input, hx, cx, w_ih, w_hh, b_ih, b_hh, dh, dc, target=\"cce\"):\n # things from fwd\n batch, input_size = get_shape(input)\n _, hidden_size = get_shape(hx)\n xh = akg.topi.concatenate((hx, input), 1)\n whl = [w_ih, w_hh]\n W = Concat(whl, 1) # [4*hidden_size, input_size+hidden_size]\n\n gates = dense(input, w_ih, b_ih, True) + dense(hx, w_hh, b_hh, True)\n\n ingate_in, forgetgate_in, cellgate_in, outgate_in = Split(gates, 4, 1)\n\n ingate = sigmoid(ingate_in)\n forgetgate = sigmoid(forgetgate_in)\n cellgate = Tanh(cellgate_in)\n outgate = sigmoid(outgate_in)\n cy = (forgetgate * cx) + (ingate * cellgate)\n tanh_cy = Tanh(cy)\n #hy = outgate * tanh_cy\n\n # starts bwd\n # head * dh/do shape [n,]\n doutgate = dh * tanh_cy\n doutgate_in = outgate * (1 - outgate) * doutgate\n kk = akg.tvm.reduce_axis((0, batch))\n dWo = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j:\n akg.tvm.sum(xh[kk, j] * doutgate_in(kk, i), axis=kk), name=\"dWo\")\n\n dtanh_cy = dh * outgate\n dc = (1 - tanh_cy * tanh_cy) * dtanh_cy\n\n dingate = cellgate * dc\n dingate_in = ingate * (1 - ingate) * dingate\n kk3 = akg.tvm.reduce_axis((0, batch))\n dWi = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j:\n akg.tvm.sum(xh[kk3, j] * dingate_in(kk3, i), axis=kk3), name=\"dWi\")\n\n dforgetgate = dc * cx\n dforgetgate_in = forgetgate * (1 - forgetgate) * dforgetgate\n kk2 = akg.tvm.reduce_axis((0, batch))\n dWf = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j:\n akg.tvm.sum(xh[kk2, j] * dforgetgate_in(kk2, i), axis=kk2), name=\"dWf\")\n\n dcellgate = ingate * dc\n dcellgate_in = (1 - cellgate * cellgate) * dcellgate\n kk4 = akg.tvm.reduce_axis((0, batch))\n dWc = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j:\n akg.tvm.sum(xh[kk4, j] * dcellgate_in(kk4, i), axis=kk4), name=\"dWc\")\n\n dW = akg.topi.concatenate((dWi, dWf, dWc, dWo))\n\n db = akg.topi.concatenate((dingate_in, dforgetgate_in, dcellgate_in, doutgate_in), 1)\n\n kk5 = akg.tvm.reduce_axis((0, 4 * hidden_size))\n dxh = akg.tvm.compute((batch, hidden_size + input_size), lambda i, j:\n akg.tvm.sum(W[kk5, j] * db[i, kk5], axis=kk5), name=\"dxh\")\n dhx = akg.tvm.compute((batch, hidden_size), lambda i, j: dxh[i, j], name=\"dhx\")\n dx = akg.tvm.compute((batch, input_size), lambda i, j: dxh[i, j + hidden_size], name=\"dx\")\n\n dcx = forgetgate * dc\n\n dw_ih = akg.tvm.compute(w_ih.shape, lambda i, j: dW[i, j])\n #dw_hh = akg.tvm.compute(w_hh.shape, lambda i, j: dW[i, j + input_size])\n\n bhr = akg.tvm.reduce_axis((0, batch))\n\n db_ih = akg.tvm.compute((4 * hidden_size,), lambda i: akg.tvm.sum(db[i, bhr], axis=bhr), name=\"dbih\")\n\n bir = akg.tvm.reduce_axis((0, batch))\n\n db_hh = akg.tvm.compute((4 * hidden_size,), lambda i: akg.tvm.sum(db[i, bir], axis=bir), name=\"dbhh\")\n\n return dw_ih, w_hh, db_ih, db_hh, dcx, dhx, dx","def __findUHF(self,samples): \n self.GPU_setArrayToZeros.prepared_call(self.gShapeZero,self.bShapeZero,\n self.GPU_bufDoppSum)\n\n self.GPU_filterMasks.prepared_call(self.gShapeVecMasks,self.bShapeVecMasks,\n self.GPU_bufXcorr,self.GPU_bufSignalFreq,self.GPU_bufBitsMask,self.GPU_bufDoppIdx,\n np.int32(self.Nfft),np.int32(self.doppIdxArrayLen))\n\n if self.FFTNoBatches == 1:\n cufft.cufftExecC2C(self.fftPlanDopplers,int(self.GPU_bufXcorr),int(self.GPU_bufXcorr),cufft.CUFFT_INVERSE)\n\n \n else:\n # It is at the moment faster to call single fft loops than batched fft loops (don't ask me why). This can however be changed in the config filte. Therefore all these loops\n for j in range(self.fftLoops):\n for i in range(self.num_streams):\n if j*self.num_streams + i < self.FFTNoBatches:\n buffAddr = self.buffAddr[j*self.num_streams+i] # compute the address in the large buffer\n cufft.cufftExecC2C(self.fftPlanDopplers[i],buffAddr,buffAddr,cufft.CUFFT_INVERSE)\n \n self.GPU_absSumDoppler.prepared_call(self.gShapeAbsSum,self.bShapeAbsSum,\n self.GPU_bufDoppSum,self.GPU_bufXcorr,np.int32(self.Nfft))\n\n if STORE_BITS_IN_FILE:\n tstore = time.time()\n tmpArr = np.empty((self.doppIdxArrayLen,self.num_masks),dtype=np.float32)\n cuda.memcpy_dtoh(tmpArr,self.GPU_bufDoppSum)\n self.sum_match = np.vstack([self.sum_match,np.sum(tmpArr,axis=1)])\n sumBest = np.argmax(np.sum(tmpArr,axis=1))\n log.debug(f'demodulator store in file 1 (save array) time {time.time()-tstore} s')\n\n self.GPU_estDoppler.prepared_call(self.gShapeDopp,self.bShapeDopp,\n self.GPU_bufDoppResult,self.GPU_bufFindDoppTmp,self.GPU_bufDoppSum,np.int32(self.num_dopplers),np.int32(self.doppIdxArrayOffset))\n\n bestDoppler = np.empty(2,dtype=np.float32) # contains [doppler, standard_dev]\n cuda.memcpy_dtoh(bestDoppler,self.GPU_bufDoppResult) # fetch the result\n # do scaling with the best Doppler before returning\n # Keep the scaling in indices. This is handier for the demodulation\n\n try:\n lowIdx = int(bestDoppler[0])\n highIdx = int(np.ceil(bestDoppler[0]))\n lowVal = self.doppHzLUT[lowIdx]\n highVal = self.doppHzLUT[highIdx]\n # This one is for our stats\n bestDopplerScaled = lowVal + (highVal-lowVal) * (bestDoppler[0] % 1) # scale with decimal offset\n\n # this one is for the demodulator. Contains the index\n self.dopplerIdxlast = np.int32(np.round(self.doppCyperSymNorm[lowIdx] + (self.doppCyperSymNorm[highIdx]-self.doppCyperSymNorm[lowIdx]) * (bestDoppler[0] % 1))) # directly for use in the demodulator\n # print(f'bestDopplerScaled {self.dopplerIdxlast}')\n SNR = self.computeSNR(lowIdx,highIdx,5)\n # SNR = 20.\n freqOffset = bestDopplerScaled - self.centreFreqOffset # we only want the detected frequency offset. Not the IF offset\n sdev_Hz = bestDoppler[1]/self.Nfft * self.sampleRate # not used when SUM_ALL_MASKS = 1\n\n except ValueError as e:\n log.error(f'Error occurred during find_UHF -- skipping block. Message: {e}')\n self.dopplerIdxlast = 0\n freqOffset = 0.\n sdev_Hz = 0.\n SNR = 0.\n \n return freqOffset, sdev_Hz, self.clippedPeakIPure, SNR","def directed_Hausdorff_hyperbox(b1,b2): \n return max(0,np.max(np.hstack((b1.u-b2.u,b2.l-b1.l))))","def getEG(n,int_method,func) :\n m = np.asarray([0.5,0.6,0.7,0.8,0.9,1,1.1,1.2,1.3,1.4,1.5,2,2.5,3,3.5,4,\n 4.5,5,5.5,6,6.5,7,7.5,8,8.5,9,9.5,10])\n bes = np.asarray([0.5,0.47768,0.44879,0.39831,0.25858,0,0.15502,0.25699,\n 0.30896,0.35245,0.39119,0.51822,0.53678,0.54984,0.55847,\n 0.56395,0.57054,0.57950,0.58402,0.58765,0.59512,0.60214,\n 0.60469,0.61143,0.61789,0.62443,0.63097,0.63694])\n p = np.asarray([1,0.85417,0.94685,1.04467,2.55052,0,1.59086,\n 1.00670,0.88866,0.83763,0.81030,0.76108,0.83093,0.86863,\n 0.89233,0.90909,0.92097,0.93007,0.93735,0.94332,0.94813,\n 0.95193,0.95557,0.95864,0.96107,0.96360,0.96570,\n 0.96788])\n h0 = np.asarray([0,-0.03567,-0.04808,-0.04315,-0.01879,0,0.00041,0.00069,\n 0.00639,0.01405,0.02294,0.07814,0.13994,0.19278,0.23793,\n 0.27678,0.31039,0.33974,0.36585,0.38917,0.41003,0.42891,\n 0.44621,0.46195,0.47644,0.48982,0.50223,0.51379])\n h1 = np.asarray([0,0.26899, 0.10571,0.01763,-0.39382,0,0.15211,0.05665,\n 0.00933,-0.02791,-0.05876,-0.16720,-0.13033,-0.10455 ,\n -0.08618,-0.07208,-0.06179,-0.05369,-0.04715,-0.04176,\n -0.03742,-0.03408,-0.03081,-0.02808,-0.02599,-0.02375,\n -0.02194,-0.02004])\n h2 = np.asarray([0,-0.09016,-0.06893,-0.04971,-0.08828,0,-0.03341,\n -0.03964,-0.04456,-0.04775,-0.04984,-0.05381,-0.03570,\n -0.02476,-0.01789,-0.01333,-0.01028,-0.00812,-0.00653,\n -0.00534,-0.00444,-0.00376,-0.00319,-0.00274,-0.00238,\n -0.00207,-0.00182,-0.00160])\n h3 = np.asarray([0,0.03993,0.03363,0.02216,-0.00797,0,0.00899,0.01172,\n 0.01150,0.01026,0.00860,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0])\n \n if (func == True) :\n int_bes = splev(n,splrep(m, bes))\n int_p = splev(n,splrep(m, p))\n int_h0 = splev(n,splrep(m, h0))\n int_h1 = splev(n,splrep(m, h1))\n int_h2 = splev(n,splrep(m, h2))\n int_h3 = splev(n,splrep(m, h3))\n else :\n int_bes = griddata(m, bes, n, method=int_method)\n int_p = griddata(m, p, n, method=int_method)\n int_h0 = griddata(m, h0, n, method=int_method)\n int_h1 = griddata(m, h1, n, method=int_method)\n int_h2 = griddata(m, h2, n, method=int_method)\n int_h3 = griddata(m, h3, n, method=int_method)\n \n return np.asarray([int_bes,int_p,int_h0,int_h1,int_h2,int_h3])","def glueEmH( Ja, Jf, truncNum = scipy.inf ):\n w, v = truncBasisH( Ja, truncNum )\n sPlus, sMinus, sZ = sPlusAndMinusAndZ( v )\n \n H1 = scipy.zeros( ( len(w)**4, len(w)**4 ) )\n \n for n in range( len(w)**4 ):\n # Diagonal previous generation contributions\n o = oct(n)[-4:].zfill(4)\n o = [int(char) for char in o]\n o_A, o_B, o_C, o_D = o\n \n H1[n, n] += scipy.sum( [ w[ i ] for i in o ] )\n \n # Edge terms\n for np in range( n, len(w)**4 ):\n op = oct(np)[-4:].zfill(4)\n op = [int(char) for char in op]\n op_A, op_B, op_C, op_D = op\n \n x = 0.\n if ( (o_B == op_B) and (o_C == op_C) ):\n x += -Jf * ( .5 * ( sPlus[0][o_A, op_A] * sMinus[0][o_D, op_D] + sMinus[0][o_A, op_A] * sPlus[0][o_D,op_D] ) + sZ[0][o_A, op_A] * sZ[0][o_D, op_D] )\n if ( (o_C == op_C) and (o_A == op_A) ):\n x += -Jf * ( .5 * ( sPlus[1][o_B, op_B] * sMinus[1][o_D, op_D] + sMinus[1][o_B, op_B] * sPlus[1][o_D,op_D] ) + sZ[1][o_B, op_B] * sZ[1][o_D, op_D] )\n if ( (o_A == op_A) and (o_B == op_B) ):\n x += -Jf * ( .5 * ( sPlus[2][o_C, op_C] * sMinus[2][o_D, op_D] + sMinus[2][o_C, op_C] * sPlus[1][o_D,op_D] ) + sZ[1][o_C, op_C] * sZ[2][o_D, op_D] )\n \n H1[n, np] = x\n H1[np, n] = x\n \n return H1","def ecfp(mol,radius):\n #mol=Chem.AddHs(mol)\n bitInfo={}\n atoms_dict=invariants(mol)\n \n for idxs,i in atoms_dict.items():\n bitInfo[i]=bitInfo.get(i,())+((idxs,0),)\n \n neighborhoods=[]\n atom_neighborhoods=[len(mol.GetBonds())*bitarray('0') for a in mol.GetAtoms()]\n dead_atoms=len(mol.GetAtoms())*bitarray('0')\n \n for r in range(1,radius+1):\n round_ids={} #new bit ID this iteration\n round_atom_neighborhoods=copy.deepcopy(atom_neighborhoods) #bond to include under this r\n neighborhoods_this_round=[] #(round_atom_neighborhoods,round_ids,idxs)\n \n for idxs,a in enumerate(mol.GetAtoms()):\n if dead_atoms[idxs]:\n continue\n nbsr=[] #list to hash this iteration\n o_bond=bond(mol,idxs)\n for b in o_bond:\n round_atom_neighborhoods[idxs][b[2]] = True\n round_atom_neighborhoods[idxs] |= atom_neighborhoods[b[1]]\n nbsr.append((b[0],atoms_dict[b[1]]))\n nbsr=sorted(nbsr)\n nbsr=[item for sublist in nbsr for item in sublist]\n nbsr.insert(0,atoms_dict[idxs])\n nbsr.insert(0,r)\n \n round_ids[idxs]=get_hash(nbsr)\n neighborhoods_this_round.append((round_atom_neighborhoods[idxs],round_ids[idxs],idxs))\n for lst in neighborhoods_this_round:\n if lst[0] not in neighborhoods:\n bitInfo[lst[1]] = bitInfo.get(lst[1],())+((lst[2],r),)\n neighborhoods.append(lst[0])\n else:\n dead_atoms[lst[2]]=True\n atoms_dict=round_ids\n atom_neighborhoods=copy.deepcopy(round_atom_neighborhoods)\n return bitInfo","def ehermite(a, b):\n [c, d, g] = extgcd(a, b)\n if g:\n E = np.array([[c, d], [-b/g, a/g]])\n else:\n E = np.array([[1, 0], [0, 1]])\n\n return E\n #Leila: check this \"http://www.ece.northwestern.edu/local-apps/matlabhelp/techdoc/ref/gcd.html\"","def check_correctness_sigmoid_channelwise(f):\n\n rng = np.random.RandomState([2012, 7, 19])\n batch_size = 5\n pool_size = 1\n n = 3 * pool_size\n zv = rng.randn(batch_size, n).astype(config.floatX) * 1. - 1.5\n top_down_v = rng.randn(batch_size, n / pool_size).astype(config.floatX)\n\n z_th = T.matrix()\n z_th.name = 'z_th'\n\n top_down_th = T.matrix()\n top_down_th.name = 'top_down_th'\n\n p_th, h_th = f(z_th, pool_size, top_down_th)\n h_s = T.nnet.sigmoid(z_th + top_down_th)\n\n func = function([z_th, top_down_th], [p_th, h_th, h_s])\n\n pv, hv, h_s = func(zv, top_down_v)\n p_s = h_s\n\n assert p_s.shape == pv.shape\n assert h_s.shape == hv.shape\n if not np.allclose(h_s, hv):\n print((h_s.min(), h_s.max()))\n print((hv.min(), hv.max()))\n assert False\n if not np.allclose(p_s, pv):\n diff = abs(p_s - pv)\n print('max diff ', diff.max())\n print('min diff ', diff.min())\n print('ave diff ', diff.mean())\n assert False","def simulation_OFC(self,ncmE,ncmC,f,g,Cfun,h,dt,tf,x0,z0=None,dscale=10.0,\\\n xnames=\"num\",Ncol=1,FigSize=(20,10),FontSize=20,phis=None):\n \"\"\"\n \n \n 1) SIMULATION\n \n \n \"\"\"\n if len(sig(f).parameters) == 1:\n fun1 = f\n f = lambda x,p: fun1(x)\n if len(sig(g).parameters) == 1:\n fun2 = g\n g = lambda x,p: fun2(x)\n if len(sig(Cfun).parameters) == 1:\n fun3 = Cfun\n Cfun = lambda x,p: fun3(x)\n if len(sig(h).parameters) == 1:\n fun4 = h\n h = lambda x,p: fun4(x)\n print(\"========================================================\")\n print(\"====================== SIMULATIOM ======================\")\n print(\"========================================================\")\n if dt <= self.dt_rk:\n self.dt_rk = dt\n self.Nrk = int(dt/self.dt_rk)\n Nsim = int(tf/dt)\n np.set_printoptions(precision=1)\n print(\"time step =\",dt)\n print(\"terminal time =\",tf)\n print(\"initial state =\",x0)\n print(\"estimated initial state =\",z0)\n funx = lambda x,p,dEf: f(x,p)+dEf(x,p)\n z = z0\n zhis = np.zeros((Nsim+1,self.n))\n zhis[0,:] = z\n x = x0\n xhis = np.zeros((Nsim+1,self.n))\n xhis[0,:] = x\n tit1 = \"Performance of NCM-based Output Feedback (1)\"\n tit2 = \"Performance of NCM-based Output Feedback (2)\"\n tit3 = \"Performance of NCM-based Output Feedback (3)\"\n tit4 = \"Performance of NCM-based Output Feedback (4)\"\n ly = r\"estimation error: $\\|x-\\hat{x}\\|_2$\"\n l1 = r\"estimation error\"\n lyb = r\"tracking error: $\\|x-x_d\\|_2$\"\n l1b = r\"tracking error\"\n bNam1 = \"=================== ESTIMATION ERROR ===================\"\n bNam2 = \"============ ESTIMATION ERROR OF EACH STATE ============\"\n bNam3 = \"==================== Tracking ERROR ====================\"\n bNam4 = \"============= Tracking ERROR OF EACH STATE =============\"\n l2 = r\"optimal steady-state upper bound\"\n if phis == None:\n phis = np.linspace(self.plims[0,:],self.plims[1,:],Nsim)\n for k in range(Nsim):\n p = phis[k,:]\n Mc = ncmC.ncm(z,p)\n u = -g(z,p).T@Mc@z\n dEfC = lambda x,p: g(x,p)@u\n d1 = self.unifrand2(ncmC.d1_over,np.size(ncmC.Bw(x,p),1))*dscale\n x = self.rk4(x,p,dEfC,funx)+ncmC.Bw(x,p)@d1*dt\n xhis[k+1,:] = x\n Me = ncmE.ncm(z,p)\n Cx = Cfun(z,p)\n Lx = Me@Cx.T\n #Lx = K.T\n d2 = self.unifrand2(ncmE.d2_over,np.size(ncmE.Gw(x,p),1))*dscale\n y = h(x,u,p)+ncmE.Gw(x,p)@d2\n funz = lambda z,p,dEf: f(z,p)+g(z,p)@u+dEf(z,p)\n dEfE = lambda z,p: Lx@(y-h(z,u,p))\n z = self.rk4(z,p,dEfE,funz)\n zhis[k+1,:] = z\n this = np.linspace(0,tf,Nsim+1)\n \"\"\"\n \n \n 2) FIGURE GENERATION\n \n \n \"\"\"\n print(\"========================================================\")\n print(bNam1)\n print(\"========================================================\")\n matplotlib.rcParams.update({\"font.size\": 15})\n matplotlib.rc(\"text\",usetex=True)\n plt.figure()\n plt.plot(this,np.sqrt(np.sum((xhis-zhis)**2,1)))\n plt.plot(this,np.ones(np.size(this))*ncmE.Jcv_opt)\n plt.xlabel(r\"time\",fontsize=FontSize)\n plt.ylabel(ly,fontsize=FontSize)\n plt.legend([l1,l2],loc=\"best\")\n plt.title(tit1,fontsize=FontSize)\n plt.show()\n print(\"========================================================\")\n print(bNam2)\n print(\"========================================================\")\n Nrow = int(self.n/Ncol)+np.remainder(self.n,Ncol)\n fig,ax = plt.subplots(Nrow,Ncol,figsize=FigSize)\n plt.subplots_adjust(wspace=0.25,hspace=0.25)\n if Ncol == 1:\n ax = np.reshape(ax,(self.n,1))\n elif Nrow == 1:\n ax = np.reshape(ax,(1,self.n))\n if xnames == \"num\":\n xnames = []\n for i in range(self.n):\n xnames += [r\"state \"+str(i+1)]\n for row in range(Nrow):\n for col in range(Ncol):\n i = Ncol*row+col\n if i+1 <= self.n:\n ax[row,col].plot(this,xhis[:,i]-zhis[:,i])\n ax[row,col].set_xlabel(r\"time\",fontsize=FontSize)\n LabelName = r\"estimation error: \"+xnames[i]\n ax[row,col].set_ylabel(LabelName,fontsize=FontSize)\n fig.suptitle(tit2,fontsize=FontSize)\n plt.show()\n print(\"========================================================\")\n print(bNam3)\n print(\"========================================================\")\n matplotlib.rcParams.update({\"font.size\": 15})\n matplotlib.rc(\"text\",usetex=True)\n plt.figure()\n plt.plot(this,np.sqrt(np.sum((xhis)**2,1)))\n plt.plot(this,np.ones(np.size(this))*ncmC.Jcv_opt)\n plt.xlabel(r\"time\",fontsize=FontSize)\n plt.ylabel(lyb,fontsize=FontSize)\n plt.legend([l1b,l2],loc=\"best\")\n plt.title(tit3,fontsize=FontSize)\n plt.show()\n print(\"========================================================\")\n print(bNam4)\n print(\"========================================================\")\n Nrow = int(self.n/Ncol)+np.remainder(self.n,Ncol)\n fig,ax = plt.subplots(Nrow,Ncol,figsize=FigSize)\n plt.subplots_adjust(wspace=0.25,hspace=0.25)\n if Ncol == 1:\n ax = np.reshape(ax,(self.n,1))\n elif Nrow == 1:\n ax = np.reshape(ax,(1,self.n))\n if xnames == \"num\":\n xnames = []\n for i in range(self.n):\n xnames += [r\"state \"+str(i+1)]\n for row in range(Nrow):\n for col in range(Ncol):\n i = Ncol*row+col\n if i+1 <= self.n:\n ax[row,col].plot(this,xhis[:,i])\n ax[row,col].set_xlabel(r\"time\",fontsize=FontSize)\n LabelName = r\"tracking error: \"+xnames[i]\n ax[row,col].set_ylabel(LabelName,fontsize=FontSize)\n fig.suptitle(tit4,fontsize=FontSize)\n plt.show()\n print(\"========================================================\")\n print(\"==================== SIMULATIOM END ====================\")\n print(\"========================================================\")\n return this,xhis,zhis","def edgeHam( H, Jf, repNum, repString, adjacencyList ):\n \n flipVal = -.5 * Jf\n opVal = .25 * Jf\n sameVal = -.25 * Jf\n \n # Cycle throught the adjacencies\n for (i,j) in adjacencyList:\n \n si,sj = repString[i], repString[j]\n \n if si != sj:\n # Raising / Lowering terms will flip the two and spit out -1/2 Jf\n # We have to do some wonky stuff because you can't do element \n # assignment with strings\n flipString = [c for c in repString]\n flipString[i] = sj\n flipString[j] = si\n flipString = ''.join( flipString )\n flipNum = int( flipString, base = 2 )\n \n H[(repNum, flipNum)] += flipVal\n \n # Opposite spins will get a 1/4 from the s_z terms\n H[(repNum, repNum)] += opVal\n \n else:\n # Same spins will get a -1/4 from the s_z terms\n H[(repNum, repNum)] += sameVal","def check_correctness_channelwise(f):\n\n rng = np.random.RandomState([2012, 7, 19])\n batch_size = 5\n pool_size = 4\n n = 3 * pool_size\n zv = rng.randn(batch_size, n).astype(config.floatX) * 1. - 1.5\n top_down_v = rng.randn(batch_size, n / pool_size).astype(config.floatX)\n\n p_np, h_np = max_pool_channels_python(zv, pool_size, top_down_v)\n\n z_th = T.matrix()\n z_th.name = 'z_th'\n\n top_down_th = T.matrix()\n top_down_th.name = 'top_down_th'\n\n p_th, h_th = f(z_th, pool_size, top_down_th)\n\n func = function([z_th, top_down_th], [p_th, h_th])\n\n pv, hv = func(zv, top_down_v)\n\n assert p_np.shape == pv.shape\n assert h_np.shape == hv.shape\n if not np.allclose(h_np, hv):\n print((h_np.min(), h_np.max()))\n print((hv.min(), hv.max()))\n assert False\n if not np.allclose(p_np, pv):\n diff = abs(p_np - pv)\n print('max diff ', diff.max())\n print('min diff ', diff.min())\n print('ave diff ', diff.mean())\n assert False","def mat24_complete_heptad(p_io):\n ## uint_fast32_t err, s1, s5, s015, s3, s4, s8, s01234; \n ## uint_fast32_t s567, s67, s9AB, s9CD, s9, s6GH, s6;\n ## uint_fast32_t sACE, sD, sFGI, sG, sFJK, sJLM, sALN;\n\n err = ((p_io[0] + 8) | (p_io[1] + 8) | (p_io[2] + 8) | \n (p_io[3] + 8) | (p_io[4] + 8) | (p_io[5] + 8) | (p_io[8] + 8));\n err &= (0 - 0x20);\n s1 = 1 << p_io[1]; \n s5 = 1 << p_io[5];\n s015 = (1 << p_io[0]) ^ s1 ^ s5;\n s3 = 1 << p_io[3]; \n s4 = 1 << p_io[4]; \n s8 = 1 << p_io[8];\n s01234 = s015 ^ s5 ^ (1 << p_io[2]) ^ s3 ^ s4;\n # if err == 0 then 0 <= s01234 < 0x1000000 has odd parity\n # octad = [0, 1, 2, 3, 4, 5, 6, 7]\n s567 = odd_syn(s01234);\n err |= (s01234) & s567;\n # if err == 0 then entries [0,1,2,3,4,6] are in an octad\n err |= (s01234 | s567) & s8;\n # if err == 0 then entry 8 is not in that octad\n err |= s5 ^ (s5 & s567);\n s67 = s567 & ~s5;\n # octad = [0, 1, 2, 3, 8, 9, 10, 11]\n s9AB = odd_syn(s01234 ^ s4 ^ s8);\n # octad = [0, 1, 4, 5, 8, 9, 12, 13]\n s9CD = odd_syn(s015 ^ s4 ^ s8);\n s9 = s9AB & s9CD;\n p_io[9] = lsb24(s9);\n # octad [1, 3, 5, 6, 8, 9, 16, 17]\n s6GH = odd_syn(s1 ^ s3 ^ s5 ^ s8 ^ s9);\n s6 = s67 & s6GH;\n p_io[6] = lsb24(s6);\n p_io[7] = lsb24(s67 & ~s6GH);\n # still needed: \n # err, s1, s015, s3, s8, s01234, s9AB, s9CD, s9, s6GH, s6\n # octad [0, 2, 4, 6, 8, 10, 12, 14]\n sACE = odd_syn(s01234 ^ s1 ^ s3 ^ s6 ^ s8);\n p_io[10] = lsb24(s9AB & sACE);\n p_io[11] = lsb24(s9AB & ~sACE & ~s9);\n p_io[12] = lsb24(s9CD & sACE);\n sD = s9CD & ~sACE & ~s9;\n p_io[13] = lsb24(sD);\n p_io[14] = lsb24(sACE & ~s9AB & ~s9CD);\n # still needed: \n # err, s1, s015, s3, s8, s6GH, s6, sACE, sD\n # octad [0, 1, 5, 6, 13, 15, 16, 18]\n sFGI = odd_syn(s015 ^ s6 ^ sD);\n sG = s6GH & sFGI;\n p_io[16] = lsb24(sG);\n p_io[17] = lsb24(s6GH & ~s6 & ~sFGI);\n # octad [0, 1, 3, 5, 8, 15, 19, 20]\n sFJK = odd_syn(s015 ^ s3 ^ s8);\n p_io[15] = lsb24(sFGI & sFJK);\n p_io[18] = lsb24(sFGI & ~sG & ~sFJK);\n # octad [0, 3, 5, 6, 16, 19, 21, 22]\n sJLM = odd_syn(s015 ^ s1 ^ s3 ^ s6 ^ sG);\n p_io[19] = lsb24(sFJK & sJLM);\n p_io[20] = lsb24(sFJK & ~sFGI & ~sJLM);\n # octad [0, 1, 5, 6, 8, 10, 21, 23]\n sALN = odd_syn(s015 ^ s6 ^ s8); \n p_io[21] = lsb24(sALN & sJLM);\n p_io[22] = lsb24(sJLM & ~sALN & ~sFJK);\n p_io[23] = lsb24(sALN & ~sACE & ~sJLM);\n return err;","def homothick():\n return se2hmt(binary([[1,1,1],\n [0,0,0],\n [0,0,0]]),\n binary([[0,0,0],\n [0,1,0],\n [1,1,1]]))","def fedorenko(tau, h, grid):\n relation = tau / h\n new_grid = np.zeros(len(grid) - 1)\n for m in range(1, len(grid) - 1):\n new_grid[m-1] = grid[m] - np.dot(relation, grid[m] - grid[m-1]) - np.dot(relation / 2 * (relation - relation ** 2), grid[m-1] - 2 * grid[m] + grid[m+1])\n new_grid = np.insert(new_grid, 0, grid[0])\n return new_grid","def optimize_fore(self):\n self.u = np.random.uniform(-1, 1, (32, 288, 1, 1))\n \n self.l2 = torch.from_numpy(self.u).float()\n print('self u shape',self.l2.shape)\n self.n = torch.randn(32, 1, 28, 28)\n self.l1 = self.enc(self.input + self.n)\n self.del1=self.dec(self.l1)\n self.del2=self.dec(self.l2)\n self.update_netc()\n self.update_netd()\n\n self.update_l2()\n self.update_netg()\n print('sssssssssssssssssssssss')","def pingjiazhibiao(result):\n import math\n list_ed_normal = []\n list_es_normal = []\n list_ed_true = []\n list_es_true = []\n # these definations are for statistic\n ed_pred_all, es_pred_all,ed_true_all,es_true_all,ed_match,es_match,ed_normal,es_normal,ed_nomiss,es_nomiss= 0,0,0,0,0,0,0,0,0,0\n total_error_ed,total_error_es = 0,0\n sample_missimg_num = 0\n a4cdDict = {}\n a4csDict = {}\n for i in range(-5,7):\n a4cdDict[i] = 0\n a4csDict[i] = 0\n for i in result:\n pred = i[0]\n ed_pred = pred[0]\n es_pred = pred[1]\n if ed_pred == [] or es_pred == []:\n sample_missimg_num += 1\n true = i[1]\n ed_true = true[0]\n es_true = true[1]\n\n # avoid many to one\n ed_pred.sort()\n es_pred.sort()\n deleteAmong10frames(ed_pred)\n deleteAmong10frames(es_pred)\n \n for j in ed_pred:\n ed_pred_all += 1\n for t in ed_true:\n if math.fabs(j - t) < 6:\n ed_normal += 1\n total_error_ed += math.fabs(t - j)\n a4cdDict[j-t]+=1\n break\n # all - normal = FP\n # normal is TP\n a4cdDict[6] = ed_pred_all-ed_normal\n\n for j in es_pred:\n es_pred_all += 1\n for t in es_true:\n if math.fabs(j - t) < 6:\n es_normal += 1\n total_error_es += math.fabs(t - j)\n a4csDict[j-t]+=1\n break\n a4csDict[6] = es_pred_all-es_normal\n for j in ed_true:\n ed_true_all += 1\n for t in ed_pred:\n if math.fabs(t - j) < 6:\n ed_nomiss += 1\n break\n\n for j in es_true:\n es_true_all += 1\n for t in es_pred:\n if math.fabs(t - j) < 6:\n es_nomiss += 1\n break\n # aFD precision recall \n ed_result = total_error_ed / ed_normal,(ed_normal / ed_pred_all),(ed_nomiss / ed_true_all)\n es_result = total_error_es / es_normal,(es_normal / es_pred_all),(es_nomiss / es_true_all)\n return ed_result,a4cdDict, es_result,a4csDict, sample_missimg_num / len(result)","def wol(noi, noft, times,\r\n M, NE, NI,\r\n Omee, Omei, Omie, Omii, F):\r\n FF=np.zeros((NE,1))\r\n for h in range(noi):\r\n ip=np.random.rand(M,1)\r\n ip/=np.linalg.norm(ip)\r\n cn=np.zeros((NE,1))\r\n for i in range(noft):\r\n c = np.zeros((M,1))\r\n VE, VI=np.zeros((NE, times)), np.zeros((NI, times))\r\n oe, oi=np.zeros((NE, times)), np.zeros((NI, times))\r\n re, ri=np.zeros((NE, times)), np.zeros((NI, times))\r\n for j in range(times):\r\n epev, epiv = sigv * np.random.randn(1,1), sigv * np.random.randn(1,1)\r\n epet, epit = sigt * np.random.randn(1,1), sigt * np.random.randn(1,1)\r\n c[:,0] = + 1 * ip[:,0]\r\n VE[:,j]=(1 - lam * dt) * VE[:,j-1] + dt* F[:,:] @ c[:,0] + Omee[:,:] @ oe[:,j-1] + Omie[:,:] @ oi[:,j-1] + epev[0,0]\r\n if VE[ne,j]>TE and RE[ne,0] < 0:\r\n oe[ne,j] = 1\r\n re[:,j]=(1 - lam * dt) * re[:,j-1]+oe[:,j-1]\r\n VI[:,j]=(1 - lam * dt) * VI[:,j-1] + Omei[:,:] @ oe[:,j-1] + Omii[:,:] @ oi[:,j-1] + epiv[0,0]\r\n ni=np.argmax(VI[:,j] - TI - epit[0,0])\r\n if VI[ni,j]>TI and RI[ni,0] < 0:\r\n oi[ni,j] = 1\r\n ri[:,j]=(1 - lam * dt) * ri[:,j-1]+oi[:,j-1]\r\n np.hstack((cn,np.sum(oe, axis=1, keepdims=True)))\r\n np.hstack((FF, np.var(cn[:,1:], axis=1)/np.mean(cn[:,1:], axis=1, keepdims=True)))\r\n return np.nanmean(FF[:,1:])","def doublehgm_same_evaluation(input_generator,branches,iden_method,Plot,reference=None):\n input_signal = input_generator.GetOutput()\n filter_spec_tofind = nlsp.log_bpfilter(branches=branches,input=input_signal)\n ref_nlsystem = nlsp.HammersteinGroup_Series(input_signal=input_signal,\n nonlinear_functions=(nlsp.nl_branches(nlsp.function_factory.power_series,branches),nlsp.nl_branches(nlsp.function_factory.power_series,branches)),\n filter_irs=(filter_spec_tofind,filter_spec_tofind),\n max_harmonics=(range(1,branches+1),range(1,branches+1)),\n hgm_type=(nlsp.HammersteinGroupModel_up,nlsp.HammersteinGroupModel_up))\n\n found_filter_spec, nl_functions = iden_method(input_generator,ref_nlsystem.GetOutput(2),branches)\n iden_nlsystem = nlsp.HammersteinGroupModel_up(input_signal=input_signal,\n nonlinear_functions=nl_functions,\n filter_irs=found_filter_spec,\n max_harmonics=range(1,branches+1))\n if reference is not None:\n reference = nlsp.change_length_signal(reference,length=len(input_signal))\n ref_nlsystem = nlsp.HammersteinGroup_Series(input_signal=reference,\n nonlinear_functions=(nlsp.nl_branches(nlsp.function_factory.power_series,branches),nlsp.nl_branches(nlsp.function_factory.power_series,branches)),\n filter_irs=(filter_spec_tofind,filter_spec_tofind),\n max_harmonics=(range(1,branches+1),range(1,branches+1)),\n hgm_type=(nlsp.HammersteinGroupModel_up,nlsp.HammersteinGroupModel_up))\n iden_nlsystem.SetInput(reference)\n if Plot is True:\n plot.relabelandplotphase(sumpf.modules.FourierTransform(ref_nlsystem.GetOutput(2)).GetSpectrum(),\"Reference System\",show=False)\n plot.relabelandplotphase(sumpf.modules.FourierTransform(iden_nlsystem.GetOutput()).GetSpectrum(),\"Identified System\",show=True)\n print \"SNR between Reference and Identified output for double hgm all same: %r\" %nlsp.snr(ref_nlsystem.GetOutput(2),\n iden_nlsystem.GetOutput())","def extendedGcd(a, b):\n x0 = 1\n x1 = 0\n y0 = 0\n y1 = 1\n\n while b != 0:\n p = a // b\n z = a % b\n a = b\n b = z\n\n w = x1\n x1 = x0 - p * x1\n x0 = w\n \n v = y1\n y1 = y0 - p * y1\n y0 = v\n print(\"returns: gcd, si, ti\")\n return (gcd(a, b), x0, y0)","def _h(W):\r\n # E = slin.expm(W * W)\r\n # h = np.trace(E) - d\r\n M = np.eye(d) + W * W / d\r\n E = np.linalg.matrix_power(M, d - 1)\r\n h = (E.T * M).sum() - d\r\n G_h = E.T * W * 2\r\n return h, G_h","def _dipole_gof(uu, sing, vv, B, B2):\n ncomp = 3 if sing[2] / sing[0] > 0.2 else 2\n one = np.dot(vv[:ncomp], B)\n Bm2 = np.sum(one ** 2)\n return Bm2 / B2, one","def test_init_hebbian_3(self):\n v_one = [1, -1, -1, -1, 1, -1, -1, -1, 1]\n v_two = [-1, -1, -1, 1, 1, 1, -1, -1, -1]\n v_three = [-1, -1, 1, -1, -1, 1, -1, -1, 1]\n network = HopfieldNetwork([v_one, v_two, v_three])\n expected = np.array([\n [0, 1, -1, -1, 1, -3, 1, 1, 1],\n [1, 0, 1, 1, -1, -1, 3, 3, -1],\n [-1, 1, 0, -1, -3, 1, 1, 1, 1],\n [-1, 1, -1, 0, 1, 1, 1, 1, -3],\n [1, -1, -3, 1, 0, -1, -1, -1, -1],\n [-3, -1, 1, 1, -1, 0, -1, -1, -1],\n [1, 3, 1, 1, -1, -1, 0, 3, -1],\n [1, 3, 1, 1, -1, -1, 3, 0, -1],\n [1, -1, 1, -3, -1, -1, -1, -1, 0]\n ])\n npt.assert_equal(network.weight_matrix, expected)","def ohms(self):\n # Rwb = Rwiper + Rtotal * (counts / 256)\n # Rwa = Rwiper + Rtotal * ((256 - counts) / 256)\n g = 0\n rtotal=0.0\n reach=[]\n for chan in self.get_channel_list(self.nchans):\n self.rwa[chan] = float( 256 - self.vals[chan] ) / 256.0\n self.rwb[chan] = float( self.vals[chan] ) / 256.0\n self.rwa[chan] *= self.Rtotal\n self.rwb[chan] *= self.Rtotal \n self.rwa[chan] += self.Rwiper\n self.rwb[chan] += self.Rwiper","def inverse_gc(g):\n i = g\n j = 1\n while j<N:\n i = i ^ (g >> j)\n j = j + 1\n return i","def toffoli(ha, hb, hc):\n\n return controlled_U(ha, cnot(hb, hc))","def grover(self) -> None:\n\n size = self.circ_size\n random.seed(self.seed)\n\n # Split the single qreg into the computational register and a \"work\" register to store the oracle results\n qr = self.qr[:-1]\n wr = self.qr[-1:]\n\n if self.truth_value is None:\n raise ValueError(f'This circuit type requires a truth value be set before it can be generated. i.e. with'\n f'\"my_Premade.truth_value = (some_int)\"')\n\n tv = self.truth_value\n\n self.h(qr)\n\n loop = math.floor(math.sqrt(2 ** size))\n logger.debug(f'loop: {loop}')\n for i in range(loop):\n # NOT the wires where the magic state bit should be 0\n for j in range(len(qr)):\n if not tv & (1 << j): # i.e. tharr be zeroes in this here bitstring position\n self.x(qr[j])\n\n self.x(wr[0])\n self.mcrz(math.pi, qr, wr[0])\n self.x(wr[0])\n\n for j in range(len(qr)):\n if not tv & (1 << j): # i.e. tharr be zeroes in this here bitstring position\n self.x(qr[j])\n\n # Inversion about the average\n self.h(qr)\n self.x(qr)\n\n self.mcrz(math.pi, qr[:-1], qr[-1])\n\n self.x(qr)\n self.h(qr)\n\n if self.meas: self.measure(self.qr, self.cr)","def test_superposition_cnot():\n\n program = dedent(\n \"\"\"\\\n register q0[0]\n register q1[1]\n H q0\n CNOT q0 q1\n \"\"\"\n )\n\n result = run(program, run_gate_array, return_distribution=True)\n assert isclose(result, [0.5, 0.0, 0.0, 0.5]).all()","def cell_cnc_tracker(Out, U, V, W, t, cell0, cellG, cellD, SHP, cryoconite_locations):\n\n Cells = np.random.rand(len(t),SHP[0],SHP[1],SHP[2]) * cell0\n CellD = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellD\n CellG = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellG\n \n \n for i in np.arange(0,SHP[0],1):\n CellG[i,:,:] = np.where(cryoconite_locations==True, CellG[i,:,:]*1000, CellG[i,:,:])\n \n for t in np.arange(0,len(Out.Qz[:,0,0,0]),1):\n \n for layer in np.arange(0,len(Out.Qz[0,:,0,0]),1):\n\n # normalise lateral flow so that -ve= flow out of cells towards edges\n # and positive flow is towards centre line. In Qx -ve = leftwards flow\n # and +ve = rightwards flow. This leads to a rightwards drift in cell\n # fluxes if not normalised in this way.\n U[t,layer,:,0:int(U.shape[2]/2)] = 0-U[t,layer,:,0:int(U.shape[2]/2)]\n\n # nabla is the inverted delta operator used to denote the divergence \n # of a vector field, here applied to hydrological flow in m3/d \n # calculated as dx/dt + dy/dt + dz/dt\n\n nabla = (U[t,layer,:,:] + V[t,layer,:,:] + W[t,layer,:,:])\n \n # divergence gives net in/outflow in m3/t\n # cells/m3 = cells/mL *1000\n\n delC = Out.Q[t,layer,:,:] * (1+CellG[layer,:,:] - CellD[layer,:,:])\n\n Cells[t,layer,:,:] = Cells[t,layer,:,:] + (delC * 1000) \n\n Cells[Cells<0] = 0\n \n CellColumnTot = Cells.sum(axis=1)\n \n\n return Cells, CellColumnTot","def dnde_photon_spectrum_fns(\n self,\n) -> Dict[str, Callable[[Union[float, npt.NDArray[np.float64]], float], float]]:\n\n def dnde_zero(e, _: float):\n return np.zeros_like(e)\n\n def wrap(f):\n @functools.wraps(f)\n def fnew(*args, **kwargs):\n return f(self, *args, **kwargs)\n\n return fnew\n\n return {\n \"e e\": wrap(dnde_photon_e_e),\n \"mu mu\": wrap(dnde_photon_mu_mu),\n \"ve ve\": dnde_zero,\n \"vt vt\": dnde_zero,\n \"vm vm\": dnde_zero,\n \"pi pi\": wrap(dnde_photon_pi_pi),\n \"k0 k0\": wrap(dnde_photon_k0_k0),\n \"k k\": wrap(dnde_photon_k_k),\n \"pi0 gamma\": wrap(dnde_photon_pi0_gamma),\n \"eta gamma\": wrap(dnde_photon_eta_gamma),\n \"pi0 phi\": wrap(dnde_photon_pi0_phi),\n \"eta phi\": wrap(dnde_photon_eta_phi),\n \"eta omega\": wrap(dnde_photon_eta_omega),\n \"pi0 pi0 gamma\": wrap(dnde_photon_pi0_pi0_gamma),\n \"pi pi pi0\": wrap(dnde_photon_pi_pi_pi0),\n \"pi pi eta\": wrap(dnde_photon_pi_pi_eta),\n \"pi pi etap\": wrap(dnde_photon_pi_pi_etap),\n \"pi pi omega\": wrap(dnde_photon_pi_pi_omega),\n \"pi0 pi0 omega\": wrap(dnde_photon_pi0_pi0_omega),\n \"pi0 k0 k0\": wrap(dnde_photon_pi0_k0_k0),\n \"pi0 k k\": wrap(dnde_photon_pi0_k_k),\n \"pi k k0\": wrap(dnde_photon_pi_k_k0),\n \"pi pi pi pi\": wrap(dnde_photon_pi_pi_pi_pi),\n \"pi pi pi0 pi0\": wrap(dnde_photon_pi_pi_pi0_pi0),\n \"v v\": wrap(dnde_photon_v_v),\n }","def le_func(rn, g, h):\n le = np.copy(rn)\n le -= g\n le -= h\n return le","def Heralded_HOM_exp_simulator(squeezing_parameter, bs_reflectivity, number_resolving_det=True, coher_ampl=0., old_PNR_func=False,\n cutoff=6, parallelized=False):\n\n #####################\n ### INITALISATION ###\n #####################\n\n nmodes = 4\n\n ## Initialises the initial covariance matrix of the Gaussian state to be the identity,\n ## meaning we start with vacuum in all modes.\n cov_mat = np.identity(2 * nmodes)\n\n ##############################\n ### DEFINE COHERENT STATES ###\n ##############################\n\n ## Defines the coherent state amplitudes in the input modes.\n ## Because no coherent state is present here, they are all zeros.\n ampls = np.ones(nmodes) * coher_ampl\n\n ###########################\n ### DEFINE SPDC SOURCES ###\n ###########################\n\n ## Defines the first SPDC source as a TMS between modes 0 and 1, as a symplectic transformation\n TMS1 = get_tms_sym(squeezing_parameter, phi=0, Mode1=0, Mode2=1, NumModes=nmodes)\n\n ## Defines the second SPDC source as a TMS between modes 2 and 3, as a symplectic transformation\n TMS2 = get_tms_sym(squeezing_parameter, phi=0, Mode1=2, Mode2=3, NumModes=nmodes)\n\n ############################\n ### DEFINE LINEAR OPTICS ###\n ############################\n\n ## Defines the linear-optical unitary (in this case a simple tunable beam-splitter),\n tunable_bs_matrix = np.identity(nmodes)\n tunable_bs_matrix[1, 1] = np.sqrt(1 - bs_reflectivity)\n tunable_bs_matrix[1, 2] = np.sqrt(bs_reflectivity)\n tunable_bs_matrix[2, 1] = - np.sqrt(bs_reflectivity)\n tunable_bs_matrix[2, 2] = np.sqrt(1 - bs_reflectivity)\n LO_unitary = tunable_bs_matrix\n\n ## Gets the linear-optical transformation in the symplectic form.\n LO_unitary_sym = get_unitary_sym(LO_unitary)\n\n ###############################################\n ### CALCULATE TOTAL GAUSSIAN TRANSFORMATION ###\n ###############################################\n\n ## Obtains the total Gaussian transformation matrix in the symplectic formalism\n sym_transf = LO_unitary_sym @ TMS2 @ TMS1\n\n #############################\n ### EVOLVE GAUSSIAN STATE ###\n #############################\n\n ## Obtains the covariance matrix of the output Gaussian state\n cov_mat = symplectic_evolution(cov_mat, sym_transf)\n\n ## Obtains the amplitudes of the output Gaussian state\n ampls = LO_unitary @ ampls\n\n ###############################\n ### SINGLE PHOTON DETECTION ###\n ###############################\n\n ## Map state into the StrawberryField package, which has fast functions for\n ## photon counting (i.e. non-Gaussian measurements) from Gaussian states.\n gauss_state = map_into_StrawberryFields(ampls, cov_mat, nmodes)\n\n ## Define in which modes we want t observe a coincidence detection.\n ## In this case we are looking for a 4-fold coincidence detection with a photon in all four modes.\n ## Repeated elements would represent multiple photons in the same mode. I.e. [0, 0, 2]\n ## would indicate two photons in mode 0 and one in mode 2.\n output_configuration = [0, 1, 2, 3]\n\n ## convert the detection configuration into a Fock state\n output_Fock = conf_to_Fock(output_configuration, nmodes)\n\n if number_resolving_det:\n ## Calculates the detection probability considering number-resolving detectors.\n det_prob = gauss_state.fock_prob(output_Fock)\n else:\n if old_PNR_func:\n ## Calculates the detection probability considering threshold detectors.\n det_prob = threshold_detection_prob_old(gauss_state, output_Fock, cutoff=cutoff)\n else:\n ## Calculates the detection probability considering threshold detectors.\n if parallelized:\n det_prob = threshold_detection_prob_parallel(gauss_state.cov(), gauss_state.means(), output_Fock)\n else:\n det_prob = threshold_detection_prob(gauss_state.cov(), gauss_state.means(), output_Fock)\n\n return det_prob","def next_heegner_disc(self, n=0, sgn=-1, fd=False):\n for D in range(n + 1, 2 * n + 100):\n DD = D * sgn\n if(self.is_Heegner_disc(DD)):\n return DD\n raise ArithmeticError(\" COuld not find any Heegner discriminat > {0} !\".format(n))","def test_h_gate_nondeterministic_minimal_basis_gates(self):\n shots = 2000\n circuits = ref_1q_clifford.h_gate_circuits_nondeterministic(final_measure=True)\n targets = ref_1q_clifford.h_gate_counts_nondeterministic(shots)\n job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='U,CX')\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)","def test_tanh_con():\n c=14\n assert {'diff':EF.tanh(c).der, 'value': EF.tanh(c).val}=={'diff':0, 'value': ((math.exp(c)-math.exp(-c))/2)/((math.exp(c)+math.exp(-c))/2)}","def rnn_tanh_cell_grad(input, hidden, w_ih, w_hh, b_ih, b_hh, grad, target=\"cce\"):\n batch, input_size = get_shape(input)\n _, hidden_size = get_shape(hidden)\n igates = akg.topi.nn.dense(input, w_ih, b_ih)\n hgates = akg.topi.nn.dense(hidden, w_hh, b_hh)\n h = Tanh(igates + hgates)\n\n dh = (1 - h * h) * grad\n kk = akg.tvm.reduce_axis((0, batch))\n dWih = akg.tvm.compute((hidden_size, input_size), lambda i, j:\n akg.tvm.sum(input[kk, j] * dh(kk, i), axis=kk), name=\"dWih\")\n kk2 = akg.tvm.reduce_axis((0, batch))\n dWhh = akg.tvm.compute((hidden_size, hidden_size), lambda i, j:\n akg.tvm.sum(hidden[kk2, j] * dh(kk2, i), axis=kk2), name=\"dWhh\")\n kk3 = akg.tvm.reduce_axis((0, hidden_size))\n di = akg.tvm.compute((batch, input_size), lambda i, j: akg.tvm.sum(w_ih[kk3, j] * dh[i, kk3], axis=kk3), name=\"di\")\n kk4 = akg.tvm.reduce_axis((0, hidden_size))\n dhid = akg.tvm.compute((batch, hidden_size), lambda i, j: akg.tvm.sum(w_hh[kk4, j] * dh[i, kk4], axis=kk4), name=\"dhid\")\n db = akg.topi.sum(dh, 0)\n return di, dhid, dWih, dWhh, db\n # dbih/dbhh are the same and returning it twice causes CCEbuild to fail due to some SSA error\n # return di, dhid, dWih, dWhh, db, db","def HaarGOB(treeG):\n # number of level of the chain (or tree)\n Ntr = len(treeG)\n # reorder chain (optional) \n # reordering each level so that in each level the nodes are in the\n # descent order of degrees\n # compute u_l^c for level J_0 (top level)\n clusterJ0 = treeG[Ntr-1]['clusters']\n N0 = len(clusterJ0)\n # generate indicator function on G^c\n chic = np.identity(N0)\n uc = [None]*N0\n uc[0] = 1/np.sqrt(N0,dtype=np.float64)*np.ones(N0)\n for l in np.arange(1, N0):\n uc[l] = np.sqrt((N0-l)/(N0-l+1))*(chic[l-1,:]-1/(N0-l)*np.sum(chic[l:,:], axis=0))\n# u = copy.deepcopy(uc)\n treeG[Ntr-1]['u'] = uc\n # compute the next level orthonormal basis ulk and stored into u\n for j_tr in np.arange(0, Ntr-1)[::-1]:\n N1 = len(treeG[j_tr]['clusters'])\n u = [None]*N1\n i = N0\n for l in range(N0):\n clusterl = treeG[j_tr+1]['clusters'][l]\n kl = len(clusterl)\n #for k==1\n ucl = uc[l]\n ul1 = np.zeros(N1)\n for j in range(N0):\n idxj = treeG[j_tr+1]['clusters'][j]\n ul1[idxj] = ucl[j]/np.sqrt(len(idxj))\n u[l] = ul1\n if kl>1:\n chil = np.zeros((kl,N1))\n for k in range(kl):\n idxl = treeG[j_tr+1]['clusters'][l]\n chil[k,idxl[k]] = 1;\n \n for k in np.arange(1,kl):\n i = i+1\n ulk = np.sqrt((kl-k)/(kl-k+1))*(chil[k-1,:]-1/(kl-k)*np.sum(chil[k:,:],axis=0))\n u[i-1] = ulk\n treeG[j_tr]['u'] = u\n # update uc and N0\n# uc = copy.deepcopy(u)\n uc = u\n N0 = N1\n return treeG","def ftlan_E1c(hop, v0, T, m=50, Min_b=10e-10, Min_m=5, kB=1, norm = np.linalg.norm):\n# def Tri_diag(a1, b1):\n# mat = np.diag(b1, -1) + np.diag(a1, 0) + np.diag(b1, 1)\n# e, w = np.linalg.eigh(mat)\n# return e, w\n\n beta = 1./(T * kB)\n E = 0.\n a, b = [], []\n v0 = v0/norm(v0)\n Hv = hop(v0)\n a.append(v0.dot(Hv))\n v1 = Hv - a[0] * v0\n b.append(norm(v1))\n if b[0] < Min_b:\n return 0\n\n v1 = v1/b[0]\n Hv = hop(v1)\n a.append(v1.dot(Hv))\n\n for i in range(1, m - 1):\n v2 = Hv - b[i - 1] * v0 - a[i] * v1\n b.append(norm(v2))\n if abs(b[i]) < Min_b:\n b.pop()\n break\n\n v2 = v2/b[i]\n Hv = hop(v2)\n a.append(v2.dot(Hv))\n v0 = v1.copy()\n v1 = v2.copy()\n \n a = np.asarray(a)\n b = np.asarray(b)\n\n eps, phi = Tri_diag(a, b)\n l = len(eps)\n# Eo = eps[0]\n# eps = eps-Eo\n exp_eps = np.exp(-beta * eps)\n E = np.sum(exp_eps * eps * phi[0, :]**2.)\n Z = np.sum(exp_eps * phi[0, :]**2.)\n# for i in range(len(eps)):\n# E += exp_eps[i] * eps[i] * phi[0, i]**2\n\n# E = E + Eo\n# de = eps[:, np.newaxis] - eps\n# for i in range(l):\n# E += eps[i] * phi[0, i]**2./np.sum(np.exp(-beta*de[:l, i])*(phi[0, :l]**2.))\n return E, Z","def real_extract(og, fg):\n\n oe = sg2plato(og)\n ae = sg2plato(fg)\n q = 0.22 + 0.001 * oe\n return (q * oe + ae) / (1 + q)","def test6(self):\n smis = [ 'CCC(O)C(=O)O','c1ccccc1','C1CCCCC1','C1NCCCC1','CNCNCNC']\n for smi in smis:\n m = Chem.MolFromSmiles(smi)\n fp1 = Chem.RDKFingerprint(m,2,7,4096)\n fp2 = DataStructs.FoldFingerprint(fp1,2)\n fp3 = Chem.RDKFingerprint(m,2,7,2048)\n assert tuple(fp2.GetOnBits())==tuple(fp3.GetOnBits())\n fp2 = DataStructs.FoldFingerprint(fp2,2)\n fp3 = Chem.RDKFingerprint(m,2,7,1024)\n assert tuple(fp2.GetOnBits())==tuple(fp3.GetOnBits())\n fp2 = DataStructs.FoldFingerprint(fp1,4)\n assert tuple(fp2.GetOnBits())==tuple(fp3.GetOnBits())","def hgmwithfilter_evaluation(input_generator,branches,nlfuntion,iden_method,Plot,reference=None):\n input_signal = input_generator.GetOutput()\n # filter_spec_tofind = nlsp.create_bpfilter([2000,8000,30000],input_signal)\n filter_spec_tofind = nlsp.log_bpfilter(branches=branches,input=input_signal)\n # filter_spec_tofind = [i for i in reversed(filter_spec_tofind)]\n length_kernel = len(filter_spec_tofind[0])\n # filter_spec_tofind = nlsp.log_chebyfilter(branches=branches,input=input_signal)\n ref_nlsystem = nlsp.HammersteinGroupModel_up(input_signal=input_signal,\n nonlinear_functions=nlsp.nl_branches(nlfuntion,branches),\n filter_irs=filter_spec_tofind,\n max_harmonics=range(1,branches+1))\n found_filter_spec, nl_functions = iden_method(input_generator,ref_nlsystem.GetOutput(),branches)\n found_filter_spec = nlsp.change_length_filterkernels(found_filter_spec,length=length_kernel)\n iden_nlsystem = nlsp.HammersteinGroupModel_up(input_signal=input_signal,\n nonlinear_functions=nl_functions,\n filter_irs=found_filter_spec,\n max_harmonics=range(1,branches+1))\n # nlsp.filterkernel_evaluation_plot(filter_spec_tofind,found_filter_spec)\n # nlsp.filterkernel_evaluation_sum(filter_spec_tofind,found_filter_spec)\n if reference is not None:\n reference = nlsp.change_length_signal(reference,length=len(input_signal))\n ref_nlsystem.SetInput(reference)\n iden_nlsystem.SetInput(reference)\n if Plot is True:\n plot.relabelandplot(ref_nlsystem.GetOutput(),\"Reference Output\",show=False)\n plot.relabelandplot(iden_nlsystem.GetOutput(),\"Identified Output\",show=True)\n # nlsp.plot_array([sumpf.modules.FourierTransform(s).GetSpectrum() for s in filter_spec_tofind],label_array=[\"reference%d\" %i for i in range(len(filter_spec_tofind))],Show=False)\n # nlsp.plot_array([sumpf.modules.FourierTransform(s).GetSpectrum() for s in found_filter_spec],label_array=[\"identified%d\" %i for i in range(len(found_filter_spec))],Show=True)\n print \"SNR between Reference and Identified output without overlapping filters: %r\" %nlsp.snr(ref_nlsystem.GetOutput(),\n iden_nlsystem.GetOutput())\n sumpf.modules.SignalFile(filename=\"C:/Users/diplomand.8/Desktop/linearHGM_explannation/cheby/noise/input\", signal=reference,format=sumpf.modules.SignalFile.WAV_FLOAT)\n sumpf.modules.SignalFile(filename=\"C:/Users/diplomand.8/Desktop/linearHGM_explannation/cheby/noise/%s\" %iden_method.__name__,signal=iden_nlsystem.GetOutput(),format=sumpf.modules.SignalFile.WAV_FLOAT)\n sumpf.modules.SignalFile(filename=\"C:/Users/diplomand.8/Desktop/linearHGM_explannation/cheby/noise/reference\",signal=ref_nlsystem.GetOutput(),format=sumpf.modules.SignalFile.WAV_FLOAT)","def cantor() -> bigger.MCG[Edge]: # pylint: disable=too-many-statements\n\n POS, EQ, NEG = +1, 0, -1\n\n def edges() -> Iterable[Edge]:\n for x in naturals():\n for y in [POS, EQ, NEG]:\n yield x, y\n\n def negate(X: Edge) -> Edge:\n return X[0], -X[1]\n\n def invert(sign: int, X: tuple[Edge, bool, Edge, bool, Edge, bool, Edge, bool]) -> tuple[Edge, bool, Edge, bool, Edge, bool, Edge, bool]:\n return X if sign == POS else (negate(X[6]), not X[7], negate(X[4]), not X[5], negate(X[2]), not X[3], negate(X[0]), not X[1])\n\n def link(edge: Edge) -> tuple[Edge, bool, Edge, bool, Edge, bool, Edge, bool]:\n n, k = edge\n if k == EQ: # Equator\n if n == 0:\n return ((0, NEG), False, (1, NEG), True, (1, POS), False, (0, POS), True)\n elif n == 1:\n return ((2, POS), False, (0, POS), False, (0, NEG), True, (2, NEG), True)\n else: # n > 1\n return ((3 * n - 3, NEG), False, (3 * n - 1, NEG), True, (3 * n - 1, POS), False, (3 * n - 3, POS), True)\n\n # Northern / Southern hemisphere.\n if n == 0:\n return invert(k, ((0, EQ), False, (1, POS), False, (1, EQ), True, (2, POS), False))\n elif n == 1:\n return invert(k, ((4, POS), False, (3, POS), False, (0, POS), True, (0, EQ), False))\n elif n == 2:\n return invert(k, ((7, POS), False, (6, POS), False, (0, POS), False, (1, EQ), True))\n N, r = n // 3 + 1, n % 3\n incoming = 3 * (N // 2) - (1 if N % 2 else 2)\n if r == 0:\n return invert(k, ((N, EQ), False, (n + 2, POS), False, (incoming, POS), True, (n + 1, POS), False))\n elif r == 1:\n return invert(k, ((6 * N - 2, POS), False, (6 * N - 3, POS), False, (n - 1, POS), False, (incoming, POS), True))\n else: # r == 2:\n return invert(k, ((6 * N + 1, POS), False, (6 * N + 0, POS), False, (n - 2, POS), True, (N, EQ), False))\n\n T = bigger.Triangulation.from_pos(edges, link)\n\n def generator(name: str) -> bigger.Encoding[Edge]: # pylint: disable=too-many-branches\n twist_match = re.match(r\"(?P<curve>[ab])_(?P<n>-?\\d+)$\", name)\n rotate_match = re.match(r\"r$\", name)\n\n if twist_match is not None:\n parameters = twist_match.groupdict()\n curve_name = parameters[\"curve\"]\n N = int(parameters[\"n\"])\n if curve_name == \"a\":\n if N == 1:\n cut_sequence = [(0, EQ), (0, POS), (1, EQ)]\n else:\n cut_sequence = [(0, EQ), (N, EQ), (3 * N - 3, POS)]\n while N > 1:\n low_N = N // 2\n cut_sequence.append((3 * low_N - (1 if N % 2 else 2), POS))\n if N % 2:\n cut_sequence.append((3 * low_N - 3, POS))\n N = low_N\n elif curve_name == \"b\":\n if N <= 3:\n cut_sequence = [(0, EQ), (0, POS), (1, EQ)]\n else:\n extend_left = N % 2\n N = N // 2\n cut_sequence = [(N, EQ), (3 * N - 3, POS)]\n while N > 1:\n N_low = N // 2\n cut_sequence.append((3 * N_low - (1 if N % 2 else 2), POS))\n if extend_left:\n cut_sequence.append((3 * N_low - 3, POS))\n if N % 2 != extend_left:\n cut_sequence.append((N_low, EQ))\n break\n N = N_low\n else:\n cut_sequence.append((0, EQ))\n\n curve = T(dict(((x, y * s), 1) for x, y in cut_sequence for s in [+1, -1]))\n return curve.twist()\n elif rotate_match is not None:\n\n def isom(edge: Edge) -> Edge:\n n, k = edge\n if k == EQ:\n if n == 0:\n return (1, EQ)\n elif n == 1:\n return (0, EQ)\n return (n ^ (1 << n.bit_length() - 2), k)\n\n if n == 0:\n return (0, k)\n elif n == 1:\n return (2, k)\n elif n == 2:\n return (1, k)\n N, r = n // 3 + 1, n % 3\n return (3 * (N ^ (1 << N.bit_length() - 2)) - 3 + r, k)\n\n return T.encode([(-1, isom, isom)])\n\n raise ValueError(f\"Unknown mapping class {name}\")\n\n return bigger.MCG(T, generator)","def a5_homelien(clk, i, o):\n\n\tmajority = Signal(bool(0))\n\tr1, r1_reg, r1_clk, r1_out, r1_bit = lfsr_hw(clk, i, majority, 19, [13, 16, 17, 18], 8, \"R1\")\n\tr2, r2_reg, r2_clk, r2_out, r2_bit = lfsr_hw(clk, i, majority, 22, [20, 21], 10, \"R2\")\n\tr3, r3_reg, r3_clk, r3_out, r3_bit = lfsr_hw(clk, i, majority, 23, [7, 20, 21, 22], 10, \"R3\")\n\t@always_comb\n\tdef xors():\n\t\t# this should be done automatically with the chain function from the lists above\n\t\t# but perhaps need to complain on myhdl list to get it working again\n\t\tr1_bit.next = i[0] ^ r1_reg[13] ^ r1_reg[16] ^ r1_reg[17] ^ r1_reg[18]\n\t\tr2_bit.next = i[0] ^ r2_reg[20] ^ r2_reg[21]\n\t\tr3_bit.next = i[0] ^ r3_reg[7] ^ r3_reg[20] ^ r3_reg[21] ^ r3_reg[22]\n\n\t@always_comb\n\tdef calc_stuff():\n\t\tmajority.next = (r1_clk + r2_clk + r3_clk) >= 2\n\t\to.next = r1_out ^ r2_out ^ r3_out\n\n\treturn (r1, r2, r3, calc_stuff, xors)","def chkiapws09table6(printresult=True,chktol=_CHKTOL):\n from teospy.tests.tester import Tester\n args1 = [(273.15,101325.), (273.15,1e8), (313.15,101325.)]\n DERS2 = ((0,0),(1,0),(0,1),(2,0),(1,1),(0,2))\n \n funs = liq_g\n fargs = [(der+args) for args in args1 for der in DERS2]\n refs = [\n 0.101342743e3,0.147644587,0.100015695e-2,-0.154472324e2,\n -0.677459513e-7,-0.508915308e-12,\n 0.977303868e5,0.851506346e1,0.956683354e-3,-0.142970174e2,\n 0.199088060e-6,-0.371527164e-12,\n -0.116198898e5,-0.572365181e3,0.100784471e-2,-0.133463968e2,\n 0.388499694e-6,-0.445841077e-12\n ]\n fnames = 'liq_g'\n argfmt = '({0:1g},{1:1g},{2:6.2f},{3:6g})'\n header = 'F03 liq_g derivatives'\n testder = Tester(funs,fargs,refs,fnames,argfmt,header=header)\n \n funs = [cp,density,soundspeed,\n enthalpy,entropy,helmholtzenergy,internalenergy]\n fargs = args1\n refs = [\n [0.421941153e4,0.390523030e4,0.417942416e4],\n [0.999843071e3,0.104527793e4,0.992216354e3],\n [0.140240099e4,0.157543089e4,0.152891242e4],\n [0.610136242e2,0.954044973e5,0.167616267e6],\n [-0.147644587,-0.851506346e1,0.572365181e3],\n [0.183980891e-2,0.206205140e4,-0.117220097e5],\n [-0.403272791e2,-0.263838183e3,0.167514147e6]\n ]\n fnames = ['cp','density','soundspeed',\n 'enthalpy','entropy','helmholtzenergy','internalenergy']\n argfmt = '({0:6.2f},{1:6g})'\n header = 'F03 thermodynamic properties'\n testprop = Tester(funs,fargs,refs,fnames,argfmt,header=header)\n \n # Run Tester instances and print results\n testder.run()\n testprop.run()\n if printresult:\n testder.printresults(chktol=chktol)\n testprop.printresults(chktol=chktol)\n return (testder, testprop)","def test():\n Z = func.evaluate_circuit(F, e_x, e_y, e_xor)\n if Z == d[0]:\n return 0\n elif Z == d[1]:\n return 1","def test_mannext(self):\n self.chck_triple('mannext')","def FigA7(case):\n \n #set the parameter, arrays\n \n n_array=np.array([1,2,3])\n\n #set the result arrays\n if case==0:\n class_number=5\n elif case==1:\n class_number=6\n fate=np.zeros([class_number])#number of evolutionary fate\n fate_matrix=np.zeros([np.size(n_array),np.size(fate)])\n \n time=np.linspace(0,100000, 1000000)\n loop=10**6\n \"\"\"\n 0 Co and/or Ch cannot survive in mono-culture\n 1 Co cannot invade\n 2 Only equilibrium of exclusion is stable\n 3 Only equilibrium of coexistence is stable\n 4 Two equilibria are UNstable\n 5 two Equilibrium are stable (which may occur only when sCO vs rCh)\n \"\"\"\n for tri in range(np.size(n_array)):\n counter=0\n n=n_array[tri]\n print(str(\"Hill coefficient is %d\" %(n)))\n fate=np.zeros([class_number])#number of evolutionary fate should be reset\n if case==0 or case==1:\n fname=str('parameter-sweep-MC-n%d-case%d' %(n, case))\n else:\n print(\"Error in case\")\n return 1\n \n for i in range(loop):\n if(i+1)%10000==0:\n print(i+1)\n Ks,cd,T0, alpha,=np.random.uniform(0,1,4)\n Kr,cr=np.random.uniform([Ks,0],[1,1],2)#Kr>Ks and cr.cd\n #check whether r is positive or not\n if case==0:\n r1=rmax*(1-cr-cd)#rCO\n r2=rmax#sCH\n W0Co=r1-dmax*T0**n/(T0**n+Kr**n)-alpha#initial growth of Cooperator\n W0Ch=r2-dmax*T0**n/(T0**n+Ks**n)-alpha#initial growth of Cheater\n elif case==1:\n r1=rmax*(1-cd)#sCo\n r2=rmax*(1-cr)#rCh\n W0Co=r1-dmax*T0**n/(T0**n+Ks**n)-alpha\n W0Ch=r2-dmax*T0**n/(T0**n+Kr**n)-alpha\n stab_e=0#initialize the falgs of stability\n stab_c=0\n if W0Co<0 or W0Ch<0:\n fate[0]+=1\n res=0\n else:\n #succeed in mono-culture \n init=np.array([T0,10**(-6)])\n if case==0: \n solCo=odeint(DyCoop, init, time, args=(T0, r1, Kr, alpha, n))\n Ts=solCo[-1,0]\n #x1s=solCo[-1,1]\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Ks, alpha, n))\n x2s=solCh[-1,1]\n else:\n solCo=odeint(DyCoop, init, time, args=(T0, r1, Ks, alpha, n))\n Ts=solCo[-1,0]\n #x1s=solCo[-1,1]\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Kr, alpha, n))\n x2s=solCh[-1,1]\n \n #Evolutionary dynamics \n if case==0:\n K=Kr\n else:\n K=Ks\n if r1*(1-x2s)-dmax*T0**n/(T0**n+K**n)<alpha:\n #Co cannot invade\n fate[1]+=1\n res=1\n else:\n #Co can invade\n #calculate Tdagger Td and check whether coexist or exclude\n if case==0:\n #rCo vs sCh\n #in this case, at most one equilbrium is stable\n tau=Quad(case,alpha,cr+cd,0,Kr, Ks, n)\n Td=tau**(1/n)\n if Td<Ts:\n #Co exclude Ch\n fate[2]+=1\n res=2\n else:\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\n #check the stability condition\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\n if stab==0:\n #stable coexistence\n fate[3]+=1\n res=3\n else:\n #unstable coexistence nor exclusion\n fate[4]+=1\n res=4\n print(Td, x1d, x2d)\n else:\n #sCo vs rCh\n # in this case two equilibria can be stable at the same time\n [tau_p,tau_m]=Quad(case,alpha,cd,cr,Ks, Kr, n)\n if tau_m>Ts**n or tau_p<Ts**n:\n # cexclusion is stable\n stab_e=1\n # stability in coexistence \n if tau_p<0:\n stab_c=0\n else:\n Td=tau_p**(1/n)\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\n #check the stability condition\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\n if stab==0:\n #stable coexistence\n stab_c=1\n #classify\n if stab_e==1 and stab_c==1:\n # two stable equilbria\n fate[5]+=1\n res=5\n elif stab_e==1 and stab_c==0:\n #only stable cexclusion\n fate[2]+=1\n res=2\n elif stab_e==0 and stab_c==1:\n #stable coexistence\n fate[3]+=1\n res=3\n else:\n #both unstable\n fate[4]+=1\n res=4\n \n #save the results\n if counter==0:\n result=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\n #save the result with parameter values\n \n else:\n #add array of results\n R=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\n result=np.concatenate((result, R), axis=0)\n counter+=1\n \n #save csv file and graph\n np.savetxt(fname+'.csv',result, delimiter=',', header='Ks, Kr, cr, cd, alpha, T0, class', fmt='%.6f') \n print(fate)\n fate_matrix[tri,:]=fate \n if case==0: \n np.savetxt('parameter_sweep_MC_total_case0.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4', fmt='%d')\n else:\n np.savetxt('parameter_sweep_MC_total_case1.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4,cl5', fmt='%d')\n Plot(case)","def pollard(N) :\n\tleft = right = seed\n\td = 1\n\twhile d == 1: \n\t\tleft = pseudo(left,N)\n\t\tright = pseudo(pseudo(right,N),N)\n\t\td = gcd(abs(left-right),N)\n\t\tif PRINT_TRACE : \n\t\t\tprint(left,right,d)\n\tif d == N : \n\t\tprint(\"Failure\")\n\telse :\n\t\tprint(\"non trivial factor is %d\"%d)","def CFHX(m_dot, p_nominal, epsilon, p_HP_in, T_HP_in, p_LP_in, T_LP_in):\r\n\r\n\r\n # Data from Aleks:\r\n # Length CFHX = 22 cm\r\n # D_in = 23.6 mm, D_out 40.5 mm\r\n # T range: 40 K - 5 K\r\n # m_dot = 0.5 g/s\r\n # p = 1 bar\r\n # Effectiveness: 97.4 %\r\n # dp_HP = 4.8 mbar (= dp23)\r\n # dp_LP = 5 mbar (= dp78)\r\n\r\n # Geometry of the CFHX\r\n A_HP = 0.25 * np.pi * 0.0236**2 #m²\r\n A_LP = 0.25 * np.pi * (0.0405**2 - 0.0236**2) #m²\r\n\r\n\r\n ## Calculation of the outgoing pressure with the scaled pressure drops\r\n\r\n # Scaling of the pressure drop with the Darcy--Weisbach equation\r\n # dp = f *L/D_i * 0.5 * Rho * u**2\r\n dp_HP_Aleks = 4.8e2 #Pa\r\n dp_LP_Aleks = 5.0e2 #Pa\r\n # Mean density with the arithmetic mean of the temperature range values\r\n Rho_Aleks = hp.HeCalc(3, 0, 1, 1e5, 2, 0.5*(40+5), 1) #kg/m³\r\n u_HP_Aleks = 0.5e-3/(A_HP*Rho_Aleks) #m/s\r\n u_LP_Aleks = 0.5e-3/(A_LP*Rho_Aleks) #m/s\r\n\r\n # Mean density of the two inlet temperatures and the nominal pressure to be able to compare the dp\r\n Rho = hp.HeCalc(3, 0, 1, p_nominal, 2, 0.5*(T_HP_in + T_LP_in), 1) #kg/m³\r\n u_HP = m_dot/(A_HP*Rho) #m/s\r\n u_LP = m_dot/(A_LP*Rho) #m/s\r\n\r\n # Actual scaling\r\n dp_HP = Rho/Rho_Aleks * u_HP**2/u_HP_Aleks**2 * dp_HP_Aleks #Pa\r\n dp_LP = Rho/Rho_Aleks * u_LP**2/u_LP_Aleks**2 * dp_LP_Aleks #Pa\r\n\r\n # Calculation of the outgoing pressure with the scaled pressure drops\r\n p_HP_out = p_HP_in - dp_HP #Pa\r\n p_LP_out = p_LP_in - dp_LP #Pa\r\n\r\n\r\n ## Calculation of the outgoing temperatures using the effectiveness\r\n # Asumming that the effectiveness is the same for both the HP and the LP side!\r\n\r\n # Check which stream restricts the heat exchange -> Pinch point\r\n # See \"Compact heat exchangers\" by Kays, London : Chapter 7\r\n dh_HP_max = hp.HeCalc(9, 0, 1, p_HP_in, 2, T_HP_in, 1) - hp.HeCalc(9, 0, 1, p_HP_out, 2, T_LP_in, 1)\r\n dh_LP_max = hp.HeCalc(9, 0, 1, p_LP_out, 2, T_HP_in, 1) - hp.HeCalc(9, 0, 1, p_LP_in, 2, T_LP_in, 1)\r\n\r\n # The maximum possible heat transfer corresponds to the restricting one\r\n dh_max = min(dh_HP_max, dh_LP_max)\r\n\r\n # Calculating the specific enthalpy with all known pressures and temperatures\r\n h_HP_in = hp.HeCalc(9, 0, 1, p_HP_in, 2, T_HP_in, 1) #J/kg\r\n h_LP_in = hp.HeCalc(9, 0, 1, p_LP_in, 2, T_LP_in, 1) #J/kg\r\n\r\n # Calculating the outgoing enthalpies\r\n h_HP_out = h_HP_in - epsilon * dh_max #J/kg\r\n h_LP_out = h_LP_in + epsilon * dh_max #J/kg\r\n\r\n # Calculation of the temperatures dependend on the specific enthalpy and the pressure\r\n T_HP_out = hp.HeCalc(2, 0, 1, p_HP_out, 9, h_HP_out, 1) #K\r\n T_LP_out = hp.HeCalc(2, 0, 1, p_LP_out, 9, h_LP_out, 1) #K\r\n\r\n # Cross check the dp scaling\r\n # print(\"u_HP_Aleks\", u_HP_Aleks)\r\n # print(\"u_HP\", u_HP)\r\n # print(\"Rho_Aleks\", Rho_Aleks)\r\n # print(\"Rho\", Rho)\r\n # print(\"dp_HP\", dp_HP)\r\n # print(\"dp_HP/dp_HP_Aleks \", dp_HP/dp_HP_Aleks)\r\n # print(\"dp_LP/dp_LP_Aleks \", dp_LP/dp_LP_Aleks)\r\n\r\n # Output of the results\r\n state_out = {\"h_HP\": h_HP_out, \"T_HP\": T_HP_out, \"p_HP\": p_HP_out,\r\n \"h_LP\": h_LP_out, \"T_LP\": T_LP_out, \"p_LP\": p_LP_out}\r\n return state_out","def softclippingHGMevaluation(input_generator,branches,iden_method,Plot,reference=None):\n for t in range(8,11):\n t = t / 10.0\n p = 1.0 - t\n input_signal = input_generator.GetOutput()\n nl_functions = [nlsp.function_factory.softclip(power=p),]*branches\n filter_spec_tofind = nlsp.log_bpfilter(branches=branches, input=input_signal)\n ref_nlsystem = nlsp.HammersteinGroupModel_up(input_signal=input_signal,\n nonlinear_functions=nl_functions,\n filter_irs=filter_spec_tofind,\n max_harmonics=range(1,branches+1))\n\n found_filter_spec, nl_functions = iden_method(input_generator,ref_nlsystem.GetOutput(),branches)\n iden_nlsystem = nlsp.HammersteinGroupModel_up(input_signal=input_signal,\n nonlinear_functions=nl_functions,\n filter_irs=found_filter_spec,\n max_harmonics=range(1,branches+1))\n # sine = sumpf.modules.SineWaveGenerator(frequency=5000.0,phase=0.0,samplingrate=input_signal.GetSamplingRate(),length=len(input_signal)).GetSignal()\n sine = sumpf.modules.SweepGenerator(samplingrate=input_signal.GetSamplingRate(),length=len(input_signal)).GetSignal()\n ref_nlsystem.SetInput(sine)\n iden_nlsystem.SetInput(sine)\n if reference is not None:\n reference = nlsp.change_length_signal(reference,length=len(input_signal))\n ref_nlsystem.SetInput(reference)\n iden_nlsystem.SetInput(reference)\n\n if Plot is True:\n plot.relabelandplot(sumpf.modules.FourierTransform(ref_nlsystem.GetOutput()).GetSpectrum(),\"Reference System\",show=False)\n plot.relabelandplot(sumpf.modules.FourierTransform(iden_nlsystem.GetOutput()).GetSpectrum(),\"Identified System\",show=False)\n print \"SNR between Reference and Identified output for symmetric hardclipping HGM(threshold:%r): %r\" %(t,nlsp.snr(ref_nlsystem.GetOutput(),\n iden_nlsystem.GetOutput()))","def hilfe(self):\n sDreieck_hilfe(3)","def test_bit_driver_output(self):\n\n H = qaoa.bit_driver(range(3), 1)\n hamiltonian = qml.Hamiltonian([1, 1, 1], [qml.PauliZ(0), qml.PauliZ(1), qml.PauliZ(2)])\n\n assert decompose_hamiltonian(H) == decompose_hamiltonian(hamiltonian)","def test_helpers():\n\n print \"GCD of 8 and 12 is %0d\" % fractions.gcd(8, 12)\n\n print \"%0d and %0d are co-prime\" % (2, coPrime(2))\n print \"%0d and %0d are co-prime\" % (6, coPrime(6))\n\n mod_inverse(11, 60)\n\n modulo(2, 3, 4)\n\n totient(24)","def dice(hm, hf):\n return 2 * np.count_nonzero(hm & hf) / float(np.count_nonzero(hm) + np.count_nonzero(hf))","def needleman_wunsch(x, y, lodict={}, gop=-2.5, gep=-1.75, local=False, indel=''):\n n, m = len(x), len(y)\n dp = np.zeros((n + 1, m + 1))\n pointers = np.zeros((n + 1, m + 1), np.int32)\n if not local:\n for i1, c1 in enumerate(x):\n if gop is None:\n dp[i1 + 1, 0] = lodict.get((c1, indel), gep)\n else:\n dp[i1 + 1, 0] = dp[i1, 0]+(gep if i1 + 1 > 1 else gop)\n pointers[i1 + 1, 0] = 1\n for i2, c2 in enumerate(y):\n if gop is None:\n dp[0, i2 + 1] = lodict.get((indel, c2), gep)\n else:\n dp[0, i2 + 1] = dp[0, i2]+(gep if i2 + 1 > 1 else gop)\n pointers[0, i2 + 1] = 2\n for i1, c1 in enumerate(x):\n for i2, c2 in enumerate(y):\n match = dp[i1, i2] + lodict.get(\n (c1, c2),\n 1 if c1 == c2 else -1)\n insert = dp[i1, i2 + 1] + (\n lodict.get((c1, indel), gep) if gop is None else\n gep if pointers[i1, i2 + 1] == 1 else gop)\n delet = dp[i1 + 1, i2] + (\n lodict.get((indel, c2), gep) if gop is None else\n gep if pointers[i1 + 1, i2] == 2 else gop)\n pointers[i1 + 1, i2 + 1] = p = np.argmax([match, insert, delet])\n max_score = [match, insert, delet][p]\n if local and max_score < 0:\n max_score = 0\n dp[i1 + 1, i2 + 1] = max_score\n alg = []\n if local:\n i, j = np.unravel_index(dp.argmax(), dp.shape)\n else:\n i, j = n, m\n score = dp[i, j]\n while (i > 0 or j > 0):\n pt = pointers[i, j]\n if pt == 0:\n i -= 1\n j -= 1\n alg = [(x[i], y[j])] + alg\n if pt == 1:\n i -= 1\n alg = [(x[i], indel)] + alg\n if pt == 2:\n j -= 1\n alg = [(indel, y[j])] + alg\n if local and dp[i, j] == 0:\n break\n return score, alg","def hilfe(self):\n sZweieck_hilfe(3)","def make_Gr(mlat, *J):\n\n if (len(J)!=3):\n print(\"Number of paramaters are not right, must be 5!\")\n \n NN = 2*mlat # # of sites in one super unitcell\n tau = -np.zeros((NN, NN),dtype=complex)\n h = np.zeros((NN,NN), dtype=complex)\n\n # translational cell's Hamiltonian\n for i in range(mlat-1):\n if (i%2==0):\n h[i,i+1] = J[0]\n h[mlat+i,mlat+i+1] = J[1]\n h[i,mlat+i] = J[2] # horizoltal connection\n elif (i%2==1):\n h[i,i+1] = J[1]\n h[mlat+i,mlat+i+1] = J[0]\n # longitudinal connection of the last sites\n if (mlat-1)%2 == 0:\n h[mlat-1,2*mlat-1] = J[2]\n \n h = h + h.conj().T # make it hermitian\n\n # Hopping matrix\n for i in range(1,mlat,2):\n tau[i+mlat,i] = J[2]\n\n return h, tau","def tanh(a):","def TR_algo3(h, vd=2):\n ve = 0\n vd = 2\n p = [0]*N\n for i in range(M-1, -1, -1):\n w = [bit_component(h, i*N+ii) for ii in range(N)]\n #print(i, w)\n w = sum( [wx*2**j for j, wx in enumerate(w)] )\n #print(i, w, gc(w))\n l = gc(w)\n l = T_inv(ve, vd, l)\n for j in range(N):\n p[j] += bit_component(l, j) << i\n ve = ve ^ rotate_left(e(w), vd+1)\n vd = (vd + d(w) + 1) % N\n return p","def enthalpy(temp,pres):\n g = liq_g(0,0,temp,pres)\n g_t = liq_g(1,0,temp,pres)\n h = g - temp*g_t\n return h","def detect_edges_hed(self):\n inp = cv2.dnn.blobFromImage(self.input_image, scalefactor=1.0,\n size=(self.WIDTH, self.HEIGHT),\n mean=(104.00698793, 116.66876762, 122.67891434),\n swapRB=False, crop=False)\n self.net.setInput(inp)\n out = self.net.forward()\n hed = out[0, 0]\n hed = (255 * hed).astype(\"uint8\")\n hed = cv2.fastNlMeansDenoising(hed, SMOOTH_FACTOR, SMOOTH_FACTOR, 21)\n save_image_opencv(hed, 'hed')\n hed_skel = skeletonize(hed).astype(\"uint8\")\n save_image_opencv(hed_skel, 'hed_skel')\n thresheld_hed = cv2.threshold(hed_skel, 0, 255,\n cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]\n save_image_opencv(thresheld_hed, 'thresheld_hed')\n return hed, thresheld_hed","def test_hof(a, b):\n def f(g, x):\n return g(x) * g(x + 10.0)\n\n def g(x):\n return x * b\n\n return f(g, a) + f(g, b)","def hilfe(self):\n sKreis_hilfe(3)","def current_operator(h0):\n h = h0.copy()\n h = h0.get_multicell() # multicell Hamiltonian\n if h.dimensionality != 1: raise # only for 1d\n if not h.is_multicell: # no multicell\n def fj(k):\n phik = np.exp(1j*2.*np.pi*k) # complex phase\n jk = 1j*(h.inter*phik - h.inter.H*np.conjugate(phik)) \n return jk\n else: # multicell Hamiltonian\n def fj(k):\n jk = h.intra*0. # initialize\n for t in h.hopping:\n phik = np.exp(1j*2.*np.pi*k*t.dir[0]) # complex phase\n jk = jk + 1j*t.m*phik*t.dir[0]\n return jk\n return fj","def Mo96(self,dc,nu):\n return 1. + (nu**2.-1.)/dc","def magma_zheevd_m(ngpu, jobz, uplo, n, A, lda, w, work, lwork,\n rwork, lrwork, iwork, liwork):\n\n uplo = _uplo_conversion[uplo]\n info = c_int_type()\n status = _libmagma.magma_zheevd_m(ngpu, jobz, uplo, n, int(A), lda,\n int(w), int(work), lwork, int(rwork),\n lrwork, int(iwork), liwork, ctypes.byref(info))\n magmaCheckStatus(status)","def fix_COO_and_NH(pdb):\n M = Molecule(pdb)\n ds = M.ds\n g = M.g\n m = Chem.MolFromPDBFile(pdb, removeHs=True) # don't use True, otherwise Error\n mc = Chem.EditableMol(m)\n q = Chem.MolFromSmarts( 'C(~[O])~[O]' )\n matches = m.GetSubstructMatches(q)\n #bom = Chem.GetAdjacencyMatrix(m,useBO=True)\n for (i,j,k) in matches:\n d1, d2 = ds[i,j], ds[i,k]\n b1 = m.GetBondBetweenAtoms(i,j)\n b2 = m.GetBondBetweenAtoms(i,k)\n if d1 < d2:\n bij = 2.0; bik = 1.0\n else:\n bij = 1.0; bik = 2.0\n mc.RemoveBond(i,j)\n mc.RemoveBond(i,k)\n mc.AddBond(i,j,bo2bt['%.1f'%bij])\n mc.AddBond(i,k,bo2bt['%.1f'%bik])\n mu = mc.GetMol()\n return mu\n # NX4, e.g., >[N+]<, >[NH+]-, >[NH2+], -[NH3+]\n #q = Chem.MolFromSmarts( '[NX4]' )\n\n # [*]~NX2, e.g., >C=[NH2+]\n\n # [*]~NX, e.g., >C=[NH+]-","def test_hyperbolic_functions(self):\r\n inputs = ['0', '0.5', '1', '2', '1+j']\r\n neg_inputs = ['0', '-0.5', '-1', '-2', '-1-j']\r\n negate = lambda x: [-k for k in x]\r\n\r\n # sinh is odd\r\n sinh_vals = [0, 0.521, 1.175, 3.627, 0.635 + 1.298j]\r\n self.assert_function_values('sinh', inputs, sinh_vals)\r\n self.assert_function_values('sinh', neg_inputs, negate(sinh_vals))\r\n\r\n # cosh is even - do not negate\r\n cosh_vals = [1, 1.128, 1.543, 3.762, 0.834 + 0.989j]\r\n self.assert_function_values('cosh', inputs, cosh_vals)\r\n self.assert_function_values('cosh', neg_inputs, cosh_vals)\r\n\r\n # tanh is odd\r\n tanh_vals = [0, 0.462, 0.762, 0.964, 1.084 + 0.272j]\r\n self.assert_function_values('tanh', inputs, tanh_vals)\r\n self.assert_function_values('tanh', neg_inputs, negate(tanh_vals))\r\n\r\n # sech is even - do not negate\r\n sech_vals = [1, 0.887, 0.648, 0.266, 0.498 - 0.591j]\r\n self.assert_function_values('sech', inputs, sech_vals)\r\n self.assert_function_values('sech', neg_inputs, sech_vals)\r\n\r\n # the following functions do not have 0 in their domain\r\n inputs = inputs[1:]\r\n neg_inputs = neg_inputs[1:]\r\n\r\n # csch is odd\r\n csch_vals = [1.919, 0.851, 0.276, 0.304 - 0.622j]\r\n self.assert_function_values('csch', inputs, csch_vals)\r\n self.assert_function_values('csch', neg_inputs, negate(csch_vals))\r\n\r\n # coth is odd\r\n coth_vals = [2.164, 1.313, 1.037, 0.868 - 0.218j]\r\n self.assert_function_values('coth', inputs, coth_vals)\r\n self.assert_function_values('coth', neg_inputs, negate(coth_vals))","def mobius(decomp): #fix 1 value\n return 0 if any([decomp[p] >= 2 for p in decomp]) else (-1) ** (breadth(decomp) % 2)","def zernike_diff(Nstar=1,seeing=[0.9,0.,0.],npix=npix,zenith=0,filter='g', theta=0., corrector='corrector',x=None,y=None,z=None,zernike_max_order=20,regular=False):\n hdu = genImgVallCCD(Nstar=Nstar,seeing=seeing,npix=npix,zenith=zenith,filter=filter, theta=theta, corrector=corrector,x=x,y=y,z=z,regular=regular)\n nn = len(hdu)\n data = []\n colnames = ['x','y','M20','M22','M31','M33']\n for hdui in hdu[1:]:\n Nobj = hdui.data.shape[0]\n M20=np.zeros(Nobj)\n M22=np.zeros(Nobj).astype(complex)\n M31=np.zeros(Nobj).astype(complex)\n M33=np.zeros(Nobj).astype(complex)\n #sigma = 1.1/0.27\n sigma = 1.08/0.27\n for i in range(Nobj):\n M20[i],M22[i],M31[i],M33[i]=complexMoments(data=hdui.data[i][4:].reshape(npix,npix),sigma=sigma)\n x=hdui.header['ccdXcen']\n y=hdui.header['ccdYcen']\n data.append([x,y,np.median(M20), np.median(M22), np.median(M31), np.median(M33)])\n data=np.array(data)\n betaAll=[]\n betaErrAll=[]\n R2adjAll=[]\n beta,betaErr,R2_adj = zernikeFit(data[:,0].real,data[:,1].real,data[:,2].real,max_order=zernike_max_order)\n betaAll.append(beta)\n betaErrAll.append(betaErr)\n R2adjAll.append(R2_adj)\n for i in range(3,6):\n beta,betaErr,R2_adj = zernikeFit(data[:,0].real,data[:,1].real,data[:,i].real,max_order=zernike_max_order)\n betaAll.append(beta)\n betaErrAll.append(betaErr)\n R2adjAll.append(R2_adj)\n beta,betaErr,R2_adj = zernikeFit(data[:,0].real,data[:,1].real,data[:,i].imag,max_order=zernike_max_order)\n betaAll.append(beta)\n betaErrAll.append(betaErr)\n R2adjAll.append(R2_adj)\n betaAll = np.array(betaAll)\n betaErrAll = np.array(betaErrAll)\n R2adjAll = np.array(R2adjAll)\n return betaAll,betaErrAll, R2adjAll","def half_gcdex(f, g):\n lev, dom, per, F, G = f.unify(g)\n s, h = dmp_half_gcdex(F, G, dom)\n return per(s), per(h)","def test_2_layer():\r\n # angular frequency in radians * THz\r\n w = 100 * nu.THz\r\n # Relative permittivity of metal and dielectric\r\n em = -4.56 + 0.12j\r\n ed = 1.23 + 0.01j\r\n ex_list = ez_list = [ed, em]\r\n # Relative permeabilities\r\n mu_list = [1,1]\r\n # Dictionary of input parameters\r\n input_params = {'w': w, 'd_list': [inf,inf], 'ex_list': ex_list,\r\n 'ez_list': ez_list, 'mu_list': mu_list}\r\n \r\n # Calculate the theoretical kx\r\n theo_kx = (w / nu.c0) * cmath.sqrt((em * ed) / (em + ed))\r\n if theo_kx.imag < 0:\r\n theo_kx *= -1\r\n print('Theoretical kx:',\r\n '(%.7g+%.7gj) rad/um' % (theo_kx.real / nu.um**-1, theo_kx.imag / nu.um**-1))\r\n \r\n # If I use the theoretical kx value, the mode should be correct and\r\n # all my tests should pass.\r\n params = deepcopy(input_params)\r\n params['kx'] = theo_kx\r\n params = find_all_params_from_kx(params)\r\n kzd, kzm = params['kz_list']\r\n # check that kz_list is correct\r\n assert_floats_are_equal(kzd**2, (w**2 / nu.c0**2) * ed**2 / (em + ed))\r\n assert_floats_are_equal(kzm**2, (w**2 / nu.c0**2) * em**2 / (em + ed))\r\n # check that layer_bottom_list is correct\r\n assert params['layer_bottom_list'][0] == -inf\r\n assert params['layer_bottom_list'][1] == 0\r\n # Check that the boundary condition matrix agrees with hand-calculation\r\n bc_mat = bc_matrix(params)\r\n # ...top-left is Ex0down / H0down\r\n assert_floats_are_equal(bc_mat[0,0], -kzd / (w * ed * nu.eps0))\r\n # ...top-right is -Ex1up / H1up\r\n assert_floats_are_equal(bc_mat[0,1], -kzm / (w * em * nu.eps0))\r\n # ...bottom-left is eps0 * Ez0down / H0down\r\n assert_floats_are_equal(bc_mat[1,0], ed * -theo_kx / (w * ed * nu.eps0))\r\n # ...bottom-right is -eps1 * Ez1up / H1up\r\n assert_floats_are_equal(bc_mat[1,1], -em * -theo_kx / (w * em * nu.eps0))\r\n # Check that one of the eigenvalues is almost zero (compared to the size\r\n # of the matrix elements).\r\n eigenvalues = np.linalg.eig(bc_mat)[0]\r\n assert abs(eigenvalues).min() / abs(bc_mat).max() < 1e-6\r\n # Check that the mode passes all tests.\r\n assert check_mode(params, thorough=True) is True\r\n # Check that I can scale the fields and it still passes all tests.\r\n params_scaled = rescale_fields(1.23+4.56j, params)\r\n assert check_mode(params_scaled, thorough=True) is True\r\n \r\n # Now try my kx-finding algorithm, to see if it finds the right value.\r\n kx_list = find_kx(input_params)\r\n print('kx_list:',\r\n ['(%.7g+%.7gj) rad/um' % (kx.real / nu.um**-1, kx.imag / nu.um**-1)\r\n for kx in kx_list])\r\n kx = kx_list[0]\r\n assert_floats_are_equal(theo_kx, kx)\r\n \r\n plot_mode(params)\r\n \r\n print('If you see this message, all the tests succeeded!!')","def hemianopsia_soft(hemi='left',slope=5.0,dprime_fnc=dprime_basic):\n def hemianopsia_fnc(distance):\n if (hemi == 'left'):\n return dprime_fnc(distance) * sigmoid(distance[0],slope)\n elif (hemi == 'right'):\n return dprime_fnc(distance) * sigmoid(-distance[0],slope)\n else:\n assert False, \"Unimplemented branch for the argument bling\"\n return hemianopsia_fnc","def test_hill_formula(self):\n # make sure smiles match reference\n molecule_smiles = create_ethanol()\n assert molecule_smiles.hill_formula == \"C2H6O\"\n # make sure is not order dependent\n molecule_smiles_reverse = create_reversed_ethanol()\n assert molecule_smiles.hill_formula == molecule_smiles_reverse.hill_formula\n # make sure single element names are put first\n order_mol = Molecule.from_smiles(\"C(Br)CB\")\n assert order_mol.hill_formula == \"C2H6BBr\"\n # test molecule with no carbon\n no_carb_mol = Molecule.from_smiles(\"OS(=O)(=O)O\")\n assert no_carb_mol.hill_formula == \"H2O4S\"\n # test no carbon and hydrogen\n br_i = Molecule.from_smiles(\"BrI\")\n assert br_i.hill_formula == \"BrI\"\n # make sure files and smiles match\n molecule_file = Molecule.from_file(get_data_file_path(\"molecules/ethanol.sdf\"))\n assert molecule_smiles.hill_formula == molecule_file.hill_formula\n # make sure the topology molecule gives the same formula\n from openforcefield.topology.topology import Topology, TopologyMolecule\n\n topology = Topology.from_molecules(molecule_smiles)\n topmol = TopologyMolecule(molecule_smiles, topology)\n assert molecule_smiles.hill_formula == Molecule.to_hill_formula(topmol)\n # make sure the networkx matches\n assert molecule_smiles.hill_formula == Molecule.to_hill_formula(\n molecule_smiles.to_networkx()\n )"],"string":"[\n \"def genfb_py(h, n, u, v, f, dt, dx, dy, du,dv,dn, gridu,gridv,gridn, threadblock, beta=0.281105, eps=0.013, gamma=0.0880, mu=0.3, nu=0, dudt_x=dudt, dvdt_x=dvdt, dndt_x=dndt, grav=True, cori=True, advx=True, advy=True, attn=True, ): # generalized forward backward feedback timestep\\n \\n p5 = np.float32(0.5)\\n one = np.float32(1)\\n p32 = np.float32(1.5)\\n beta = np.float32(beta)\\n eps = np.float32(eps)\\n gamma= np.float32(gamma)\\n mu = np.float32(mu)\\n \\n dn_m1,dn_m2,dn_m0 = dn # dn[0], dn[1], dn[2] # unpack\\n if dn_m1 is dn_m2 or dn_m1 is dn_m0:\\n print (\\\"error dn_m1\\\")\\n if dn_m2 is dn_m0: \\n print (\\\"error dn_m0\\\")\\n print( dn_m1[280,5],dn_m2[280,5],dn_m0[280,5]) \\n# hn = n.copy_to_host()\\n# print ('n', hn.shape,n.shape, np.argmax(hn),np.max(hn),np.argmin(hn),np.min(hn))\\n# hn = u.copy_to_host()\\n# print ('u', hn.shape,n.shape, np.argmax(hn),np.max(hn),np.argmin(hn),np.min(hn))\\n# hn = v.copy_to_host()\\n# print ('v', hn.shape,n.shape, np.argmax(hn),np.max(hn),np.argmin(hn),np.min(hn))\\n dndt_x[gridn, threadblock](h, n, u, v, dx, dy, dn_m0)\\n \\n # must do the following before the u and v !\\n #n1 = n + ((p32+beta)* dn_m0 - (p5+beta+beta)* dn_m1+ (beta)* dn_m2)*dt\\n# n_m0 = dn_m0.copy_to_host()\\n# print ('dn_m0',dn_m0.shape,np.argmax(n_m0),np.max(n_m0),np.argmin(n_m0),np.min(n_m0))\\n# lincomb4_cuda[gridn,threadblock](n, dn_m0, dn_m1, dn_m2, one, (p32+beta)*dt, -(p5+beta+beta)*dt, (beta)*dt, n)\\n \\n h_n = n.copy_to_host()\\n hn_m0 = dn_m0.copy_to_host()\\n hn_m1 = dn_m1.copy_to_host()\\n hn_m2 = dn_m2.copy_to_host()\\n h_n = h_n+(p32+beta)*dt*hn_m0 -(p5+beta+beta)*dt*hn_m0+(beta)*dt*hn_m0\\n n[:]=h_n\\n \\n \\n \\n du_m0,du_m1,du_m2,du_p1 = du # du[0], du[1], du[2], du[3] # unpack\\n# if du_p1 is du_m0 or du_p1 is du_m1 or du_p1 is du_m2:\\n# print (\\\"error du_p1\\\")\\n# if du_m0 is du_m2 or du_m0 is du_m1 :\\n# print (\\\"error du_m0\\\")\\n# if du_m2 is du_m1:\\n# print (\\\"error du_m1\\\")\\n print( du_m0[280,5],du_m1[280,5],du_m2[280,5],du_p1[280,5]) \\n dudt_x[gridu, threadblock](h, n, f, u, v, dx, dy, du_p1, grav, cori, advx, advy, attn,nu,mu)\\n\\n dv_m0,dv_m1,dv_m2,dv_p1 = dv #dv[0], dv[1], dv[2], dv[3] # unpack \\n print( dv_m0[280,5],dv_m1[280,5],dv_m2[280,5],dv_p1[280,5]) \\n dvdt_x[gridv, threadblock](h, n, f, u, v, dx, dy, dv_p1, grav, cori, advx, advy, attn,nu,mu)\\n \\n #u1 = u+ ((p5+gamma+eps+eps)*du_p1 +(p5-gamma-gamma-eps-eps-eps)*du_m0 +gamma*du_m1+eps*du_m2)*dt\\n # lincomb5_cuda[gridu,threadblock](u, du_p1, du_m0, du_m1, du_m2, one, (p5+gamma+eps+eps)*dt, (p5-gamma-gamma-eps-eps-eps)*dt, gamma*dt, eps*dt, u)\\n lincomb5_cuda[gridu,threadblock](u, du_p1, du_m0, du_m1, du_m2, one, one*dt, np.float32(0.0), np.float32(0.0), np.float32(0.0), u)\\n\\n #v1 = v+ ((p5+gamma+eps+eps)*dv_p1 +(p5-gamma-gamma-eps-eps-eps)*dv_m0 +gamma*dv_m1+eps*dv_m2)*dt\\n # lincomb5_cuda[gridv,threadblock](v, dv_p1, dv_m0, dv_m1, dv_m2, one, (p5+gamma+eps+eps)*dt, (p5-gamma-gamma-eps-eps-eps)*dt, gamma*dt, eps*dt, v)\\n lincomb5_cuda[gridv,threadblock](v, dv_p1, dv_m0, dv_m1, dv_m2, one, one*dt, np.float32(0.0), np.float32(0.0), np.float32(0.0), v)\\n \\n\\n dv = [ dv_p1,dv_m0,dv_m1,dv_m2 ]\\n du = [ du_p1,du_m0,du_m1,du_m2 ]\\n dn = [ dn_m0,dn_m1,dn_m2 ]\\n return du, dv, dn\",\n \"def fredkin(ha, hb, hc):\\n\\n return controlled_U(ha, swap(hb, hc))\",\n \"def genfb(h, n, u, v, f, dt, dx, dy, du,dv,dn, beta=0.281105, eps=0.013, gamma=0.0880, mu=0.3, nu=0, dudt_x=dudt, dvdt_x=dvdt, dndt_x=dndt, grav=True, cori=True, advx=True, advy=True, attn=True): # generalized forward backward feedback timestep\\n \\n beta = np.float32(beta)\\n eps = np.float32(eps)\\n gamma = np.float32(gamma)\\n mu = np.float32(mu)\\n \\n \\n dn_m1,dn_m2,dn_m0 = dn # unpack\\n dndt_x(h, n, u, v, dx, dy, dn_m0)\\n \\n# test_out = dn_m0.copy()\\n# dndt(h, n, u, v, dx, dy, test_out)\\n \\n# test_dif = dn_m0-test_out\\n# if np.max(np.abs(test_dif[1:-1,1:-1] )) >1E-5 :\\n# test_dif[1:-1,5][np.abs(test_dif[1:-1,5] ) <1E-5]=0.0\\n# print (\\\"dn diff 2\\\")\\n# print (test_dif[:,5])\\n \\n #dn_m0[:]=test_out \\n\\n # must do the following before the u and v !\\n n1 = n + ((p32+beta)* dn_m0 - (p5+beta+beta)* dn_m1+ (beta)* dn_m2)*dt\\n #del dn_m2\\n du_m0,du_m1,du_m2,du_p1 = du # unpack\\n dudt_x(h, n1, f, u, v, dx, dy, du_p1, grav=grav, cori=cori, advx=advx, advy=advy, attn=attn,nu=nu,mu=mu)\\n\\n dv_m0,dv_m1,dv_m2,dv_p1 = dv # unpack \\n dvdt_x(h, n1, f, u, v, dx, dy, dv_p1, grav=grav, cori=cori, advx=advx, advy=advy, attn=attn,nu=nu,mu=mu)\\n \\n# test_out = du_p1.copy()\\n# dudt(h, n1, f, u, v, dx, dy, test_out)\\n \\n# test_dif = du_p1-test_out\\n# if np.max(np.abs(test_dif[1:-1,5] )) >1E-5 :\\n# test_dif[1:-1,5][np.abs(test_dif[1:-1,5] ) <1E-5]=0.0\\n# print (\\\"du diff\\\")\\n# print (test_dif[:,5])\\n \\n# #du_p1[:] = test_out\\n\\n# test_out = dv_p1.copy()\\n# dvdt(h, n1, f, u, v, dx, dy, test_out)\\n \\n# test_dif = dv_p1-test_out\\n# if np.max(np.abs(test_dif[1:-1,5] )) >1E-5 :\\n# test_dif[1:-1,5][np.max(test_dif[1:-1,5] ) <1E-5]=0.0\\n# print (\\\"dv diff\\\")\\n# print (test_dif[:,5])\\n \\n #dv_p1[:] = test_out\\n \\n u1 = u+ ((p5+gamma+eps+eps)*du_p1 +(p5-gamma-gamma-eps-eps-eps)*du_m0 +gamma*du_m1+eps*du_m2)*dt\\n # del du_m2\\n v1 = v+ ((p5+gamma+eps+eps)*dv_p1 +(p5-gamma-gamma-eps-eps-eps)*dv_m0 +gamma*dv_m1+eps*dv_m2)*dt\\n # del dv_m2\\n\\n\\n \\n \\n dv = [ dv_p1,dv_m0,dv_m1,dv_m2 ]\\n du = [ du_p1,du_m0,du_m1,du_m2 ]\\n dn = [ dn_m0,dn_m1,dn_m2 ]\\n# n[:,:], u[:,:], v[:,:], = n1, u1, v1\\n return n1, u1, v1, du,dv,dn\",\n \"def test_G_H(self):\\r\\n chkmtx = (numpy.dot(golay.DEFAULT_G, golay.DEFAULT_H.T) % 2)\\r\\n self.assertTrue((chkmtx == 0).all())\",\n \"def __init__(self, N: int, P: int, H: int, csdfg_fwd: CompiledSDFG,\\n csdfg_bwd: CompiledSDFG):\\n super().__init__()\\n\\n class DaceMHAFunction(torch.autograd.Function):\\n @staticmethod\\n def forward(ctx, Q, K, V, WQ, WK, WV, WO, BQ, BK, BV, BO, scaler):\\n B, SN, N = Q.shape\\n _, SM, _ = K.shape\\n output = torch.empty([B, SN, N], device=Q.device)\\n csdfg_fwd(k=K.contiguous(),\\n q=Q.contiguous(),\\n v=V.contiguous(),\\n __return=output,\\n wk=WK.contiguous(),\\n wq=WQ.contiguous(),\\n wv=WV.contiguous(),\\n wo=WO.contiguous(),\\n bk=BK.contiguous(),\\n bq=BQ.contiguous(),\\n bv=BV.contiguous(),\\n bo=BO.contiguous(),\\n scaler=scaler.item(),\\n B=B,\\n P=P,\\n H=H,\\n N=H * P,\\n SN=SN,\\n SM=SM)\\n ctx.save_for_backward(Q, K, V, output)\\n return output\\n\\n @staticmethod\\n def backward(ctx, grads):\\n # ctx.saved_tensors\\n output = torch.empty_like(K, device='cuda')\\n gK, gQ, gV, gWK, gWQ, gWV = [\\n torch.empty(grads.shape, grads.dtype) for _ in range(6)\\n ]\\n csdfg_bwd(output=output,\\n gK=gK,\\n gQ=gQ,\\n gV=gV,\\n gWK=gWK,\\n gWQ=gWQ,\\n gWV=gWV)\\n return gK, gQ, gV, gWK, gWQ, gWV\\n\\n self.P = P\\n self.H = H\\n self.N = N\\n\\n self.op = DaceMHAFunction\\n self.WK = torch.nn.Parameter(torch.Tensor(P, H, P * H))\\n self.WQ = torch.nn.Parameter(torch.Tensor(P, H, P * H))\\n self.WV = torch.nn.Parameter(torch.Tensor(P, H, P * H))\\n self.WO = torch.nn.Parameter(torch.Tensor(P, H, P * H))\\n self.BK = torch.nn.Parameter(torch.Tensor(P, H))\\n self.BQ = torch.nn.Parameter(torch.Tensor(P, H))\\n self.BV = torch.nn.Parameter(torch.Tensor(P, H))\\n self.BO = torch.nn.Parameter(torch.Tensor(N))\\n self.scaler = torch.tensor([P**-0.5], dtype=torch_dtype)\\n\\n # Initialize parameters\\n xavier_uniform_(self.WK)\\n xavier_uniform_(self.WQ)\\n xavier_uniform_(self.WV)\\n xavier_uniform_(self.WO)\\n\\n uniform_(self.BK)\\n uniform_(self.BQ)\\n uniform_(self.BV)\\n uniform_(self.BO)\",\n \"def main():\\n regexham = r'\\\\s+\\\\((\\\\d+,\\\\s*\\\\d+)\\\\)\\\\s+([\\\\-+]?\\\\d+\\\\.\\\\d+[eEdD]?[\\\\-+]?\\\\d+)' #to extract the Hamiltonian.\\n root = '.'\\n #fname = 'output_files/'\\n ciffci = CIFlow_Reader('testfci.dat', regexp = regexham , read_ham= True)\\n ciffcipar = CIFlow_Reader( 'psi0_output10outputfci.dat', regexp = regexham , read_ham = True)\\n #print ciffci.calc_overlap(cifdoci)\\n #print e.get_groundstate('00000000000011|00000000000011') \\n\\n psir = rp.PsiReader('psi0_output10.dat', isbig = False, numorbs = -1 , read_ints = False)\\n\\n detlist = dw.cimain(psir.values['nalpha'],psir.values['nbeta'], psir.values['norb'], [range(1,psir.values['nalpha']+psir.values['nbeta']), []], [] , fname = 'determinants.dat' ,ref = [lambda x , y , z : psir.get_hf_orbs()] , add_frozen = 0, write = False) #CISDDOCI\\n count = 0\\n for det in detlist:\\n for det2 in detlist:\\n #+ because the eigenvectors have already a different phasefactor of 1.\\n if abs(ciffci.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) - ciffcipar.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) ) > 1e-10 :\\n print 'difference in hamiltonian row: ' , det[0]+'|'+det[1] , \\\" col: \\\" , det2[0]+'|'+det2[1] , 'fci: ', ciffci.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) , 'fciaddres: ' , ciffcipar.get_mat_element(det[0]+'|'+det[1],det2[0]+'|'+det2[1]) \\n count += 1\\n print 'There were ' , count , ' different elements'\",\n \"def hemianopsia_hard(hemi='left',dprime_fnc=dprime_basic):\\n def hemianopsia_fnc(distance):\\n if (hemi == 'left' and distance[0] < 0) or (hemi == 'right' and distance[0] > 0):\\n return SMALL_FLOAT\\n else:\\n return dprime_fnc(distance)\\n return hemianopsia_fnc\",\n \"def exp_mod(a, b, nbr):\\n bina = [int(x) for x in bin(a)[2:]]\\n #binb = [int(x) for x in bin(b)[2:]]\\n binn = [int(x) for x in bin(nbr)[2:]]\\n #while len(binn)<len(bina):\\n # binn = [0]+binn\\n #print(bina, binn)\\n binn.reverse()\\n bina.reverse()\\n n = len(bina)+len(binn)*4+1\\n na = len(bina)\\n nan = len(bina)+len(binn) # debut de Y\\n nany = len(bina)+2*len(binn)+1 # debut de \\\"A\\\" (ici c'est b)\\n nanya = len(bina)+3*len(binn)+1 # debut de \\\"APOW\\\" (ce qui doit etre mesuré)\\n q = QuantumRegister(n+2, 'q') # +lost+lost2\\n circ = QuantumCircuit(q)\\n for i in range(na):\\n if bina[i]:\\n circ.x(q[i])\\n for i in range(len(binn)):\\n if binn[i]:\\n circ.x(q[na+i])\\n expmod(circ, q, # X, a, A, APOW, Y, n, N, binn, lost, lost2)\\n [q[i] for i in range(len(bina))],\\n b%nbr,\\n [q[i+nany] for i in range(len(binn))],\\n [q[i+nanya] for i in range(len(binn))],\\n [q[i+nan] for i in range(len(binn)+1)],\\n nbr,\\n [q[i+na] for i in range(len(binn))],\\n binn,\\n q[n],\\n q[n+1])\\n if len(bina)%2:\\n circ_m = measure(circ, q, [i for i in range(nan,nany)])\\n else:\\n circ_m = measure(circ, q, [i for i in range(nanya,n)])\\n #circ_m = measure(circ, q, [i for i in range(n)])\\n return circ_m\",\n \"def chk_hamming(data):\\n pass\",\n \"def zzx_heu_gcd(f, g, **flags):\\n def interpolate(h, x):\\n f = []\\n\\n while h:\\n g = h % x\\n\\n if g > x // 2:\\n g -= x\\n\\n f.insert(0, g)\\n h = (h-g) // x\\n\\n return f\\n\\n def finalize(h, cff, cfg, gcd):\\n h = zzx_mul_const(h, gcd)\\n return h, cff, cfg\\n\\n if not (f or g):\\n return [], [], []\\n elif not f:\\n return g, [], [1]\\n elif not g:\\n return f, [1], []\\n\\n df = zzx_degree(f)\\n dg = zzx_degree(g)\\n\\n cf = zzx_content(f)\\n cg = zzx_content(g)\\n\\n gcd = igcd(cf, cg)\\n\\n f = [ c // gcd for c in f ]\\n g = [ c // gcd for c in g ]\\n\\n if df == 0 or dg == 0:\\n return [gcd], f, g\\n\\n f_norm = zzx_max_norm(f)\\n g_norm = zzx_max_norm(g)\\n\\n B = 2*min(f_norm, g_norm) + 29\\n\\n x = max(min(B, 99*INT_TYPE(isqrt(B))),\\n 2*min(f_norm // abs(poly_LC(f)),\\n g_norm // abs(poly_LC(g))) + 2)\\n\\n for i in xrange(0, 6):\\n ff = zzx_eval(f, x)\\n gg = zzx_eval(g, x)\\n\\n if ff and gg:\\n h = igcd(ff, gg)\\n\\n cff = ff // h\\n cfg = gg // h\\n\\n h = interpolate(h, x)\\n h = zzx_primitive(h)[1]\\n\\n cff_, r = zzx_div(f, h)\\n\\n if not r:\\n cfg_, r = zzx_div(g, h)\\n\\n if not r:\\n return finalize(h, cff_, cfg_, gcd)\\n\\n cff = interpolate(cff, x)\\n\\n h, r = zzx_div(f, cff)\\n\\n if not r:\\n cfg_, r = zzx_div(g, h)\\n\\n if not r:\\n return finalize(h, cff, cfg_, gcd)\\n\\n cfg = interpolate(cfg, x)\\n\\n h, r = zzx_div(g, cfg)\\n\\n if not r:\\n cff_, r = zzx_div(f, h)\\n\\n if not r:\\n return finalize(h, cff_, cfg, gcd)\\n\\n x = INT_TYPE(2.7319*x*isqrt(isqrt(x)))\\n\\n raise HeuristicGCDFailed('no luck')\",\n \"def distcalc(z,h=0.70,omegalambda=0.7,omegam=0.3,omegak=0.0):\\n\\n H0 = 100 * h # this is in units of km/s/Mpc\\n\\n H0freq = H0 * constants.kilo/(constants.mega * constants.parsec) # this is H0 is units of Hz\\n \\n hubbletime = 1.0/H0freq # in seconds\\n hubbletimeyr = hubbletime / constants.year\\n\\n #hubble distance\\n dh = constants.c / H0freq # in meters\\n\\n #now i can calculate the comoving distance (line of sight) using hogg eqn 15\\n dc = dh * integrate.quad(dcintegrand,0,z,(omegalambda,omegam,omegak))[0]\\n\\n #now i can find the transverse comoving distance using hogg eqn 16\\n if omegak == 0:\\n dm = dc\\n elif omegak > 0:\\n dm = dh/np.sqrt(omegak) * np.sinh(dc * np.sqrt(omegak) / dh)\\n else:\\n dm = dh/np.sqrt(abs(omegak)) * np.sin(dc * np.sqrt(abs(omegak)) / dh)\\n\\n\\n #now i will calculate the angular diameter distance (hogg eqn 18)\\n da = dm/(1+z)\\n \\n #now i will calculate scale in kpc/arcsec, since this is commonly used\\n scale = da * constants.arcsec / (constants.kilo * constants.parsec)\\n\\n #now i will calculate the luminosity distance (hog eqn 21)\\n dl = (1+z)*dm\\n \\n #now i will calculate lookback time and \\n #time from the begining of the universe to that redshift using hogg eqn 30\\n \\n tlookback = hubbletimeyr * integrate.quad(timeintegrand,0,z,(omegalambda,omegam,omegak))[0]\\n \\n tz = hubbletimeyr * integrate.quad(timeintegrand,z,np.inf,(omegalambda,omegam,omegak))[0]\\n \\n #all sky co-moving volume out to redshift z (hogg eqn 30)\\n if omegak == 0:\\n vc = 4 * np.pi * dm**3 / 3\\n elif omegak > 0:\\n vc = ( 4 * np.pi * dh**3 / (2 * omegak) ) * ( dm * np.sqrt(1 + omegak * dm**2 / dh**2) / dh - \\n np.arcsinh( np.sqrt(omegak) * dm / dh ) / np.sqrt(omegak) )\\n else:\\n vc = ( 4 * np.pi * dh**3 / (2 * omegak) ) * ( dm * np.sqrt(1 + omegak * dm**2 / dh**2) / dh - \\n np.arcsin( np.sqrt(abs(omegak)) * dm / dh ) / np.sqrt(abs(omegak)) )\\n\\n #for output, i will make a dictionary\\n output = dict(dh=dh, dc=dc, dm=dm, da=da, scale=scale, dl=dl, tlookback = tlookback, tz=tz, vc=vc)\\n\\n return output\",\n \"def global_fn(self, h, e, g_state):\\n N, K, _ = h.shape\\n\\n # Concatenate all relevant inputs.\\n h = h.sum(dim=1)\\n\\n mask = torch.ones(1, K, K, 1)\\n if torch.cuda.is_available():\\n mask = mask.cuda()\\n for kx1 in range(K):\\n for kx2 in range(K):\\n if kx1 != kx2-1:\\n mask[:, kx1, kx2, :] = 0.\\n #if kx1 == kx2:\\n # mask[:, kx1, kx2, :] = 0.\\n e = torch.sum(e*mask, dim=[1,2])\\n\\n x = torch.cat([h, e], dim=1).view(-1, 1, 2*self.n_hidden)\\n output, g_n = self.G_gru(input=x,\\n hx=g_state)\\n output = output.view(N, self.n_hidden)\\n return output, g_n\",\n \"def Gamma01ph(ne,ng):\\r\\n\\r\\n return d(ne,ng)**2*domega(ne,ng)**3/(3*np.pi*epsilon_0*hbar*c**3)\",\n \"def pollard_rho(g: int, h: int, n: int, order: int = None):\\n x = {0: 1}\\n a = {0: 0}\\n b = {0: 0}\\n\\n import ressources.multGroup as multGroup\\n\\n if order is None:\\n order = multGroup.multiplicativeOrder(g, n)\\n\\n # from a, b and c, partitioning the field\\n def step_xab(x, a, b, g, h, order, n):\\n s = x % 3\\n\\n # S1\\n if s == 1:\\n x = x * h % n\\n b = (b + 1) % order\\n\\n # S2\\n if s == 0:\\n x = square_and_multiply(x, 2, n)\\n a = 2 * a % order\\n b = 2 * b % order\\n\\n # S3\\n if s == 2:\\n x = x * g % n\\n a = (a + 1) % order\\n\\n return x, a, b\\n\\n # returns x, a, b for a given i using memoization\\n def get_xab(i):\\n\\n if i not in x:\\n _x, _a, _b = get_xab(i - 1)\\n\\n x[i], a[i], b[i] = step_xab(_x, _a, _b, g, h, order, n)\\n\\n return x[i], a[i], b[i]\\n\\n def naturals_from(i):\\n while True:\\n # yield is a keyword that is used like return, except the function will return a generator.\\n # https://www.google.com/search?client=firefox-b-d&q=yield+python\\n yield i\\n i += 1\\n\\n for i in naturals_from(1):\\n\\n x_i, a_i, b_i = get_xab(i)\\n x_2i, a_2i, b_2i = get_xab(2 * i)\\n\\n if x_i == x_2i:\\n\\n r = (b_i - b_2i) % order\\n\\n if r == 0:\\n return False\\n\\n return multGroup.inv(r, order) * (a_2i - a_i) % order\",\n \"def compute_gcd(first, second, n, gcd_factor): \\n a = QuantumRegister(n, \\\"aq\\\")\\n b = QuantumRegister(n, \\\"bq\\\")\\n anc = QuantumRegister(2, \\\"ancq\\\")\\n res = QuantumRegister(n, \\\"resq\\\")\\n zero = QuantumRegister(2, \\\"zq\\\")\\n anc_cl = ClassicalRegister(2, \\\"anccl\\\")\\n zero_cl = ClassicalRegister(2, \\\"zcl\\\")\\n a_cl = ClassicalRegister(n, \\\"acl\\\")\\n b_cl = ClassicalRegister(n, \\\"bcl\\\") \\n res_cl = ClassicalRegister(n, \\\"cl\\\")\\n qc = QuantumCircuit(a, b, anc, res, zero, anc_cl, zero_cl, \\n res_cl, a_cl, b_cl, name=\\\"qc\\\")\\n\\n for i in range(0, n):\\n if first[i] == \\\"1\\\":\\n qc.x(a[n-(i+1)])\\n \\n for i in range(0, n):\\n if second[i] == \\\"1\\\":\\n qc.x(b[n-(i+1)])\\n\\n for i in range(0, n):\\n if gcd_factor[i] == \\\"1\\\":\\n qc.x(res[n-(i+1)]) \\n\\n qc.measure(a,res_cl)\\n qc.x(zero[0]).c_if(res_cl, 0)\\n qc.measure(b, res_cl)\\n qc.x(zero[1]).c_if(res_cl, 0)\\n qc.measure(zero, zero_cl)\\n #Resetting the zero qreg to 0, with zero_cl holding the zero status \\n qc.x(zero[0]).c_if(res_cl, 0) \\n qc.measure(a,res_cl) \\n qc.x(zero[1]).c_if(res_cl, 0) \\n #Resetting res_cl to zero again.\\n for i in range(n):\\n qc.measure(zero[0], res_cl[i]) \\n\\n #Checking for equality\\n args = [a[x] for x in range(n)] + [b[x] for x in range(n)]\\n csub = CompositeGate(\\\"csub\\\", [math.pi], args, circuit =\\\"qc\\\")\\n csub = subtract.subtract(qc, n, math.pi, a, b, csub, -1)\\n qc.measure(a, res_cl)\\n qc.x(zero[0]).c_if(res_cl, 0)\\n cadd = CompositeGate(\\\"csub\\\", [math.pi], args, circuit =\\\"qc\\\")\\n cadd = subtract.subtract(qc, n, math.pi, a, b, cadd, 1)\\n\\n #Checking if either b, a or both are zero - if they are, then swap\\n #the 1 in res_q out for a zero\\n qc.swap(res[0], zero[0]).c_if(zero_cl, 1)\\n qc.swap(res[0], zero[0]).c_if(zero_cl, 2)\\n qc.swap(res[0], zero[0]).c_if(zero_cl, 3)\\n #flip the 1 in zero_q to make zero_q on the zero state again.\\n qc.x(zero[0]).c_if(zero_cl, 1)\\n qc.x(zero[0]).c_if(zero_cl, 2)\\n qc.x(zero[0]).c_if(zero_cl, 3) \\n\\n zero_status, gcd_factor, b_value, equality_status, a_value = \\\\\\n gcd_main.gcd(qc, a, b, res, anc, zero, zero_cl, anc_cl, res_cl,\\n n, a_cl, b_cl)\\n\\n return zero_status, gcd_factor, b_value, equality_status, a_value\",\n \"def exotic(double[:] v, redshifts, in_terms, double H0):\\n\\n cdef double t = v[0]\\n cdef double a = v[1]\\n cdef double ombar_m = v[2]\\n cdef double ombar_r = v[3]\\n cdef double ombar_de = v[4]\\n cdef double z = v[5]\\n cdef double dl = v[6]\\n cdef double gamma = in_terms[0]\\n cdef double zeta = in_terms[1]\\n\\n cdef double Hz = H0 * (ombar_m +ombar_r +ombar_de)**(0.5)\\n\\n# if ombar_m < 0 or ombar_de < 0:\\n# print('exotic')\\n# print('z = %s, Hz = %s, gamma = %s, zeta = %s'% (z, Hz, gamma, zeta))\\n# print('ombar_m = %s, ombar_r = %s, ombar_de = %s'\\n# % (ombar_m, ombar_r, ombar_de))\\n\\n if math.isnan(Hz):\\n print('exotic')\\n print('z = %s, Hz = %s, gamma = %s, zeta = %s'% (z, Hz, gamma, zeta))\\n print('ombar_m = %s, ombar_r = %s, ombar_de = %s'\\n % (ombar_m, ombar_r, ombar_de))\\n\\n cdef double dtdz = -1.0/((1.0+z) * Hz)\\n cdef double dadz = -(1.0+z)**(-2.0)\\n cdef double domdz = (3.0*ombar_m +gamma*ombar_m*ombar_r /Hz) /(1.0+z)\\n cdef double dordz = (4.0*ombar_r -(gamma*ombar_m*ombar_r -zeta*ombar_r*ombar_de) /Hz ) /(1.0+z)\\n cdef double dodedz = -zeta*ombar_r*ombar_de/(1.0+z) /Hz\\n cdef double ddldz = 1.0/Hz\\n\\n # first derivatives of functions I want to find:\\n f = [dtdz,# dt/dz (= f.d wrt z of time)\\n dadz,# d(a)/dz (= f.d wrt z of scale factor)\\n domdz,# dw = 0, (ombar_m)/dz (= f.d wrt z of density_m(t) / crit density(t0))\\n dordz,# w = 1/3, d(ombar_r)/dz (= f.d wrt z of density_r(t) / crit density(t0))\\n dodedz,# w = -1, d(ombar_de)/dz (= f.d wrt z of density_de(t) / crit density(t0))\\n 1.0,# d(z)/dz (= f.d wrt z of redshift)\\n ddldz]# d(dl)/dz (= f.d wrt z of luminosty distance) # H + Hdz*(1+z)\\n\\n return f\",\n \"def test_init_hebbian_2(self):\\n v_one = [1, -1, -1, -1, 1, -1, -1, -1, 1]\\n v_two = [-1, -1, -1, 1, 1, 1, -1, -1, -1]\\n network = HopfieldNetwork([v_one, v_two])\\n expected = np.array([\\n [0, 0, 0, -2, 0, -2, 0, 0, 2],\\n [0, 0, 2, 0, -2, 0, 2, 2, 0],\\n [0, 2, 0, 0, -2, 0, 2, 2, 0],\\n [-2, 0, 0, 0, 0, 2, 0, 0, -2],\\n [0, -2, -2, 0, 0, 0, -2, -2, 0],\\n [-2, 0, 0, 2, 0, 0, 0, 0, -2],\\n [0, 2, 2, 0, -2, 0, 0, 2, 0],\\n [0, 2, 2, 0, -2, 0, 2, 0, 0],\\n [2, 0, 0, -2, 0, -2, 0, 0, 0]\\n ], np.int64)\\n npt.assert_equal(network.weight_matrix, expected)\",\n \"def hEqn(g, e, h, f, Gescape, Gform, EHdecay, FHloss, stepsize):\\n hchange = (g * Gescape\\n - h * e * EHdecay\\n - h * f * FHloss\\n - e * h * Gform)\\n return hchange * stepsize\",\n \"def zzX_heu_gcd(f, g, **flags):\\n if poly_univariate_p(f):\\n return zzx_heu_gcd(f, g, **flags)\\n\\n def interpolate(h, x):\\n f = []\\n\\n while not zzX_zero_p(h):\\n g = zzX_zz_trunc(h, x)\\n f.insert(0, g)\\n h = zzX_sub(h, g)\\n h = zzX_quo_const(h, x)\\n\\n return f\\n\\n def finalize(h, cff, cfg, gcd):\\n if zzX_zz_LC(h) > 0:\\n h = zzX_mul_const(h, gcd)\\n else:\\n h = zzX_mul_const(h, -gcd)\\n cff = zzX_neg(cff)\\n cfg = zzX_neg(cfg)\\n\\n return h, cff, cfg\\n\\n zero_f = zzX_zero_p(f)\\n zero_g = zzX_zero_p(g)\\n\\n l = poly_level(f)\\n z = zzX_zero(l)\\n\\n if zero_f and zero_g:\\n return z, z, z\\n elif zero_f:\\n return g, z, zzX_const(l, 1)\\n elif zero_g:\\n return f, zzX_const(l, 1), z\\n\\n df = zzX_degree(f)\\n dg = zzX_degree(g)\\n\\n cf = zzX_zz_content(f)\\n cg = zzX_zz_content(g)\\n\\n gcd = igcd(cf, cg)\\n\\n f = zzX_quo_const(f, gcd)\\n g = zzX_quo_const(g, gcd)\\n\\n f_norm = zzX_max_norm(f)\\n g_norm = zzX_max_norm(g)\\n\\n B = 2*min(f_norm, g_norm) + 29\\n\\n x = max(min(B, 99*INT_TYPE(isqrt(B))),\\n 2*min(f_norm // abs(zzX_zz_LC(f)),\\n g_norm // abs(zzX_zz_LC(g))) + 2)\\n\\n for i in xrange(0, 6):\\n ff = zzX_eval(f, x)\\n gg = zzX_eval(g, x)\\n\\n if not (zzX_zero_p(ff) or zzX_zero_p(gg)):\\n h, cff, cfg = zzX_heu_gcd(ff, gg, **flags)\\n\\n h = interpolate(h, x)\\n h = zzX_zz_primitive(h)[1]\\n\\n cff_, r = zzX_div(f, h)\\n\\n if zzX_zero_p(r):\\n cfg_, r = zzX_div(g, h)\\n\\n if zzX_zero_p(r):\\n return finalize(h, cff_, cfg_, gcd)\\n\\n cff = interpolate(cff, x)\\n\\n h, r = zzX_div(f, cff)\\n\\n if zzX_zero_p(r):\\n cfg_, r = zzX_div(g, h)\\n\\n if zzX_zero_p(r):\\n return finalize(h, cff, cfg_, gcd)\\n\\n cfg = interpolate(cfg, x)\\n\\n h, r = zzX_div(g, cfg)\\n\\n if zzX_zero_p(r):\\n cff_, r = zzX_div(f, h)\\n\\n if zzX_zero_p(r):\\n return finalize(h, cff_, cfg, gcd)\\n\\n x = INT_TYPE(2.7319*x*isqrt(isqrt(x)))\\n\\n raise HeuristicGCDFailed('no luck')\",\n \"def zzx_cofactors(f, g, **flags):\\n return zzx_heu_gcd(f, g, **flags)\",\n \"def __pow__(G, H):\\n return NotImplemented\",\n \"def apply_fhd(self, gfhd):\\n for bl in self.data.keys():\\n i,j = bl\\n p1,p2 = self.pol\\n G = gfhd[p1][i]*gfhd[p2][j].conj()\\n ind = np.where(G != 0)[0]\\n self.data[bl][self.pol][:,ind] /= G[ind]\",\n \"def ldos_defect(h,v,e=0.0,delta=0.001,n=1):\\n raise # still not finished\\n import green\\n # number of repetitions\\n rep = 2*n +1\\n # calculate pristine green function\\n g,selfe = green.supercell_selfenergy(h,e=e,delta=delta,nk=100,nsuper=rep)\\n # now calculate defected green function \\n ez = e + 1j*delta # complex energy\\n emat = np.matrix(np.identity(len(g)))*ez # E +i\\\\delta \\n import supercell\\n pintra = supercell.intra_super2d(h,n=rep) # pristine\\n vintra = supercell.intra_super2d(h,n=rep,central=v) # defective\\n selfe = emat - pintra - g.I # dyson euqation, get selfenergy\\n gv = (emat - vintra -selfe).I # Green function of a vacancy, with selfener\\n return\",\n \"def pohlig_hellman(g: int, h: int, n: int):\\n\\n def group_of_prime_power_order(g, h, n=tuple):\\n # n = (p, e) prime factor exponent times he appears\\n p, e = n\\n n = square_and_multiply(p, e)\\n\\n x = 0\\n # By Lagrange's theorem, this element has order p.\\n y = square_and_multiply(g, square_and_multiply(p, e - 1, n), n)\\n\\n for k in range(e):\\n hk = square_and_multiply(\\n square_and_multiply(g, -x, n) * h,\\n square_and_multiply(p, e - 1 - k, n),\\n n,\\n )\\n dk = pollard_rho(y, hk, n)\\n x += dk * square_and_multiply(p, k, n)\\n\\n return x\\n\\n pFactors = findPrimeFactors(n, True)\\n integers, modulis = [], []\\n\\n for p, e in pFactors.items():\\n ni = square_and_multiply(p, e)\\n gi = square_and_multiply(g, (n // ni), n)\\n hi = square_and_multiply(h, (n // ni), n)\\n\\n xi = group_of_prime_power_order(gi, hi, (p, e))\\n\\n integers.append(xi)\\n modulis.append(ni)\\n\\n return ChineseRemainder(integers, modulis)\",\n \"def k_HF(T, n, h=1e-3):\\n mu_p, _ = physics_solver_mu(n * (1 + h), T)\\n mu_m, _ = physics_solver_mu(n * (1 - h), T)\\n dn_dmu = 2 * h / (mu_p - mu_m) # second order diff\\n return dn_dmu / n\",\n \"def test_loss_hamiltonian_incomplete(self):\\n g = nx.lollipop_graph(4, 1).to_directed()\\n edge_weight_data = {edge: (i + 1) * 0.5 for i, edge in enumerate(g.edges)}\\n for k, v in edge_weight_data.items():\\n g[k[0]][k[1]][\\\"weight\\\"] = v\\n h = loss_hamiltonian(g)\\n\\n expected_ops = [\\n qml.PauliZ(0),\\n qml.PauliZ(1),\\n qml.PauliZ(2),\\n qml.PauliZ(3),\\n qml.PauliZ(4),\\n qml.PauliZ(5),\\n qml.PauliZ(6),\\n qml.PauliZ(7),\\n qml.PauliZ(8),\\n qml.PauliZ(9),\\n qml.PauliZ(10),\\n qml.PauliZ(11),\\n qml.PauliZ(12),\\n qml.PauliZ(13),\\n ]\\n expected_coeffs = [\\n np.log(0.5),\\n np.log(1),\\n np.log(1.5),\\n np.log(2),\\n np.log(2.5),\\n np.log(3),\\n np.log(3.5),\\n np.log(4),\\n np.log(4.5),\\n np.log(5),\\n np.log(5.5),\\n np.log(6),\\n np.log(6.5),\\n np.log(7),\\n ]\\n\\n assert expected_coeffs == h.coeffs\\n assert all([op.wires == exp.wires for op, exp in zip(h.ops, expected_ops)])\\n assert all([type(op) is type(exp) for op, exp in zip(h.ops, expected_ops)])\",\n \"def get_34cohom_dim(v,l, even_e):\\n op1 = OrdinaryGraphComplex.ContractEdgesGO.generate_operator(v,l, even_e)\\n op2 = OrdinaryGraphComplex.ContractEdgesGO.generate_operator(v+1,l, even_e)\\n fullvs = op1.domain\\n fullvs2 = op2.domain\\n \\n vs34 = Valence34Mask(fullvs)\\n vs342 = Valence34Mask(fullvs2)\\n\\n D34rank = 0\\n if op1.is_valid():\\n D = op1.get_matrix()\\n # P34 = vs34.get_P34()\\n # D34 = D * P34 \\n i34 = vs34.get_34index_list()\\n D34 = D[:, i34]\\n D34rank = D34.rank()\\n\\n DD34rank = 0\\n DD5rank = 0\\n if op2.is_valid():\\n DD = op2.get_matrix()\\n # PP34 = vs342.get_P34()\\n ii34 = vs342.get_34index_list()\\n # DD34 = DD * PP34 \\n DD34 = DD[:,ii34]\\n DD34rank = DD34.rank()\\n\\n # P5 = vs34.get_P5()\\n # DD5 = P5 * DD * PP34\\n i5 = vs34.get_5index_list()\\n DD5 = DD[i5, ii34]\\n DD5rank = DD5.rank()\\n\\n\\n return vs34.get_34dimension() - D34rank -DD34rank + DD5rank\",\n \"def test_superposition_ud_cnot():\\n program = dedent(\\n \\\"\\\"\\\"\\\\\\n register q0[0]\\n register q1[1]\\n H q1\\n CNOT q1 q0\\n \\\"\\\"\\\"\\n )\\n\\n result = run(program, run_gate_array, return_distribution=True)\\n assert isclose(result, [0.5, 0.0, 0.0, 0.5]).all()\",\n \"def lstmcell_grad_h(input, hx, cx, w_ih, w_hh, b_ih, b_hh, dh, dc, target=\\\"cce\\\"):\\n # things from fwd\\n batch, input_size = get_shape(input)\\n _, hidden_size = get_shape(hx)\\n xh = akg.topi.concatenate((hx, input), 1)\\n whl = [w_ih, w_hh]\\n W = Concat(whl, 1) # [4*hidden_size, input_size+hidden_size]\\n\\n gates = dense(input, w_ih, b_ih, True) + dense(hx, w_hh, b_hh, True)\\n\\n ingate_in, forgetgate_in, cellgate_in, outgate_in = Split(gates, 4, 1)\\n\\n ingate = sigmoid(ingate_in)\\n forgetgate = sigmoid(forgetgate_in)\\n cellgate = Tanh(cellgate_in)\\n outgate = sigmoid(outgate_in)\\n cy = (forgetgate * cx) + (ingate * cellgate)\\n tanh_cy = Tanh(cy)\\n #hy = outgate * tanh_cy\\n\\n # starts bwd\\n # head * dh/do shape [n,]\\n doutgate = dh * tanh_cy\\n doutgate_in = outgate * (1 - outgate) * doutgate\\n kk = akg.tvm.reduce_axis((0, batch))\\n dWo = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j:\\n akg.tvm.sum(xh[kk, j] * doutgate_in(kk, i), axis=kk), name=\\\"dWo\\\")\\n\\n dtanh_cy = dh * outgate\\n dc = (1 - tanh_cy * tanh_cy) * dtanh_cy\\n\\n dingate = cellgate * dc\\n dingate_in = ingate * (1 - ingate) * dingate\\n kk3 = akg.tvm.reduce_axis((0, batch))\\n dWi = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j:\\n akg.tvm.sum(xh[kk3, j] * dingate_in(kk3, i), axis=kk3), name=\\\"dWi\\\")\\n\\n dforgetgate = dc * cx\\n dforgetgate_in = forgetgate * (1 - forgetgate) * dforgetgate\\n kk2 = akg.tvm.reduce_axis((0, batch))\\n dWf = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j:\\n akg.tvm.sum(xh[kk2, j] * dforgetgate_in(kk2, i), axis=kk2), name=\\\"dWf\\\")\\n\\n dcellgate = ingate * dc\\n dcellgate_in = (1 - cellgate * cellgate) * dcellgate\\n kk4 = akg.tvm.reduce_axis((0, batch))\\n dWc = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j:\\n akg.tvm.sum(xh[kk4, j] * dcellgate_in(kk4, i), axis=kk4), name=\\\"dWc\\\")\\n\\n dW = akg.topi.concatenate((dWi, dWf, dWc, dWo))\\n\\n db = akg.topi.concatenate((dingate_in, dforgetgate_in, dcellgate_in, doutgate_in), 1)\\n\\n kk5 = akg.tvm.reduce_axis((0, 4 * hidden_size))\\n dxh = akg.tvm.compute((batch, hidden_size + input_size), lambda i, j:\\n akg.tvm.sum(W[kk5, j] * db[i, kk5], axis=kk5), name=\\\"dxh\\\")\\n dhx = akg.tvm.compute((batch, hidden_size), lambda i, j: dxh[i, j], name=\\\"dhx\\\")\\n dx = akg.tvm.compute((batch, input_size), lambda i, j: dxh[i, j + hidden_size], name=\\\"dx\\\")\\n\\n dcx = forgetgate * dc\\n\\n dw_ih = akg.tvm.compute(w_ih.shape, lambda i, j: dW[i, j])\\n #dw_hh = akg.tvm.compute(w_hh.shape, lambda i, j: dW[i, j + input_size])\\n\\n bhr = akg.tvm.reduce_axis((0, batch))\\n\\n db_ih = akg.tvm.compute((4 * hidden_size,), lambda i: akg.tvm.sum(db[i, bhr], axis=bhr), name=\\\"dbih\\\")\\n\\n bir = akg.tvm.reduce_axis((0, batch))\\n\\n db_hh = akg.tvm.compute((4 * hidden_size,), lambda i: akg.tvm.sum(db[i, bir], axis=bir), name=\\\"dbhh\\\")\\n\\n return dw_ih, w_hh, db_ih, db_hh, dcx, dhx, dx\",\n \"def __findUHF(self,samples): \\n self.GPU_setArrayToZeros.prepared_call(self.gShapeZero,self.bShapeZero,\\n self.GPU_bufDoppSum)\\n\\n self.GPU_filterMasks.prepared_call(self.gShapeVecMasks,self.bShapeVecMasks,\\n self.GPU_bufXcorr,self.GPU_bufSignalFreq,self.GPU_bufBitsMask,self.GPU_bufDoppIdx,\\n np.int32(self.Nfft),np.int32(self.doppIdxArrayLen))\\n\\n if self.FFTNoBatches == 1:\\n cufft.cufftExecC2C(self.fftPlanDopplers,int(self.GPU_bufXcorr),int(self.GPU_bufXcorr),cufft.CUFFT_INVERSE)\\n\\n \\n else:\\n # It is at the moment faster to call single fft loops than batched fft loops (don't ask me why). This can however be changed in the config filte. Therefore all these loops\\n for j in range(self.fftLoops):\\n for i in range(self.num_streams):\\n if j*self.num_streams + i < self.FFTNoBatches:\\n buffAddr = self.buffAddr[j*self.num_streams+i] # compute the address in the large buffer\\n cufft.cufftExecC2C(self.fftPlanDopplers[i],buffAddr,buffAddr,cufft.CUFFT_INVERSE)\\n \\n self.GPU_absSumDoppler.prepared_call(self.gShapeAbsSum,self.bShapeAbsSum,\\n self.GPU_bufDoppSum,self.GPU_bufXcorr,np.int32(self.Nfft))\\n\\n if STORE_BITS_IN_FILE:\\n tstore = time.time()\\n tmpArr = np.empty((self.doppIdxArrayLen,self.num_masks),dtype=np.float32)\\n cuda.memcpy_dtoh(tmpArr,self.GPU_bufDoppSum)\\n self.sum_match = np.vstack([self.sum_match,np.sum(tmpArr,axis=1)])\\n sumBest = np.argmax(np.sum(tmpArr,axis=1))\\n log.debug(f'demodulator store in file 1 (save array) time {time.time()-tstore} s')\\n\\n self.GPU_estDoppler.prepared_call(self.gShapeDopp,self.bShapeDopp,\\n self.GPU_bufDoppResult,self.GPU_bufFindDoppTmp,self.GPU_bufDoppSum,np.int32(self.num_dopplers),np.int32(self.doppIdxArrayOffset))\\n\\n bestDoppler = np.empty(2,dtype=np.float32) # contains [doppler, standard_dev]\\n cuda.memcpy_dtoh(bestDoppler,self.GPU_bufDoppResult) # fetch the result\\n # do scaling with the best Doppler before returning\\n # Keep the scaling in indices. This is handier for the demodulation\\n\\n try:\\n lowIdx = int(bestDoppler[0])\\n highIdx = int(np.ceil(bestDoppler[0]))\\n lowVal = self.doppHzLUT[lowIdx]\\n highVal = self.doppHzLUT[highIdx]\\n # This one is for our stats\\n bestDopplerScaled = lowVal + (highVal-lowVal) * (bestDoppler[0] % 1) # scale with decimal offset\\n\\n # this one is for the demodulator. Contains the index\\n self.dopplerIdxlast = np.int32(np.round(self.doppCyperSymNorm[lowIdx] + (self.doppCyperSymNorm[highIdx]-self.doppCyperSymNorm[lowIdx]) * (bestDoppler[0] % 1))) # directly for use in the demodulator\\n # print(f'bestDopplerScaled {self.dopplerIdxlast}')\\n SNR = self.computeSNR(lowIdx,highIdx,5)\\n # SNR = 20.\\n freqOffset = bestDopplerScaled - self.centreFreqOffset # we only want the detected frequency offset. Not the IF offset\\n sdev_Hz = bestDoppler[1]/self.Nfft * self.sampleRate # not used when SUM_ALL_MASKS = 1\\n\\n except ValueError as e:\\n log.error(f'Error occurred during find_UHF -- skipping block. Message: {e}')\\n self.dopplerIdxlast = 0\\n freqOffset = 0.\\n sdev_Hz = 0.\\n SNR = 0.\\n \\n return freqOffset, sdev_Hz, self.clippedPeakIPure, SNR\",\n \"def directed_Hausdorff_hyperbox(b1,b2): \\n return max(0,np.max(np.hstack((b1.u-b2.u,b2.l-b1.l))))\",\n \"def getEG(n,int_method,func) :\\n m = np.asarray([0.5,0.6,0.7,0.8,0.9,1,1.1,1.2,1.3,1.4,1.5,2,2.5,3,3.5,4,\\n 4.5,5,5.5,6,6.5,7,7.5,8,8.5,9,9.5,10])\\n bes = np.asarray([0.5,0.47768,0.44879,0.39831,0.25858,0,0.15502,0.25699,\\n 0.30896,0.35245,0.39119,0.51822,0.53678,0.54984,0.55847,\\n 0.56395,0.57054,0.57950,0.58402,0.58765,0.59512,0.60214,\\n 0.60469,0.61143,0.61789,0.62443,0.63097,0.63694])\\n p = np.asarray([1,0.85417,0.94685,1.04467,2.55052,0,1.59086,\\n 1.00670,0.88866,0.83763,0.81030,0.76108,0.83093,0.86863,\\n 0.89233,0.90909,0.92097,0.93007,0.93735,0.94332,0.94813,\\n 0.95193,0.95557,0.95864,0.96107,0.96360,0.96570,\\n 0.96788])\\n h0 = np.asarray([0,-0.03567,-0.04808,-0.04315,-0.01879,0,0.00041,0.00069,\\n 0.00639,0.01405,0.02294,0.07814,0.13994,0.19278,0.23793,\\n 0.27678,0.31039,0.33974,0.36585,0.38917,0.41003,0.42891,\\n 0.44621,0.46195,0.47644,0.48982,0.50223,0.51379])\\n h1 = np.asarray([0,0.26899, 0.10571,0.01763,-0.39382,0,0.15211,0.05665,\\n 0.00933,-0.02791,-0.05876,-0.16720,-0.13033,-0.10455 ,\\n -0.08618,-0.07208,-0.06179,-0.05369,-0.04715,-0.04176,\\n -0.03742,-0.03408,-0.03081,-0.02808,-0.02599,-0.02375,\\n -0.02194,-0.02004])\\n h2 = np.asarray([0,-0.09016,-0.06893,-0.04971,-0.08828,0,-0.03341,\\n -0.03964,-0.04456,-0.04775,-0.04984,-0.05381,-0.03570,\\n -0.02476,-0.01789,-0.01333,-0.01028,-0.00812,-0.00653,\\n -0.00534,-0.00444,-0.00376,-0.00319,-0.00274,-0.00238,\\n -0.00207,-0.00182,-0.00160])\\n h3 = np.asarray([0,0.03993,0.03363,0.02216,-0.00797,0,0.00899,0.01172,\\n 0.01150,0.01026,0.00860,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\\n 0])\\n \\n if (func == True) :\\n int_bes = splev(n,splrep(m, bes))\\n int_p = splev(n,splrep(m, p))\\n int_h0 = splev(n,splrep(m, h0))\\n int_h1 = splev(n,splrep(m, h1))\\n int_h2 = splev(n,splrep(m, h2))\\n int_h3 = splev(n,splrep(m, h3))\\n else :\\n int_bes = griddata(m, bes, n, method=int_method)\\n int_p = griddata(m, p, n, method=int_method)\\n int_h0 = griddata(m, h0, n, method=int_method)\\n int_h1 = griddata(m, h1, n, method=int_method)\\n int_h2 = griddata(m, h2, n, method=int_method)\\n int_h3 = griddata(m, h3, n, method=int_method)\\n \\n return np.asarray([int_bes,int_p,int_h0,int_h1,int_h2,int_h3])\",\n \"def glueEmH( Ja, Jf, truncNum = scipy.inf ):\\n w, v = truncBasisH( Ja, truncNum )\\n sPlus, sMinus, sZ = sPlusAndMinusAndZ( v )\\n \\n H1 = scipy.zeros( ( len(w)**4, len(w)**4 ) )\\n \\n for n in range( len(w)**4 ):\\n # Diagonal previous generation contributions\\n o = oct(n)[-4:].zfill(4)\\n o = [int(char) for char in o]\\n o_A, o_B, o_C, o_D = o\\n \\n H1[n, n] += scipy.sum( [ w[ i ] for i in o ] )\\n \\n # Edge terms\\n for np in range( n, len(w)**4 ):\\n op = oct(np)[-4:].zfill(4)\\n op = [int(char) for char in op]\\n op_A, op_B, op_C, op_D = op\\n \\n x = 0.\\n if ( (o_B == op_B) and (o_C == op_C) ):\\n x += -Jf * ( .5 * ( sPlus[0][o_A, op_A] * sMinus[0][o_D, op_D] + sMinus[0][o_A, op_A] * sPlus[0][o_D,op_D] ) + sZ[0][o_A, op_A] * sZ[0][o_D, op_D] )\\n if ( (o_C == op_C) and (o_A == op_A) ):\\n x += -Jf * ( .5 * ( sPlus[1][o_B, op_B] * sMinus[1][o_D, op_D] + sMinus[1][o_B, op_B] * sPlus[1][o_D,op_D] ) + sZ[1][o_B, op_B] * sZ[1][o_D, op_D] )\\n if ( (o_A == op_A) and (o_B == op_B) ):\\n x += -Jf * ( .5 * ( sPlus[2][o_C, op_C] * sMinus[2][o_D, op_D] + sMinus[2][o_C, op_C] * sPlus[1][o_D,op_D] ) + sZ[1][o_C, op_C] * sZ[2][o_D, op_D] )\\n \\n H1[n, np] = x\\n H1[np, n] = x\\n \\n return H1\",\n \"def ecfp(mol,radius):\\n #mol=Chem.AddHs(mol)\\n bitInfo={}\\n atoms_dict=invariants(mol)\\n \\n for idxs,i in atoms_dict.items():\\n bitInfo[i]=bitInfo.get(i,())+((idxs,0),)\\n \\n neighborhoods=[]\\n atom_neighborhoods=[len(mol.GetBonds())*bitarray('0') for a in mol.GetAtoms()]\\n dead_atoms=len(mol.GetAtoms())*bitarray('0')\\n \\n for r in range(1,radius+1):\\n round_ids={} #new bit ID this iteration\\n round_atom_neighborhoods=copy.deepcopy(atom_neighborhoods) #bond to include under this r\\n neighborhoods_this_round=[] #(round_atom_neighborhoods,round_ids,idxs)\\n \\n for idxs,a in enumerate(mol.GetAtoms()):\\n if dead_atoms[idxs]:\\n continue\\n nbsr=[] #list to hash this iteration\\n o_bond=bond(mol,idxs)\\n for b in o_bond:\\n round_atom_neighborhoods[idxs][b[2]] = True\\n round_atom_neighborhoods[idxs] |= atom_neighborhoods[b[1]]\\n nbsr.append((b[0],atoms_dict[b[1]]))\\n nbsr=sorted(nbsr)\\n nbsr=[item for sublist in nbsr for item in sublist]\\n nbsr.insert(0,atoms_dict[idxs])\\n nbsr.insert(0,r)\\n \\n round_ids[idxs]=get_hash(nbsr)\\n neighborhoods_this_round.append((round_atom_neighborhoods[idxs],round_ids[idxs],idxs))\\n for lst in neighborhoods_this_round:\\n if lst[0] not in neighborhoods:\\n bitInfo[lst[1]] = bitInfo.get(lst[1],())+((lst[2],r),)\\n neighborhoods.append(lst[0])\\n else:\\n dead_atoms[lst[2]]=True\\n atoms_dict=round_ids\\n atom_neighborhoods=copy.deepcopy(round_atom_neighborhoods)\\n return bitInfo\",\n \"def ehermite(a, b):\\n [c, d, g] = extgcd(a, b)\\n if g:\\n E = np.array([[c, d], [-b/g, a/g]])\\n else:\\n E = np.array([[1, 0], [0, 1]])\\n\\n return E\\n #Leila: check this \\\"http://www.ece.northwestern.edu/local-apps/matlabhelp/techdoc/ref/gcd.html\\\"\",\n \"def check_correctness_sigmoid_channelwise(f):\\n\\n rng = np.random.RandomState([2012, 7, 19])\\n batch_size = 5\\n pool_size = 1\\n n = 3 * pool_size\\n zv = rng.randn(batch_size, n).astype(config.floatX) * 1. - 1.5\\n top_down_v = rng.randn(batch_size, n / pool_size).astype(config.floatX)\\n\\n z_th = T.matrix()\\n z_th.name = 'z_th'\\n\\n top_down_th = T.matrix()\\n top_down_th.name = 'top_down_th'\\n\\n p_th, h_th = f(z_th, pool_size, top_down_th)\\n h_s = T.nnet.sigmoid(z_th + top_down_th)\\n\\n func = function([z_th, top_down_th], [p_th, h_th, h_s])\\n\\n pv, hv, h_s = func(zv, top_down_v)\\n p_s = h_s\\n\\n assert p_s.shape == pv.shape\\n assert h_s.shape == hv.shape\\n if not np.allclose(h_s, hv):\\n print((h_s.min(), h_s.max()))\\n print((hv.min(), hv.max()))\\n assert False\\n if not np.allclose(p_s, pv):\\n diff = abs(p_s - pv)\\n print('max diff ', diff.max())\\n print('min diff ', diff.min())\\n print('ave diff ', diff.mean())\\n assert False\",\n \"def simulation_OFC(self,ncmE,ncmC,f,g,Cfun,h,dt,tf,x0,z0=None,dscale=10.0,\\\\\\n xnames=\\\"num\\\",Ncol=1,FigSize=(20,10),FontSize=20,phis=None):\\n \\\"\\\"\\\"\\n \\n \\n 1) SIMULATION\\n \\n \\n \\\"\\\"\\\"\\n if len(sig(f).parameters) == 1:\\n fun1 = f\\n f = lambda x,p: fun1(x)\\n if len(sig(g).parameters) == 1:\\n fun2 = g\\n g = lambda x,p: fun2(x)\\n if len(sig(Cfun).parameters) == 1:\\n fun3 = Cfun\\n Cfun = lambda x,p: fun3(x)\\n if len(sig(h).parameters) == 1:\\n fun4 = h\\n h = lambda x,p: fun4(x)\\n print(\\\"========================================================\\\")\\n print(\\\"====================== SIMULATIOM ======================\\\")\\n print(\\\"========================================================\\\")\\n if dt <= self.dt_rk:\\n self.dt_rk = dt\\n self.Nrk = int(dt/self.dt_rk)\\n Nsim = int(tf/dt)\\n np.set_printoptions(precision=1)\\n print(\\\"time step =\\\",dt)\\n print(\\\"terminal time =\\\",tf)\\n print(\\\"initial state =\\\",x0)\\n print(\\\"estimated initial state =\\\",z0)\\n funx = lambda x,p,dEf: f(x,p)+dEf(x,p)\\n z = z0\\n zhis = np.zeros((Nsim+1,self.n))\\n zhis[0,:] = z\\n x = x0\\n xhis = np.zeros((Nsim+1,self.n))\\n xhis[0,:] = x\\n tit1 = \\\"Performance of NCM-based Output Feedback (1)\\\"\\n tit2 = \\\"Performance of NCM-based Output Feedback (2)\\\"\\n tit3 = \\\"Performance of NCM-based Output Feedback (3)\\\"\\n tit4 = \\\"Performance of NCM-based Output Feedback (4)\\\"\\n ly = r\\\"estimation error: $\\\\|x-\\\\hat{x}\\\\|_2$\\\"\\n l1 = r\\\"estimation error\\\"\\n lyb = r\\\"tracking error: $\\\\|x-x_d\\\\|_2$\\\"\\n l1b = r\\\"tracking error\\\"\\n bNam1 = \\\"=================== ESTIMATION ERROR ===================\\\"\\n bNam2 = \\\"============ ESTIMATION ERROR OF EACH STATE ============\\\"\\n bNam3 = \\\"==================== Tracking ERROR ====================\\\"\\n bNam4 = \\\"============= Tracking ERROR OF EACH STATE =============\\\"\\n l2 = r\\\"optimal steady-state upper bound\\\"\\n if phis == None:\\n phis = np.linspace(self.plims[0,:],self.plims[1,:],Nsim)\\n for k in range(Nsim):\\n p = phis[k,:]\\n Mc = ncmC.ncm(z,p)\\n u = -g(z,p).T@Mc@z\\n dEfC = lambda x,p: g(x,p)@u\\n d1 = self.unifrand2(ncmC.d1_over,np.size(ncmC.Bw(x,p),1))*dscale\\n x = self.rk4(x,p,dEfC,funx)+ncmC.Bw(x,p)@d1*dt\\n xhis[k+1,:] = x\\n Me = ncmE.ncm(z,p)\\n Cx = Cfun(z,p)\\n Lx = Me@Cx.T\\n #Lx = K.T\\n d2 = self.unifrand2(ncmE.d2_over,np.size(ncmE.Gw(x,p),1))*dscale\\n y = h(x,u,p)+ncmE.Gw(x,p)@d2\\n funz = lambda z,p,dEf: f(z,p)+g(z,p)@u+dEf(z,p)\\n dEfE = lambda z,p: Lx@(y-h(z,u,p))\\n z = self.rk4(z,p,dEfE,funz)\\n zhis[k+1,:] = z\\n this = np.linspace(0,tf,Nsim+1)\\n \\\"\\\"\\\"\\n \\n \\n 2) FIGURE GENERATION\\n \\n \\n \\\"\\\"\\\"\\n print(\\\"========================================================\\\")\\n print(bNam1)\\n print(\\\"========================================================\\\")\\n matplotlib.rcParams.update({\\\"font.size\\\": 15})\\n matplotlib.rc(\\\"text\\\",usetex=True)\\n plt.figure()\\n plt.plot(this,np.sqrt(np.sum((xhis-zhis)**2,1)))\\n plt.plot(this,np.ones(np.size(this))*ncmE.Jcv_opt)\\n plt.xlabel(r\\\"time\\\",fontsize=FontSize)\\n plt.ylabel(ly,fontsize=FontSize)\\n plt.legend([l1,l2],loc=\\\"best\\\")\\n plt.title(tit1,fontsize=FontSize)\\n plt.show()\\n print(\\\"========================================================\\\")\\n print(bNam2)\\n print(\\\"========================================================\\\")\\n Nrow = int(self.n/Ncol)+np.remainder(self.n,Ncol)\\n fig,ax = plt.subplots(Nrow,Ncol,figsize=FigSize)\\n plt.subplots_adjust(wspace=0.25,hspace=0.25)\\n if Ncol == 1:\\n ax = np.reshape(ax,(self.n,1))\\n elif Nrow == 1:\\n ax = np.reshape(ax,(1,self.n))\\n if xnames == \\\"num\\\":\\n xnames = []\\n for i in range(self.n):\\n xnames += [r\\\"state \\\"+str(i+1)]\\n for row in range(Nrow):\\n for col in range(Ncol):\\n i = Ncol*row+col\\n if i+1 <= self.n:\\n ax[row,col].plot(this,xhis[:,i]-zhis[:,i])\\n ax[row,col].set_xlabel(r\\\"time\\\",fontsize=FontSize)\\n LabelName = r\\\"estimation error: \\\"+xnames[i]\\n ax[row,col].set_ylabel(LabelName,fontsize=FontSize)\\n fig.suptitle(tit2,fontsize=FontSize)\\n plt.show()\\n print(\\\"========================================================\\\")\\n print(bNam3)\\n print(\\\"========================================================\\\")\\n matplotlib.rcParams.update({\\\"font.size\\\": 15})\\n matplotlib.rc(\\\"text\\\",usetex=True)\\n plt.figure()\\n plt.plot(this,np.sqrt(np.sum((xhis)**2,1)))\\n plt.plot(this,np.ones(np.size(this))*ncmC.Jcv_opt)\\n plt.xlabel(r\\\"time\\\",fontsize=FontSize)\\n plt.ylabel(lyb,fontsize=FontSize)\\n plt.legend([l1b,l2],loc=\\\"best\\\")\\n plt.title(tit3,fontsize=FontSize)\\n plt.show()\\n print(\\\"========================================================\\\")\\n print(bNam4)\\n print(\\\"========================================================\\\")\\n Nrow = int(self.n/Ncol)+np.remainder(self.n,Ncol)\\n fig,ax = plt.subplots(Nrow,Ncol,figsize=FigSize)\\n plt.subplots_adjust(wspace=0.25,hspace=0.25)\\n if Ncol == 1:\\n ax = np.reshape(ax,(self.n,1))\\n elif Nrow == 1:\\n ax = np.reshape(ax,(1,self.n))\\n if xnames == \\\"num\\\":\\n xnames = []\\n for i in range(self.n):\\n xnames += [r\\\"state \\\"+str(i+1)]\\n for row in range(Nrow):\\n for col in range(Ncol):\\n i = Ncol*row+col\\n if i+1 <= self.n:\\n ax[row,col].plot(this,xhis[:,i])\\n ax[row,col].set_xlabel(r\\\"time\\\",fontsize=FontSize)\\n LabelName = r\\\"tracking error: \\\"+xnames[i]\\n ax[row,col].set_ylabel(LabelName,fontsize=FontSize)\\n fig.suptitle(tit4,fontsize=FontSize)\\n plt.show()\\n print(\\\"========================================================\\\")\\n print(\\\"==================== SIMULATIOM END ====================\\\")\\n print(\\\"========================================================\\\")\\n return this,xhis,zhis\",\n \"def edgeHam( H, Jf, repNum, repString, adjacencyList ):\\n \\n flipVal = -.5 * Jf\\n opVal = .25 * Jf\\n sameVal = -.25 * Jf\\n \\n # Cycle throught the adjacencies\\n for (i,j) in adjacencyList:\\n \\n si,sj = repString[i], repString[j]\\n \\n if si != sj:\\n # Raising / Lowering terms will flip the two and spit out -1/2 Jf\\n # We have to do some wonky stuff because you can't do element \\n # assignment with strings\\n flipString = [c for c in repString]\\n flipString[i] = sj\\n flipString[j] = si\\n flipString = ''.join( flipString )\\n flipNum = int( flipString, base = 2 )\\n \\n H[(repNum, flipNum)] += flipVal\\n \\n # Opposite spins will get a 1/4 from the s_z terms\\n H[(repNum, repNum)] += opVal\\n \\n else:\\n # Same spins will get a -1/4 from the s_z terms\\n H[(repNum, repNum)] += sameVal\",\n \"def check_correctness_channelwise(f):\\n\\n rng = np.random.RandomState([2012, 7, 19])\\n batch_size = 5\\n pool_size = 4\\n n = 3 * pool_size\\n zv = rng.randn(batch_size, n).astype(config.floatX) * 1. - 1.5\\n top_down_v = rng.randn(batch_size, n / pool_size).astype(config.floatX)\\n\\n p_np, h_np = max_pool_channels_python(zv, pool_size, top_down_v)\\n\\n z_th = T.matrix()\\n z_th.name = 'z_th'\\n\\n top_down_th = T.matrix()\\n top_down_th.name = 'top_down_th'\\n\\n p_th, h_th = f(z_th, pool_size, top_down_th)\\n\\n func = function([z_th, top_down_th], [p_th, h_th])\\n\\n pv, hv = func(zv, top_down_v)\\n\\n assert p_np.shape == pv.shape\\n assert h_np.shape == hv.shape\\n if not np.allclose(h_np, hv):\\n print((h_np.min(), h_np.max()))\\n print((hv.min(), hv.max()))\\n assert False\\n if not np.allclose(p_np, pv):\\n diff = abs(p_np - pv)\\n print('max diff ', diff.max())\\n print('min diff ', diff.min())\\n print('ave diff ', diff.mean())\\n assert False\",\n \"def mat24_complete_heptad(p_io):\\n ## uint_fast32_t err, s1, s5, s015, s3, s4, s8, s01234; \\n ## uint_fast32_t s567, s67, s9AB, s9CD, s9, s6GH, s6;\\n ## uint_fast32_t sACE, sD, sFGI, sG, sFJK, sJLM, sALN;\\n\\n err = ((p_io[0] + 8) | (p_io[1] + 8) | (p_io[2] + 8) | \\n (p_io[3] + 8) | (p_io[4] + 8) | (p_io[5] + 8) | (p_io[8] + 8));\\n err &= (0 - 0x20);\\n s1 = 1 << p_io[1]; \\n s5 = 1 << p_io[5];\\n s015 = (1 << p_io[0]) ^ s1 ^ s5;\\n s3 = 1 << p_io[3]; \\n s4 = 1 << p_io[4]; \\n s8 = 1 << p_io[8];\\n s01234 = s015 ^ s5 ^ (1 << p_io[2]) ^ s3 ^ s4;\\n # if err == 0 then 0 <= s01234 < 0x1000000 has odd parity\\n # octad = [0, 1, 2, 3, 4, 5, 6, 7]\\n s567 = odd_syn(s01234);\\n err |= (s01234) & s567;\\n # if err == 0 then entries [0,1,2,3,4,6] are in an octad\\n err |= (s01234 | s567) & s8;\\n # if err == 0 then entry 8 is not in that octad\\n err |= s5 ^ (s5 & s567);\\n s67 = s567 & ~s5;\\n # octad = [0, 1, 2, 3, 8, 9, 10, 11]\\n s9AB = odd_syn(s01234 ^ s4 ^ s8);\\n # octad = [0, 1, 4, 5, 8, 9, 12, 13]\\n s9CD = odd_syn(s015 ^ s4 ^ s8);\\n s9 = s9AB & s9CD;\\n p_io[9] = lsb24(s9);\\n # octad [1, 3, 5, 6, 8, 9, 16, 17]\\n s6GH = odd_syn(s1 ^ s3 ^ s5 ^ s8 ^ s9);\\n s6 = s67 & s6GH;\\n p_io[6] = lsb24(s6);\\n p_io[7] = lsb24(s67 & ~s6GH);\\n # still needed: \\n # err, s1, s015, s3, s8, s01234, s9AB, s9CD, s9, s6GH, s6\\n # octad [0, 2, 4, 6, 8, 10, 12, 14]\\n sACE = odd_syn(s01234 ^ s1 ^ s3 ^ s6 ^ s8);\\n p_io[10] = lsb24(s9AB & sACE);\\n p_io[11] = lsb24(s9AB & ~sACE & ~s9);\\n p_io[12] = lsb24(s9CD & sACE);\\n sD = s9CD & ~sACE & ~s9;\\n p_io[13] = lsb24(sD);\\n p_io[14] = lsb24(sACE & ~s9AB & ~s9CD);\\n # still needed: \\n # err, s1, s015, s3, s8, s6GH, s6, sACE, sD\\n # octad [0, 1, 5, 6, 13, 15, 16, 18]\\n sFGI = odd_syn(s015 ^ s6 ^ sD);\\n sG = s6GH & sFGI;\\n p_io[16] = lsb24(sG);\\n p_io[17] = lsb24(s6GH & ~s6 & ~sFGI);\\n # octad [0, 1, 3, 5, 8, 15, 19, 20]\\n sFJK = odd_syn(s015 ^ s3 ^ s8);\\n p_io[15] = lsb24(sFGI & sFJK);\\n p_io[18] = lsb24(sFGI & ~sG & ~sFJK);\\n # octad [0, 3, 5, 6, 16, 19, 21, 22]\\n sJLM = odd_syn(s015 ^ s1 ^ s3 ^ s6 ^ sG);\\n p_io[19] = lsb24(sFJK & sJLM);\\n p_io[20] = lsb24(sFJK & ~sFGI & ~sJLM);\\n # octad [0, 1, 5, 6, 8, 10, 21, 23]\\n sALN = odd_syn(s015 ^ s6 ^ s8); \\n p_io[21] = lsb24(sALN & sJLM);\\n p_io[22] = lsb24(sJLM & ~sALN & ~sFJK);\\n p_io[23] = lsb24(sALN & ~sACE & ~sJLM);\\n return err;\",\n \"def homothick():\\n return se2hmt(binary([[1,1,1],\\n [0,0,0],\\n [0,0,0]]),\\n binary([[0,0,0],\\n [0,1,0],\\n [1,1,1]]))\",\n \"def fedorenko(tau, h, grid):\\n relation = tau / h\\n new_grid = np.zeros(len(grid) - 1)\\n for m in range(1, len(grid) - 1):\\n new_grid[m-1] = grid[m] - np.dot(relation, grid[m] - grid[m-1]) - np.dot(relation / 2 * (relation - relation ** 2), grid[m-1] - 2 * grid[m] + grid[m+1])\\n new_grid = np.insert(new_grid, 0, grid[0])\\n return new_grid\",\n \"def optimize_fore(self):\\n self.u = np.random.uniform(-1, 1, (32, 288, 1, 1))\\n \\n self.l2 = torch.from_numpy(self.u).float()\\n print('self u shape',self.l2.shape)\\n self.n = torch.randn(32, 1, 28, 28)\\n self.l1 = self.enc(self.input + self.n)\\n self.del1=self.dec(self.l1)\\n self.del2=self.dec(self.l2)\\n self.update_netc()\\n self.update_netd()\\n\\n self.update_l2()\\n self.update_netg()\\n print('sssssssssssssssssssssss')\",\n \"def pingjiazhibiao(result):\\n import math\\n list_ed_normal = []\\n list_es_normal = []\\n list_ed_true = []\\n list_es_true = []\\n # these definations are for statistic\\n ed_pred_all, es_pred_all,ed_true_all,es_true_all,ed_match,es_match,ed_normal,es_normal,ed_nomiss,es_nomiss= 0,0,0,0,0,0,0,0,0,0\\n total_error_ed,total_error_es = 0,0\\n sample_missimg_num = 0\\n a4cdDict = {}\\n a4csDict = {}\\n for i in range(-5,7):\\n a4cdDict[i] = 0\\n a4csDict[i] = 0\\n for i in result:\\n pred = i[0]\\n ed_pred = pred[0]\\n es_pred = pred[1]\\n if ed_pred == [] or es_pred == []:\\n sample_missimg_num += 1\\n true = i[1]\\n ed_true = true[0]\\n es_true = true[1]\\n\\n # avoid many to one\\n ed_pred.sort()\\n es_pred.sort()\\n deleteAmong10frames(ed_pred)\\n deleteAmong10frames(es_pred)\\n \\n for j in ed_pred:\\n ed_pred_all += 1\\n for t in ed_true:\\n if math.fabs(j - t) < 6:\\n ed_normal += 1\\n total_error_ed += math.fabs(t - j)\\n a4cdDict[j-t]+=1\\n break\\n # all - normal = FP\\n # normal is TP\\n a4cdDict[6] = ed_pred_all-ed_normal\\n\\n for j in es_pred:\\n es_pred_all += 1\\n for t in es_true:\\n if math.fabs(j - t) < 6:\\n es_normal += 1\\n total_error_es += math.fabs(t - j)\\n a4csDict[j-t]+=1\\n break\\n a4csDict[6] = es_pred_all-es_normal\\n for j in ed_true:\\n ed_true_all += 1\\n for t in ed_pred:\\n if math.fabs(t - j) < 6:\\n ed_nomiss += 1\\n break\\n\\n for j in es_true:\\n es_true_all += 1\\n for t in es_pred:\\n if math.fabs(t - j) < 6:\\n es_nomiss += 1\\n break\\n # aFD precision recall \\n ed_result = total_error_ed / ed_normal,(ed_normal / ed_pred_all),(ed_nomiss / ed_true_all)\\n es_result = total_error_es / es_normal,(es_normal / es_pred_all),(es_nomiss / es_true_all)\\n return ed_result,a4cdDict, es_result,a4csDict, sample_missimg_num / len(result)\",\n \"def wol(noi, noft, times,\\r\\n M, NE, NI,\\r\\n Omee, Omei, Omie, Omii, F):\\r\\n FF=np.zeros((NE,1))\\r\\n for h in range(noi):\\r\\n ip=np.random.rand(M,1)\\r\\n ip/=np.linalg.norm(ip)\\r\\n cn=np.zeros((NE,1))\\r\\n for i in range(noft):\\r\\n c = np.zeros((M,1))\\r\\n VE, VI=np.zeros((NE, times)), np.zeros((NI, times))\\r\\n oe, oi=np.zeros((NE, times)), np.zeros((NI, times))\\r\\n re, ri=np.zeros((NE, times)), np.zeros((NI, times))\\r\\n for j in range(times):\\r\\n epev, epiv = sigv * np.random.randn(1,1), sigv * np.random.randn(1,1)\\r\\n epet, epit = sigt * np.random.randn(1,1), sigt * np.random.randn(1,1)\\r\\n c[:,0] = + 1 * ip[:,0]\\r\\n VE[:,j]=(1 - lam * dt) * VE[:,j-1] + dt* F[:,:] @ c[:,0] + Omee[:,:] @ oe[:,j-1] + Omie[:,:] @ oi[:,j-1] + epev[0,0]\\r\\n if VE[ne,j]>TE and RE[ne,0] < 0:\\r\\n oe[ne,j] = 1\\r\\n re[:,j]=(1 - lam * dt) * re[:,j-1]+oe[:,j-1]\\r\\n VI[:,j]=(1 - lam * dt) * VI[:,j-1] + Omei[:,:] @ oe[:,j-1] + Omii[:,:] @ oi[:,j-1] + epiv[0,0]\\r\\n ni=np.argmax(VI[:,j] - TI - epit[0,0])\\r\\n if VI[ni,j]>TI and RI[ni,0] < 0:\\r\\n oi[ni,j] = 1\\r\\n ri[:,j]=(1 - lam * dt) * ri[:,j-1]+oi[:,j-1]\\r\\n np.hstack((cn,np.sum(oe, axis=1, keepdims=True)))\\r\\n np.hstack((FF, np.var(cn[:,1:], axis=1)/np.mean(cn[:,1:], axis=1, keepdims=True)))\\r\\n return np.nanmean(FF[:,1:])\",\n \"def doublehgm_same_evaluation(input_generator,branches,iden_method,Plot,reference=None):\\n input_signal = input_generator.GetOutput()\\n filter_spec_tofind = nlsp.log_bpfilter(branches=branches,input=input_signal)\\n ref_nlsystem = nlsp.HammersteinGroup_Series(input_signal=input_signal,\\n nonlinear_functions=(nlsp.nl_branches(nlsp.function_factory.power_series,branches),nlsp.nl_branches(nlsp.function_factory.power_series,branches)),\\n filter_irs=(filter_spec_tofind,filter_spec_tofind),\\n max_harmonics=(range(1,branches+1),range(1,branches+1)),\\n hgm_type=(nlsp.HammersteinGroupModel_up,nlsp.HammersteinGroupModel_up))\\n\\n found_filter_spec, nl_functions = iden_method(input_generator,ref_nlsystem.GetOutput(2),branches)\\n iden_nlsystem = nlsp.HammersteinGroupModel_up(input_signal=input_signal,\\n nonlinear_functions=nl_functions,\\n filter_irs=found_filter_spec,\\n max_harmonics=range(1,branches+1))\\n if reference is not None:\\n reference = nlsp.change_length_signal(reference,length=len(input_signal))\\n ref_nlsystem = nlsp.HammersteinGroup_Series(input_signal=reference,\\n nonlinear_functions=(nlsp.nl_branches(nlsp.function_factory.power_series,branches),nlsp.nl_branches(nlsp.function_factory.power_series,branches)),\\n filter_irs=(filter_spec_tofind,filter_spec_tofind),\\n max_harmonics=(range(1,branches+1),range(1,branches+1)),\\n hgm_type=(nlsp.HammersteinGroupModel_up,nlsp.HammersteinGroupModel_up))\\n iden_nlsystem.SetInput(reference)\\n if Plot is True:\\n plot.relabelandplotphase(sumpf.modules.FourierTransform(ref_nlsystem.GetOutput(2)).GetSpectrum(),\\\"Reference System\\\",show=False)\\n plot.relabelandplotphase(sumpf.modules.FourierTransform(iden_nlsystem.GetOutput()).GetSpectrum(),\\\"Identified System\\\",show=True)\\n print \\\"SNR between Reference and Identified output for double hgm all same: %r\\\" %nlsp.snr(ref_nlsystem.GetOutput(2),\\n iden_nlsystem.GetOutput())\",\n \"def extendedGcd(a, b):\\n x0 = 1\\n x1 = 0\\n y0 = 0\\n y1 = 1\\n\\n while b != 0:\\n p = a // b\\n z = a % b\\n a = b\\n b = z\\n\\n w = x1\\n x1 = x0 - p * x1\\n x0 = w\\n \\n v = y1\\n y1 = y0 - p * y1\\n y0 = v\\n print(\\\"returns: gcd, si, ti\\\")\\n return (gcd(a, b), x0, y0)\",\n \"def _h(W):\\r\\n # E = slin.expm(W * W)\\r\\n # h = np.trace(E) - d\\r\\n M = np.eye(d) + W * W / d\\r\\n E = np.linalg.matrix_power(M, d - 1)\\r\\n h = (E.T * M).sum() - d\\r\\n G_h = E.T * W * 2\\r\\n return h, G_h\",\n \"def _dipole_gof(uu, sing, vv, B, B2):\\n ncomp = 3 if sing[2] / sing[0] > 0.2 else 2\\n one = np.dot(vv[:ncomp], B)\\n Bm2 = np.sum(one ** 2)\\n return Bm2 / B2, one\",\n \"def test_init_hebbian_3(self):\\n v_one = [1, -1, -1, -1, 1, -1, -1, -1, 1]\\n v_two = [-1, -1, -1, 1, 1, 1, -1, -1, -1]\\n v_three = [-1, -1, 1, -1, -1, 1, -1, -1, 1]\\n network = HopfieldNetwork([v_one, v_two, v_three])\\n expected = np.array([\\n [0, 1, -1, -1, 1, -3, 1, 1, 1],\\n [1, 0, 1, 1, -1, -1, 3, 3, -1],\\n [-1, 1, 0, -1, -3, 1, 1, 1, 1],\\n [-1, 1, -1, 0, 1, 1, 1, 1, -3],\\n [1, -1, -3, 1, 0, -1, -1, -1, -1],\\n [-3, -1, 1, 1, -1, 0, -1, -1, -1],\\n [1, 3, 1, 1, -1, -1, 0, 3, -1],\\n [1, 3, 1, 1, -1, -1, 3, 0, -1],\\n [1, -1, 1, -3, -1, -1, -1, -1, 0]\\n ])\\n npt.assert_equal(network.weight_matrix, expected)\",\n \"def ohms(self):\\n # Rwb = Rwiper + Rtotal * (counts / 256)\\n # Rwa = Rwiper + Rtotal * ((256 - counts) / 256)\\n g = 0\\n rtotal=0.0\\n reach=[]\\n for chan in self.get_channel_list(self.nchans):\\n self.rwa[chan] = float( 256 - self.vals[chan] ) / 256.0\\n self.rwb[chan] = float( self.vals[chan] ) / 256.0\\n self.rwa[chan] *= self.Rtotal\\n self.rwb[chan] *= self.Rtotal \\n self.rwa[chan] += self.Rwiper\\n self.rwb[chan] += self.Rwiper\",\n \"def inverse_gc(g):\\n i = g\\n j = 1\\n while j<N:\\n i = i ^ (g >> j)\\n j = j + 1\\n return i\",\n \"def toffoli(ha, hb, hc):\\n\\n return controlled_U(ha, cnot(hb, hc))\",\n \"def grover(self) -> None:\\n\\n size = self.circ_size\\n random.seed(self.seed)\\n\\n # Split the single qreg into the computational register and a \\\"work\\\" register to store the oracle results\\n qr = self.qr[:-1]\\n wr = self.qr[-1:]\\n\\n if self.truth_value is None:\\n raise ValueError(f'This circuit type requires a truth value be set before it can be generated. i.e. with'\\n f'\\\"my_Premade.truth_value = (some_int)\\\"')\\n\\n tv = self.truth_value\\n\\n self.h(qr)\\n\\n loop = math.floor(math.sqrt(2 ** size))\\n logger.debug(f'loop: {loop}')\\n for i in range(loop):\\n # NOT the wires where the magic state bit should be 0\\n for j in range(len(qr)):\\n if not tv & (1 << j): # i.e. tharr be zeroes in this here bitstring position\\n self.x(qr[j])\\n\\n self.x(wr[0])\\n self.mcrz(math.pi, qr, wr[0])\\n self.x(wr[0])\\n\\n for j in range(len(qr)):\\n if not tv & (1 << j): # i.e. tharr be zeroes in this here bitstring position\\n self.x(qr[j])\\n\\n # Inversion about the average\\n self.h(qr)\\n self.x(qr)\\n\\n self.mcrz(math.pi, qr[:-1], qr[-1])\\n\\n self.x(qr)\\n self.h(qr)\\n\\n if self.meas: self.measure(self.qr, self.cr)\",\n \"def test_superposition_cnot():\\n\\n program = dedent(\\n \\\"\\\"\\\"\\\\\\n register q0[0]\\n register q1[1]\\n H q0\\n CNOT q0 q1\\n \\\"\\\"\\\"\\n )\\n\\n result = run(program, run_gate_array, return_distribution=True)\\n assert isclose(result, [0.5, 0.0, 0.0, 0.5]).all()\",\n \"def cell_cnc_tracker(Out, U, V, W, t, cell0, cellG, cellD, SHP, cryoconite_locations):\\n\\n Cells = np.random.rand(len(t),SHP[0],SHP[1],SHP[2]) * cell0\\n CellD = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellD\\n CellG = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellG\\n \\n \\n for i in np.arange(0,SHP[0],1):\\n CellG[i,:,:] = np.where(cryoconite_locations==True, CellG[i,:,:]*1000, CellG[i,:,:])\\n \\n for t in np.arange(0,len(Out.Qz[:,0,0,0]),1):\\n \\n for layer in np.arange(0,len(Out.Qz[0,:,0,0]),1):\\n\\n # normalise lateral flow so that -ve= flow out of cells towards edges\\n # and positive flow is towards centre line. In Qx -ve = leftwards flow\\n # and +ve = rightwards flow. This leads to a rightwards drift in cell\\n # fluxes if not normalised in this way.\\n U[t,layer,:,0:int(U.shape[2]/2)] = 0-U[t,layer,:,0:int(U.shape[2]/2)]\\n\\n # nabla is the inverted delta operator used to denote the divergence \\n # of a vector field, here applied to hydrological flow in m3/d \\n # calculated as dx/dt + dy/dt + dz/dt\\n\\n nabla = (U[t,layer,:,:] + V[t,layer,:,:] + W[t,layer,:,:])\\n \\n # divergence gives net in/outflow in m3/t\\n # cells/m3 = cells/mL *1000\\n\\n delC = Out.Q[t,layer,:,:] * (1+CellG[layer,:,:] - CellD[layer,:,:])\\n\\n Cells[t,layer,:,:] = Cells[t,layer,:,:] + (delC * 1000) \\n\\n Cells[Cells<0] = 0\\n \\n CellColumnTot = Cells.sum(axis=1)\\n \\n\\n return Cells, CellColumnTot\",\n \"def dnde_photon_spectrum_fns(\\n self,\\n) -> Dict[str, Callable[[Union[float, npt.NDArray[np.float64]], float], float]]:\\n\\n def dnde_zero(e, _: float):\\n return np.zeros_like(e)\\n\\n def wrap(f):\\n @functools.wraps(f)\\n def fnew(*args, **kwargs):\\n return f(self, *args, **kwargs)\\n\\n return fnew\\n\\n return {\\n \\\"e e\\\": wrap(dnde_photon_e_e),\\n \\\"mu mu\\\": wrap(dnde_photon_mu_mu),\\n \\\"ve ve\\\": dnde_zero,\\n \\\"vt vt\\\": dnde_zero,\\n \\\"vm vm\\\": dnde_zero,\\n \\\"pi pi\\\": wrap(dnde_photon_pi_pi),\\n \\\"k0 k0\\\": wrap(dnde_photon_k0_k0),\\n \\\"k k\\\": wrap(dnde_photon_k_k),\\n \\\"pi0 gamma\\\": wrap(dnde_photon_pi0_gamma),\\n \\\"eta gamma\\\": wrap(dnde_photon_eta_gamma),\\n \\\"pi0 phi\\\": wrap(dnde_photon_pi0_phi),\\n \\\"eta phi\\\": wrap(dnde_photon_eta_phi),\\n \\\"eta omega\\\": wrap(dnde_photon_eta_omega),\\n \\\"pi0 pi0 gamma\\\": wrap(dnde_photon_pi0_pi0_gamma),\\n \\\"pi pi pi0\\\": wrap(dnde_photon_pi_pi_pi0),\\n \\\"pi pi eta\\\": wrap(dnde_photon_pi_pi_eta),\\n \\\"pi pi etap\\\": wrap(dnde_photon_pi_pi_etap),\\n \\\"pi pi omega\\\": wrap(dnde_photon_pi_pi_omega),\\n \\\"pi0 pi0 omega\\\": wrap(dnde_photon_pi0_pi0_omega),\\n \\\"pi0 k0 k0\\\": wrap(dnde_photon_pi0_k0_k0),\\n \\\"pi0 k k\\\": wrap(dnde_photon_pi0_k_k),\\n \\\"pi k k0\\\": wrap(dnde_photon_pi_k_k0),\\n \\\"pi pi pi pi\\\": wrap(dnde_photon_pi_pi_pi_pi),\\n \\\"pi pi pi0 pi0\\\": wrap(dnde_photon_pi_pi_pi0_pi0),\\n \\\"v v\\\": wrap(dnde_photon_v_v),\\n }\",\n \"def le_func(rn, g, h):\\n le = np.copy(rn)\\n le -= g\\n le -= h\\n return le\",\n \"def Heralded_HOM_exp_simulator(squeezing_parameter, bs_reflectivity, number_resolving_det=True, coher_ampl=0., old_PNR_func=False,\\n cutoff=6, parallelized=False):\\n\\n #####################\\n ### INITALISATION ###\\n #####################\\n\\n nmodes = 4\\n\\n ## Initialises the initial covariance matrix of the Gaussian state to be the identity,\\n ## meaning we start with vacuum in all modes.\\n cov_mat = np.identity(2 * nmodes)\\n\\n ##############################\\n ### DEFINE COHERENT STATES ###\\n ##############################\\n\\n ## Defines the coherent state amplitudes in the input modes.\\n ## Because no coherent state is present here, they are all zeros.\\n ampls = np.ones(nmodes) * coher_ampl\\n\\n ###########################\\n ### DEFINE SPDC SOURCES ###\\n ###########################\\n\\n ## Defines the first SPDC source as a TMS between modes 0 and 1, as a symplectic transformation\\n TMS1 = get_tms_sym(squeezing_parameter, phi=0, Mode1=0, Mode2=1, NumModes=nmodes)\\n\\n ## Defines the second SPDC source as a TMS between modes 2 and 3, as a symplectic transformation\\n TMS2 = get_tms_sym(squeezing_parameter, phi=0, Mode1=2, Mode2=3, NumModes=nmodes)\\n\\n ############################\\n ### DEFINE LINEAR OPTICS ###\\n ############################\\n\\n ## Defines the linear-optical unitary (in this case a simple tunable beam-splitter),\\n tunable_bs_matrix = np.identity(nmodes)\\n tunable_bs_matrix[1, 1] = np.sqrt(1 - bs_reflectivity)\\n tunable_bs_matrix[1, 2] = np.sqrt(bs_reflectivity)\\n tunable_bs_matrix[2, 1] = - np.sqrt(bs_reflectivity)\\n tunable_bs_matrix[2, 2] = np.sqrt(1 - bs_reflectivity)\\n LO_unitary = tunable_bs_matrix\\n\\n ## Gets the linear-optical transformation in the symplectic form.\\n LO_unitary_sym = get_unitary_sym(LO_unitary)\\n\\n ###############################################\\n ### CALCULATE TOTAL GAUSSIAN TRANSFORMATION ###\\n ###############################################\\n\\n ## Obtains the total Gaussian transformation matrix in the symplectic formalism\\n sym_transf = LO_unitary_sym @ TMS2 @ TMS1\\n\\n #############################\\n ### EVOLVE GAUSSIAN STATE ###\\n #############################\\n\\n ## Obtains the covariance matrix of the output Gaussian state\\n cov_mat = symplectic_evolution(cov_mat, sym_transf)\\n\\n ## Obtains the amplitudes of the output Gaussian state\\n ampls = LO_unitary @ ampls\\n\\n ###############################\\n ### SINGLE PHOTON DETECTION ###\\n ###############################\\n\\n ## Map state into the StrawberryField package, which has fast functions for\\n ## photon counting (i.e. non-Gaussian measurements) from Gaussian states.\\n gauss_state = map_into_StrawberryFields(ampls, cov_mat, nmodes)\\n\\n ## Define in which modes we want t observe a coincidence detection.\\n ## In this case we are looking for a 4-fold coincidence detection with a photon in all four modes.\\n ## Repeated elements would represent multiple photons in the same mode. I.e. [0, 0, 2]\\n ## would indicate two photons in mode 0 and one in mode 2.\\n output_configuration = [0, 1, 2, 3]\\n\\n ## convert the detection configuration into a Fock state\\n output_Fock = conf_to_Fock(output_configuration, nmodes)\\n\\n if number_resolving_det:\\n ## Calculates the detection probability considering number-resolving detectors.\\n det_prob = gauss_state.fock_prob(output_Fock)\\n else:\\n if old_PNR_func:\\n ## Calculates the detection probability considering threshold detectors.\\n det_prob = threshold_detection_prob_old(gauss_state, output_Fock, cutoff=cutoff)\\n else:\\n ## Calculates the detection probability considering threshold detectors.\\n if parallelized:\\n det_prob = threshold_detection_prob_parallel(gauss_state.cov(), gauss_state.means(), output_Fock)\\n else:\\n det_prob = threshold_detection_prob(gauss_state.cov(), gauss_state.means(), output_Fock)\\n\\n return det_prob\",\n \"def next_heegner_disc(self, n=0, sgn=-1, fd=False):\\n for D in range(n + 1, 2 * n + 100):\\n DD = D * sgn\\n if(self.is_Heegner_disc(DD)):\\n return DD\\n raise ArithmeticError(\\\" COuld not find any Heegner discriminat > {0} !\\\".format(n))\",\n \"def test_h_gate_nondeterministic_minimal_basis_gates(self):\\n shots = 2000\\n circuits = ref_1q_clifford.h_gate_circuits_nondeterministic(final_measure=True)\\n targets = ref_1q_clifford.h_gate_counts_nondeterministic(shots)\\n job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='U,CX')\\n result = job.result()\\n self.is_completed(result)\\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)\",\n \"def test_tanh_con():\\n c=14\\n assert {'diff':EF.tanh(c).der, 'value': EF.tanh(c).val}=={'diff':0, 'value': ((math.exp(c)-math.exp(-c))/2)/((math.exp(c)+math.exp(-c))/2)}\",\n \"def rnn_tanh_cell_grad(input, hidden, w_ih, w_hh, b_ih, b_hh, grad, target=\\\"cce\\\"):\\n batch, input_size = get_shape(input)\\n _, hidden_size = get_shape(hidden)\\n igates = akg.topi.nn.dense(input, w_ih, b_ih)\\n hgates = akg.topi.nn.dense(hidden, w_hh, b_hh)\\n h = Tanh(igates + hgates)\\n\\n dh = (1 - h * h) * grad\\n kk = akg.tvm.reduce_axis((0, batch))\\n dWih = akg.tvm.compute((hidden_size, input_size), lambda i, j:\\n akg.tvm.sum(input[kk, j] * dh(kk, i), axis=kk), name=\\\"dWih\\\")\\n kk2 = akg.tvm.reduce_axis((0, batch))\\n dWhh = akg.tvm.compute((hidden_size, hidden_size), lambda i, j:\\n akg.tvm.sum(hidden[kk2, j] * dh(kk2, i), axis=kk2), name=\\\"dWhh\\\")\\n kk3 = akg.tvm.reduce_axis((0, hidden_size))\\n di = akg.tvm.compute((batch, input_size), lambda i, j: akg.tvm.sum(w_ih[kk3, j] * dh[i, kk3], axis=kk3), name=\\\"di\\\")\\n kk4 = akg.tvm.reduce_axis((0, hidden_size))\\n dhid = akg.tvm.compute((batch, hidden_size), lambda i, j: akg.tvm.sum(w_hh[kk4, j] * dh[i, kk4], axis=kk4), name=\\\"dhid\\\")\\n db = akg.topi.sum(dh, 0)\\n return di, dhid, dWih, dWhh, db\\n # dbih/dbhh are the same and returning it twice causes CCEbuild to fail due to some SSA error\\n # return di, dhid, dWih, dWhh, db, db\",\n \"def HaarGOB(treeG):\\n # number of level of the chain (or tree)\\n Ntr = len(treeG)\\n # reorder chain (optional) \\n # reordering each level so that in each level the nodes are in the\\n # descent order of degrees\\n # compute u_l^c for level J_0 (top level)\\n clusterJ0 = treeG[Ntr-1]['clusters']\\n N0 = len(clusterJ0)\\n # generate indicator function on G^c\\n chic = np.identity(N0)\\n uc = [None]*N0\\n uc[0] = 1/np.sqrt(N0,dtype=np.float64)*np.ones(N0)\\n for l in np.arange(1, N0):\\n uc[l] = np.sqrt((N0-l)/(N0-l+1))*(chic[l-1,:]-1/(N0-l)*np.sum(chic[l:,:], axis=0))\\n# u = copy.deepcopy(uc)\\n treeG[Ntr-1]['u'] = uc\\n # compute the next level orthonormal basis ulk and stored into u\\n for j_tr in np.arange(0, Ntr-1)[::-1]:\\n N1 = len(treeG[j_tr]['clusters'])\\n u = [None]*N1\\n i = N0\\n for l in range(N0):\\n clusterl = treeG[j_tr+1]['clusters'][l]\\n kl = len(clusterl)\\n #for k==1\\n ucl = uc[l]\\n ul1 = np.zeros(N1)\\n for j in range(N0):\\n idxj = treeG[j_tr+1]['clusters'][j]\\n ul1[idxj] = ucl[j]/np.sqrt(len(idxj))\\n u[l] = ul1\\n if kl>1:\\n chil = np.zeros((kl,N1))\\n for k in range(kl):\\n idxl = treeG[j_tr+1]['clusters'][l]\\n chil[k,idxl[k]] = 1;\\n \\n for k in np.arange(1,kl):\\n i = i+1\\n ulk = np.sqrt((kl-k)/(kl-k+1))*(chil[k-1,:]-1/(kl-k)*np.sum(chil[k:,:],axis=0))\\n u[i-1] = ulk\\n treeG[j_tr]['u'] = u\\n # update uc and N0\\n# uc = copy.deepcopy(u)\\n uc = u\\n N0 = N1\\n return treeG\",\n \"def ftlan_E1c(hop, v0, T, m=50, Min_b=10e-10, Min_m=5, kB=1, norm = np.linalg.norm):\\n# def Tri_diag(a1, b1):\\n# mat = np.diag(b1, -1) + np.diag(a1, 0) + np.diag(b1, 1)\\n# e, w = np.linalg.eigh(mat)\\n# return e, w\\n\\n beta = 1./(T * kB)\\n E = 0.\\n a, b = [], []\\n v0 = v0/norm(v0)\\n Hv = hop(v0)\\n a.append(v0.dot(Hv))\\n v1 = Hv - a[0] * v0\\n b.append(norm(v1))\\n if b[0] < Min_b:\\n return 0\\n\\n v1 = v1/b[0]\\n Hv = hop(v1)\\n a.append(v1.dot(Hv))\\n\\n for i in range(1, m - 1):\\n v2 = Hv - b[i - 1] * v0 - a[i] * v1\\n b.append(norm(v2))\\n if abs(b[i]) < Min_b:\\n b.pop()\\n break\\n\\n v2 = v2/b[i]\\n Hv = hop(v2)\\n a.append(v2.dot(Hv))\\n v0 = v1.copy()\\n v1 = v2.copy()\\n \\n a = np.asarray(a)\\n b = np.asarray(b)\\n\\n eps, phi = Tri_diag(a, b)\\n l = len(eps)\\n# Eo = eps[0]\\n# eps = eps-Eo\\n exp_eps = np.exp(-beta * eps)\\n E = np.sum(exp_eps * eps * phi[0, :]**2.)\\n Z = np.sum(exp_eps * phi[0, :]**2.)\\n# for i in range(len(eps)):\\n# E += exp_eps[i] * eps[i] * phi[0, i]**2\\n\\n# E = E + Eo\\n# de = eps[:, np.newaxis] - eps\\n# for i in range(l):\\n# E += eps[i] * phi[0, i]**2./np.sum(np.exp(-beta*de[:l, i])*(phi[0, :l]**2.))\\n return E, Z\",\n \"def real_extract(og, fg):\\n\\n oe = sg2plato(og)\\n ae = sg2plato(fg)\\n q = 0.22 + 0.001 * oe\\n return (q * oe + ae) / (1 + q)\",\n \"def test6(self):\\n smis = [ 'CCC(O)C(=O)O','c1ccccc1','C1CCCCC1','C1NCCCC1','CNCNCNC']\\n for smi in smis:\\n m = Chem.MolFromSmiles(smi)\\n fp1 = Chem.RDKFingerprint(m,2,7,4096)\\n fp2 = DataStructs.FoldFingerprint(fp1,2)\\n fp3 = Chem.RDKFingerprint(m,2,7,2048)\\n assert tuple(fp2.GetOnBits())==tuple(fp3.GetOnBits())\\n fp2 = DataStructs.FoldFingerprint(fp2,2)\\n fp3 = Chem.RDKFingerprint(m,2,7,1024)\\n assert tuple(fp2.GetOnBits())==tuple(fp3.GetOnBits())\\n fp2 = DataStructs.FoldFingerprint(fp1,4)\\n assert tuple(fp2.GetOnBits())==tuple(fp3.GetOnBits())\",\n \"def hgmwithfilter_evaluation(input_generator,branches,nlfuntion,iden_method,Plot,reference=None):\\n input_signal = input_generator.GetOutput()\\n # filter_spec_tofind = nlsp.create_bpfilter([2000,8000,30000],input_signal)\\n filter_spec_tofind = nlsp.log_bpfilter(branches=branches,input=input_signal)\\n # filter_spec_tofind = [i for i in reversed(filter_spec_tofind)]\\n length_kernel = len(filter_spec_tofind[0])\\n # filter_spec_tofind = nlsp.log_chebyfilter(branches=branches,input=input_signal)\\n ref_nlsystem = nlsp.HammersteinGroupModel_up(input_signal=input_signal,\\n nonlinear_functions=nlsp.nl_branches(nlfuntion,branches),\\n filter_irs=filter_spec_tofind,\\n max_harmonics=range(1,branches+1))\\n found_filter_spec, nl_functions = iden_method(input_generator,ref_nlsystem.GetOutput(),branches)\\n found_filter_spec = nlsp.change_length_filterkernels(found_filter_spec,length=length_kernel)\\n iden_nlsystem = nlsp.HammersteinGroupModel_up(input_signal=input_signal,\\n nonlinear_functions=nl_functions,\\n filter_irs=found_filter_spec,\\n max_harmonics=range(1,branches+1))\\n # nlsp.filterkernel_evaluation_plot(filter_spec_tofind,found_filter_spec)\\n # nlsp.filterkernel_evaluation_sum(filter_spec_tofind,found_filter_spec)\\n if reference is not None:\\n reference = nlsp.change_length_signal(reference,length=len(input_signal))\\n ref_nlsystem.SetInput(reference)\\n iden_nlsystem.SetInput(reference)\\n if Plot is True:\\n plot.relabelandplot(ref_nlsystem.GetOutput(),\\\"Reference Output\\\",show=False)\\n plot.relabelandplot(iden_nlsystem.GetOutput(),\\\"Identified Output\\\",show=True)\\n # nlsp.plot_array([sumpf.modules.FourierTransform(s).GetSpectrum() for s in filter_spec_tofind],label_array=[\\\"reference%d\\\" %i for i in range(len(filter_spec_tofind))],Show=False)\\n # nlsp.plot_array([sumpf.modules.FourierTransform(s).GetSpectrum() for s in found_filter_spec],label_array=[\\\"identified%d\\\" %i for i in range(len(found_filter_spec))],Show=True)\\n print \\\"SNR between Reference and Identified output without overlapping filters: %r\\\" %nlsp.snr(ref_nlsystem.GetOutput(),\\n iden_nlsystem.GetOutput())\\n sumpf.modules.SignalFile(filename=\\\"C:/Users/diplomand.8/Desktop/linearHGM_explannation/cheby/noise/input\\\", signal=reference,format=sumpf.modules.SignalFile.WAV_FLOAT)\\n sumpf.modules.SignalFile(filename=\\\"C:/Users/diplomand.8/Desktop/linearHGM_explannation/cheby/noise/%s\\\" %iden_method.__name__,signal=iden_nlsystem.GetOutput(),format=sumpf.modules.SignalFile.WAV_FLOAT)\\n sumpf.modules.SignalFile(filename=\\\"C:/Users/diplomand.8/Desktop/linearHGM_explannation/cheby/noise/reference\\\",signal=ref_nlsystem.GetOutput(),format=sumpf.modules.SignalFile.WAV_FLOAT)\",\n \"def cantor() -> bigger.MCG[Edge]: # pylint: disable=too-many-statements\\n\\n POS, EQ, NEG = +1, 0, -1\\n\\n def edges() -> Iterable[Edge]:\\n for x in naturals():\\n for y in [POS, EQ, NEG]:\\n yield x, y\\n\\n def negate(X: Edge) -> Edge:\\n return X[0], -X[1]\\n\\n def invert(sign: int, X: tuple[Edge, bool, Edge, bool, Edge, bool, Edge, bool]) -> tuple[Edge, bool, Edge, bool, Edge, bool, Edge, bool]:\\n return X if sign == POS else (negate(X[6]), not X[7], negate(X[4]), not X[5], negate(X[2]), not X[3], negate(X[0]), not X[1])\\n\\n def link(edge: Edge) -> tuple[Edge, bool, Edge, bool, Edge, bool, Edge, bool]:\\n n, k = edge\\n if k == EQ: # Equator\\n if n == 0:\\n return ((0, NEG), False, (1, NEG), True, (1, POS), False, (0, POS), True)\\n elif n == 1:\\n return ((2, POS), False, (0, POS), False, (0, NEG), True, (2, NEG), True)\\n else: # n > 1\\n return ((3 * n - 3, NEG), False, (3 * n - 1, NEG), True, (3 * n - 1, POS), False, (3 * n - 3, POS), True)\\n\\n # Northern / Southern hemisphere.\\n if n == 0:\\n return invert(k, ((0, EQ), False, (1, POS), False, (1, EQ), True, (2, POS), False))\\n elif n == 1:\\n return invert(k, ((4, POS), False, (3, POS), False, (0, POS), True, (0, EQ), False))\\n elif n == 2:\\n return invert(k, ((7, POS), False, (6, POS), False, (0, POS), False, (1, EQ), True))\\n N, r = n // 3 + 1, n % 3\\n incoming = 3 * (N // 2) - (1 if N % 2 else 2)\\n if r == 0:\\n return invert(k, ((N, EQ), False, (n + 2, POS), False, (incoming, POS), True, (n + 1, POS), False))\\n elif r == 1:\\n return invert(k, ((6 * N - 2, POS), False, (6 * N - 3, POS), False, (n - 1, POS), False, (incoming, POS), True))\\n else: # r == 2:\\n return invert(k, ((6 * N + 1, POS), False, (6 * N + 0, POS), False, (n - 2, POS), True, (N, EQ), False))\\n\\n T = bigger.Triangulation.from_pos(edges, link)\\n\\n def generator(name: str) -> bigger.Encoding[Edge]: # pylint: disable=too-many-branches\\n twist_match = re.match(r\\\"(?P<curve>[ab])_(?P<n>-?\\\\d+)$\\\", name)\\n rotate_match = re.match(r\\\"r$\\\", name)\\n\\n if twist_match is not None:\\n parameters = twist_match.groupdict()\\n curve_name = parameters[\\\"curve\\\"]\\n N = int(parameters[\\\"n\\\"])\\n if curve_name == \\\"a\\\":\\n if N == 1:\\n cut_sequence = [(0, EQ), (0, POS), (1, EQ)]\\n else:\\n cut_sequence = [(0, EQ), (N, EQ), (3 * N - 3, POS)]\\n while N > 1:\\n low_N = N // 2\\n cut_sequence.append((3 * low_N - (1 if N % 2 else 2), POS))\\n if N % 2:\\n cut_sequence.append((3 * low_N - 3, POS))\\n N = low_N\\n elif curve_name == \\\"b\\\":\\n if N <= 3:\\n cut_sequence = [(0, EQ), (0, POS), (1, EQ)]\\n else:\\n extend_left = N % 2\\n N = N // 2\\n cut_sequence = [(N, EQ), (3 * N - 3, POS)]\\n while N > 1:\\n N_low = N // 2\\n cut_sequence.append((3 * N_low - (1 if N % 2 else 2), POS))\\n if extend_left:\\n cut_sequence.append((3 * N_low - 3, POS))\\n if N % 2 != extend_left:\\n cut_sequence.append((N_low, EQ))\\n break\\n N = N_low\\n else:\\n cut_sequence.append((0, EQ))\\n\\n curve = T(dict(((x, y * s), 1) for x, y in cut_sequence for s in [+1, -1]))\\n return curve.twist()\\n elif rotate_match is not None:\\n\\n def isom(edge: Edge) -> Edge:\\n n, k = edge\\n if k == EQ:\\n if n == 0:\\n return (1, EQ)\\n elif n == 1:\\n return (0, EQ)\\n return (n ^ (1 << n.bit_length() - 2), k)\\n\\n if n == 0:\\n return (0, k)\\n elif n == 1:\\n return (2, k)\\n elif n == 2:\\n return (1, k)\\n N, r = n // 3 + 1, n % 3\\n return (3 * (N ^ (1 << N.bit_length() - 2)) - 3 + r, k)\\n\\n return T.encode([(-1, isom, isom)])\\n\\n raise ValueError(f\\\"Unknown mapping class {name}\\\")\\n\\n return bigger.MCG(T, generator)\",\n \"def a5_homelien(clk, i, o):\\n\\n\\tmajority = Signal(bool(0))\\n\\tr1, r1_reg, r1_clk, r1_out, r1_bit = lfsr_hw(clk, i, majority, 19, [13, 16, 17, 18], 8, \\\"R1\\\")\\n\\tr2, r2_reg, r2_clk, r2_out, r2_bit = lfsr_hw(clk, i, majority, 22, [20, 21], 10, \\\"R2\\\")\\n\\tr3, r3_reg, r3_clk, r3_out, r3_bit = lfsr_hw(clk, i, majority, 23, [7, 20, 21, 22], 10, \\\"R3\\\")\\n\\t@always_comb\\n\\tdef xors():\\n\\t\\t# this should be done automatically with the chain function from the lists above\\n\\t\\t# but perhaps need to complain on myhdl list to get it working again\\n\\t\\tr1_bit.next = i[0] ^ r1_reg[13] ^ r1_reg[16] ^ r1_reg[17] ^ r1_reg[18]\\n\\t\\tr2_bit.next = i[0] ^ r2_reg[20] ^ r2_reg[21]\\n\\t\\tr3_bit.next = i[0] ^ r3_reg[7] ^ r3_reg[20] ^ r3_reg[21] ^ r3_reg[22]\\n\\n\\t@always_comb\\n\\tdef calc_stuff():\\n\\t\\tmajority.next = (r1_clk + r2_clk + r3_clk) >= 2\\n\\t\\to.next = r1_out ^ r2_out ^ r3_out\\n\\n\\treturn (r1, r2, r3, calc_stuff, xors)\",\n \"def chkiapws09table6(printresult=True,chktol=_CHKTOL):\\n from teospy.tests.tester import Tester\\n args1 = [(273.15,101325.), (273.15,1e8), (313.15,101325.)]\\n DERS2 = ((0,0),(1,0),(0,1),(2,0),(1,1),(0,2))\\n \\n funs = liq_g\\n fargs = [(der+args) for args in args1 for der in DERS2]\\n refs = [\\n 0.101342743e3,0.147644587,0.100015695e-2,-0.154472324e2,\\n -0.677459513e-7,-0.508915308e-12,\\n 0.977303868e5,0.851506346e1,0.956683354e-3,-0.142970174e2,\\n 0.199088060e-6,-0.371527164e-12,\\n -0.116198898e5,-0.572365181e3,0.100784471e-2,-0.133463968e2,\\n 0.388499694e-6,-0.445841077e-12\\n ]\\n fnames = 'liq_g'\\n argfmt = '({0:1g},{1:1g},{2:6.2f},{3:6g})'\\n header = 'F03 liq_g derivatives'\\n testder = Tester(funs,fargs,refs,fnames,argfmt,header=header)\\n \\n funs = [cp,density,soundspeed,\\n enthalpy,entropy,helmholtzenergy,internalenergy]\\n fargs = args1\\n refs = [\\n [0.421941153e4,0.390523030e4,0.417942416e4],\\n [0.999843071e3,0.104527793e4,0.992216354e3],\\n [0.140240099e4,0.157543089e4,0.152891242e4],\\n [0.610136242e2,0.954044973e5,0.167616267e6],\\n [-0.147644587,-0.851506346e1,0.572365181e3],\\n [0.183980891e-2,0.206205140e4,-0.117220097e5],\\n [-0.403272791e2,-0.263838183e3,0.167514147e6]\\n ]\\n fnames = ['cp','density','soundspeed',\\n 'enthalpy','entropy','helmholtzenergy','internalenergy']\\n argfmt = '({0:6.2f},{1:6g})'\\n header = 'F03 thermodynamic properties'\\n testprop = Tester(funs,fargs,refs,fnames,argfmt,header=header)\\n \\n # Run Tester instances and print results\\n testder.run()\\n testprop.run()\\n if printresult:\\n testder.printresults(chktol=chktol)\\n testprop.printresults(chktol=chktol)\\n return (testder, testprop)\",\n \"def test():\\n Z = func.evaluate_circuit(F, e_x, e_y, e_xor)\\n if Z == d[0]:\\n return 0\\n elif Z == d[1]:\\n return 1\",\n \"def test_mannext(self):\\n self.chck_triple('mannext')\",\n \"def FigA7(case):\\n \\n #set the parameter, arrays\\n \\n n_array=np.array([1,2,3])\\n\\n #set the result arrays\\n if case==0:\\n class_number=5\\n elif case==1:\\n class_number=6\\n fate=np.zeros([class_number])#number of evolutionary fate\\n fate_matrix=np.zeros([np.size(n_array),np.size(fate)])\\n \\n time=np.linspace(0,100000, 1000000)\\n loop=10**6\\n \\\"\\\"\\\"\\n 0 Co and/or Ch cannot survive in mono-culture\\n 1 Co cannot invade\\n 2 Only equilibrium of exclusion is stable\\n 3 Only equilibrium of coexistence is stable\\n 4 Two equilibria are UNstable\\n 5 two Equilibrium are stable (which may occur only when sCO vs rCh)\\n \\\"\\\"\\\"\\n for tri in range(np.size(n_array)):\\n counter=0\\n n=n_array[tri]\\n print(str(\\\"Hill coefficient is %d\\\" %(n)))\\n fate=np.zeros([class_number])#number of evolutionary fate should be reset\\n if case==0 or case==1:\\n fname=str('parameter-sweep-MC-n%d-case%d' %(n, case))\\n else:\\n print(\\\"Error in case\\\")\\n return 1\\n \\n for i in range(loop):\\n if(i+1)%10000==0:\\n print(i+1)\\n Ks,cd,T0, alpha,=np.random.uniform(0,1,4)\\n Kr,cr=np.random.uniform([Ks,0],[1,1],2)#Kr>Ks and cr.cd\\n #check whether r is positive or not\\n if case==0:\\n r1=rmax*(1-cr-cd)#rCO\\n r2=rmax#sCH\\n W0Co=r1-dmax*T0**n/(T0**n+Kr**n)-alpha#initial growth of Cooperator\\n W0Ch=r2-dmax*T0**n/(T0**n+Ks**n)-alpha#initial growth of Cheater\\n elif case==1:\\n r1=rmax*(1-cd)#sCo\\n r2=rmax*(1-cr)#rCh\\n W0Co=r1-dmax*T0**n/(T0**n+Ks**n)-alpha\\n W0Ch=r2-dmax*T0**n/(T0**n+Kr**n)-alpha\\n stab_e=0#initialize the falgs of stability\\n stab_c=0\\n if W0Co<0 or W0Ch<0:\\n fate[0]+=1\\n res=0\\n else:\\n #succeed in mono-culture \\n init=np.array([T0,10**(-6)])\\n if case==0: \\n solCo=odeint(DyCoop, init, time, args=(T0, r1, Kr, alpha, n))\\n Ts=solCo[-1,0]\\n #x1s=solCo[-1,1]\\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Ks, alpha, n))\\n x2s=solCh[-1,1]\\n else:\\n solCo=odeint(DyCoop, init, time, args=(T0, r1, Ks, alpha, n))\\n Ts=solCo[-1,0]\\n #x1s=solCo[-1,1]\\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Kr, alpha, n))\\n x2s=solCh[-1,1]\\n \\n #Evolutionary dynamics \\n if case==0:\\n K=Kr\\n else:\\n K=Ks\\n if r1*(1-x2s)-dmax*T0**n/(T0**n+K**n)<alpha:\\n #Co cannot invade\\n fate[1]+=1\\n res=1\\n else:\\n #Co can invade\\n #calculate Tdagger Td and check whether coexist or exclude\\n if case==0:\\n #rCo vs sCh\\n #in this case, at most one equilbrium is stable\\n tau=Quad(case,alpha,cr+cd,0,Kr, Ks, n)\\n Td=tau**(1/n)\\n if Td<Ts:\\n #Co exclude Ch\\n fate[2]+=1\\n res=2\\n else:\\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\\n #check the stability condition\\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\\n if stab==0:\\n #stable coexistence\\n fate[3]+=1\\n res=3\\n else:\\n #unstable coexistence nor exclusion\\n fate[4]+=1\\n res=4\\n print(Td, x1d, x2d)\\n else:\\n #sCo vs rCh\\n # in this case two equilibria can be stable at the same time\\n [tau_p,tau_m]=Quad(case,alpha,cd,cr,Ks, Kr, n)\\n if tau_m>Ts**n or tau_p<Ts**n:\\n # cexclusion is stable\\n stab_e=1\\n # stability in coexistence \\n if tau_p<0:\\n stab_c=0\\n else:\\n Td=tau_p**(1/n)\\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\\n #check the stability condition\\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\\n if stab==0:\\n #stable coexistence\\n stab_c=1\\n #classify\\n if stab_e==1 and stab_c==1:\\n # two stable equilbria\\n fate[5]+=1\\n res=5\\n elif stab_e==1 and stab_c==0:\\n #only stable cexclusion\\n fate[2]+=1\\n res=2\\n elif stab_e==0 and stab_c==1:\\n #stable coexistence\\n fate[3]+=1\\n res=3\\n else:\\n #both unstable\\n fate[4]+=1\\n res=4\\n \\n #save the results\\n if counter==0:\\n result=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\\n #save the result with parameter values\\n \\n else:\\n #add array of results\\n R=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\\n result=np.concatenate((result, R), axis=0)\\n counter+=1\\n \\n #save csv file and graph\\n np.savetxt(fname+'.csv',result, delimiter=',', header='Ks, Kr, cr, cd, alpha, T0, class', fmt='%.6f') \\n print(fate)\\n fate_matrix[tri,:]=fate \\n if case==0: \\n np.savetxt('parameter_sweep_MC_total_case0.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4', fmt='%d')\\n else:\\n np.savetxt('parameter_sweep_MC_total_case1.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4,cl5', fmt='%d')\\n Plot(case)\",\n \"def pollard(N) :\\n\\tleft = right = seed\\n\\td = 1\\n\\twhile d == 1: \\n\\t\\tleft = pseudo(left,N)\\n\\t\\tright = pseudo(pseudo(right,N),N)\\n\\t\\td = gcd(abs(left-right),N)\\n\\t\\tif PRINT_TRACE : \\n\\t\\t\\tprint(left,right,d)\\n\\tif d == N : \\n\\t\\tprint(\\\"Failure\\\")\\n\\telse :\\n\\t\\tprint(\\\"non trivial factor is %d\\\"%d)\",\n \"def CFHX(m_dot, p_nominal, epsilon, p_HP_in, T_HP_in, p_LP_in, T_LP_in):\\r\\n\\r\\n\\r\\n # Data from Aleks:\\r\\n # Length CFHX = 22 cm\\r\\n # D_in = 23.6 mm, D_out 40.5 mm\\r\\n # T range: 40 K - 5 K\\r\\n # m_dot = 0.5 g/s\\r\\n # p = 1 bar\\r\\n # Effectiveness: 97.4 %\\r\\n # dp_HP = 4.8 mbar (= dp23)\\r\\n # dp_LP = 5 mbar (= dp78)\\r\\n\\r\\n # Geometry of the CFHX\\r\\n A_HP = 0.25 * np.pi * 0.0236**2 #m²\\r\\n A_LP = 0.25 * np.pi * (0.0405**2 - 0.0236**2) #m²\\r\\n\\r\\n\\r\\n ## Calculation of the outgoing pressure with the scaled pressure drops\\r\\n\\r\\n # Scaling of the pressure drop with the Darcy--Weisbach equation\\r\\n # dp = f *L/D_i * 0.5 * Rho * u**2\\r\\n dp_HP_Aleks = 4.8e2 #Pa\\r\\n dp_LP_Aleks = 5.0e2 #Pa\\r\\n # Mean density with the arithmetic mean of the temperature range values\\r\\n Rho_Aleks = hp.HeCalc(3, 0, 1, 1e5, 2, 0.5*(40+5), 1) #kg/m³\\r\\n u_HP_Aleks = 0.5e-3/(A_HP*Rho_Aleks) #m/s\\r\\n u_LP_Aleks = 0.5e-3/(A_LP*Rho_Aleks) #m/s\\r\\n\\r\\n # Mean density of the two inlet temperatures and the nominal pressure to be able to compare the dp\\r\\n Rho = hp.HeCalc(3, 0, 1, p_nominal, 2, 0.5*(T_HP_in + T_LP_in), 1) #kg/m³\\r\\n u_HP = m_dot/(A_HP*Rho) #m/s\\r\\n u_LP = m_dot/(A_LP*Rho) #m/s\\r\\n\\r\\n # Actual scaling\\r\\n dp_HP = Rho/Rho_Aleks * u_HP**2/u_HP_Aleks**2 * dp_HP_Aleks #Pa\\r\\n dp_LP = Rho/Rho_Aleks * u_LP**2/u_LP_Aleks**2 * dp_LP_Aleks #Pa\\r\\n\\r\\n # Calculation of the outgoing pressure with the scaled pressure drops\\r\\n p_HP_out = p_HP_in - dp_HP #Pa\\r\\n p_LP_out = p_LP_in - dp_LP #Pa\\r\\n\\r\\n\\r\\n ## Calculation of the outgoing temperatures using the effectiveness\\r\\n # Asumming that the effectiveness is the same for both the HP and the LP side!\\r\\n\\r\\n # Check which stream restricts the heat exchange -> Pinch point\\r\\n # See \\\"Compact heat exchangers\\\" by Kays, London : Chapter 7\\r\\n dh_HP_max = hp.HeCalc(9, 0, 1, p_HP_in, 2, T_HP_in, 1) - hp.HeCalc(9, 0, 1, p_HP_out, 2, T_LP_in, 1)\\r\\n dh_LP_max = hp.HeCalc(9, 0, 1, p_LP_out, 2, T_HP_in, 1) - hp.HeCalc(9, 0, 1, p_LP_in, 2, T_LP_in, 1)\\r\\n\\r\\n # The maximum possible heat transfer corresponds to the restricting one\\r\\n dh_max = min(dh_HP_max, dh_LP_max)\\r\\n\\r\\n # Calculating the specific enthalpy with all known pressures and temperatures\\r\\n h_HP_in = hp.HeCalc(9, 0, 1, p_HP_in, 2, T_HP_in, 1) #J/kg\\r\\n h_LP_in = hp.HeCalc(9, 0, 1, p_LP_in, 2, T_LP_in, 1) #J/kg\\r\\n\\r\\n # Calculating the outgoing enthalpies\\r\\n h_HP_out = h_HP_in - epsilon * dh_max #J/kg\\r\\n h_LP_out = h_LP_in + epsilon * dh_max #J/kg\\r\\n\\r\\n # Calculation of the temperatures dependend on the specific enthalpy and the pressure\\r\\n T_HP_out = hp.HeCalc(2, 0, 1, p_HP_out, 9, h_HP_out, 1) #K\\r\\n T_LP_out = hp.HeCalc(2, 0, 1, p_LP_out, 9, h_LP_out, 1) #K\\r\\n\\r\\n # Cross check the dp scaling\\r\\n # print(\\\"u_HP_Aleks\\\", u_HP_Aleks)\\r\\n # print(\\\"u_HP\\\", u_HP)\\r\\n # print(\\\"Rho_Aleks\\\", Rho_Aleks)\\r\\n # print(\\\"Rho\\\", Rho)\\r\\n # print(\\\"dp_HP\\\", dp_HP)\\r\\n # print(\\\"dp_HP/dp_HP_Aleks \\\", dp_HP/dp_HP_Aleks)\\r\\n # print(\\\"dp_LP/dp_LP_Aleks \\\", dp_LP/dp_LP_Aleks)\\r\\n\\r\\n # Output of the results\\r\\n state_out = {\\\"h_HP\\\": h_HP_out, \\\"T_HP\\\": T_HP_out, \\\"p_HP\\\": p_HP_out,\\r\\n \\\"h_LP\\\": h_LP_out, \\\"T_LP\\\": T_LP_out, \\\"p_LP\\\": p_LP_out}\\r\\n return state_out\",\n \"def softclippingHGMevaluation(input_generator,branches,iden_method,Plot,reference=None):\\n for t in range(8,11):\\n t = t / 10.0\\n p = 1.0 - t\\n input_signal = input_generator.GetOutput()\\n nl_functions = [nlsp.function_factory.softclip(power=p),]*branches\\n filter_spec_tofind = nlsp.log_bpfilter(branches=branches, input=input_signal)\\n ref_nlsystem = nlsp.HammersteinGroupModel_up(input_signal=input_signal,\\n nonlinear_functions=nl_functions,\\n filter_irs=filter_spec_tofind,\\n max_harmonics=range(1,branches+1))\\n\\n found_filter_spec, nl_functions = iden_method(input_generator,ref_nlsystem.GetOutput(),branches)\\n iden_nlsystem = nlsp.HammersteinGroupModel_up(input_signal=input_signal,\\n nonlinear_functions=nl_functions,\\n filter_irs=found_filter_spec,\\n max_harmonics=range(1,branches+1))\\n # sine = sumpf.modules.SineWaveGenerator(frequency=5000.0,phase=0.0,samplingrate=input_signal.GetSamplingRate(),length=len(input_signal)).GetSignal()\\n sine = sumpf.modules.SweepGenerator(samplingrate=input_signal.GetSamplingRate(),length=len(input_signal)).GetSignal()\\n ref_nlsystem.SetInput(sine)\\n iden_nlsystem.SetInput(sine)\\n if reference is not None:\\n reference = nlsp.change_length_signal(reference,length=len(input_signal))\\n ref_nlsystem.SetInput(reference)\\n iden_nlsystem.SetInput(reference)\\n\\n if Plot is True:\\n plot.relabelandplot(sumpf.modules.FourierTransform(ref_nlsystem.GetOutput()).GetSpectrum(),\\\"Reference System\\\",show=False)\\n plot.relabelandplot(sumpf.modules.FourierTransform(iden_nlsystem.GetOutput()).GetSpectrum(),\\\"Identified System\\\",show=False)\\n print \\\"SNR between Reference and Identified output for symmetric hardclipping HGM(threshold:%r): %r\\\" %(t,nlsp.snr(ref_nlsystem.GetOutput(),\\n iden_nlsystem.GetOutput()))\",\n \"def hilfe(self):\\n sDreieck_hilfe(3)\",\n \"def test_bit_driver_output(self):\\n\\n H = qaoa.bit_driver(range(3), 1)\\n hamiltonian = qml.Hamiltonian([1, 1, 1], [qml.PauliZ(0), qml.PauliZ(1), qml.PauliZ(2)])\\n\\n assert decompose_hamiltonian(H) == decompose_hamiltonian(hamiltonian)\",\n \"def test_helpers():\\n\\n print \\\"GCD of 8 and 12 is %0d\\\" % fractions.gcd(8, 12)\\n\\n print \\\"%0d and %0d are co-prime\\\" % (2, coPrime(2))\\n print \\\"%0d and %0d are co-prime\\\" % (6, coPrime(6))\\n\\n mod_inverse(11, 60)\\n\\n modulo(2, 3, 4)\\n\\n totient(24)\",\n \"def dice(hm, hf):\\n return 2 * np.count_nonzero(hm & hf) / float(np.count_nonzero(hm) + np.count_nonzero(hf))\",\n \"def needleman_wunsch(x, y, lodict={}, gop=-2.5, gep=-1.75, local=False, indel=''):\\n n, m = len(x), len(y)\\n dp = np.zeros((n + 1, m + 1))\\n pointers = np.zeros((n + 1, m + 1), np.int32)\\n if not local:\\n for i1, c1 in enumerate(x):\\n if gop is None:\\n dp[i1 + 1, 0] = lodict.get((c1, indel), gep)\\n else:\\n dp[i1 + 1, 0] = dp[i1, 0]+(gep if i1 + 1 > 1 else gop)\\n pointers[i1 + 1, 0] = 1\\n for i2, c2 in enumerate(y):\\n if gop is None:\\n dp[0, i2 + 1] = lodict.get((indel, c2), gep)\\n else:\\n dp[0, i2 + 1] = dp[0, i2]+(gep if i2 + 1 > 1 else gop)\\n pointers[0, i2 + 1] = 2\\n for i1, c1 in enumerate(x):\\n for i2, c2 in enumerate(y):\\n match = dp[i1, i2] + lodict.get(\\n (c1, c2),\\n 1 if c1 == c2 else -1)\\n insert = dp[i1, i2 + 1] + (\\n lodict.get((c1, indel), gep) if gop is None else\\n gep if pointers[i1, i2 + 1] == 1 else gop)\\n delet = dp[i1 + 1, i2] + (\\n lodict.get((indel, c2), gep) if gop is None else\\n gep if pointers[i1 + 1, i2] == 2 else gop)\\n pointers[i1 + 1, i2 + 1] = p = np.argmax([match, insert, delet])\\n max_score = [match, insert, delet][p]\\n if local and max_score < 0:\\n max_score = 0\\n dp[i1 + 1, i2 + 1] = max_score\\n alg = []\\n if local:\\n i, j = np.unravel_index(dp.argmax(), dp.shape)\\n else:\\n i, j = n, m\\n score = dp[i, j]\\n while (i > 0 or j > 0):\\n pt = pointers[i, j]\\n if pt == 0:\\n i -= 1\\n j -= 1\\n alg = [(x[i], y[j])] + alg\\n if pt == 1:\\n i -= 1\\n alg = [(x[i], indel)] + alg\\n if pt == 2:\\n j -= 1\\n alg = [(indel, y[j])] + alg\\n if local and dp[i, j] == 0:\\n break\\n return score, alg\",\n \"def hilfe(self):\\n sZweieck_hilfe(3)\",\n \"def make_Gr(mlat, *J):\\n\\n if (len(J)!=3):\\n print(\\\"Number of paramaters are not right, must be 5!\\\")\\n \\n NN = 2*mlat # # of sites in one super unitcell\\n tau = -np.zeros((NN, NN),dtype=complex)\\n h = np.zeros((NN,NN), dtype=complex)\\n\\n # translational cell's Hamiltonian\\n for i in range(mlat-1):\\n if (i%2==0):\\n h[i,i+1] = J[0]\\n h[mlat+i,mlat+i+1] = J[1]\\n h[i,mlat+i] = J[2] # horizoltal connection\\n elif (i%2==1):\\n h[i,i+1] = J[1]\\n h[mlat+i,mlat+i+1] = J[0]\\n # longitudinal connection of the last sites\\n if (mlat-1)%2 == 0:\\n h[mlat-1,2*mlat-1] = J[2]\\n \\n h = h + h.conj().T # make it hermitian\\n\\n # Hopping matrix\\n for i in range(1,mlat,2):\\n tau[i+mlat,i] = J[2]\\n\\n return h, tau\",\n \"def tanh(a):\",\n \"def TR_algo3(h, vd=2):\\n ve = 0\\n vd = 2\\n p = [0]*N\\n for i in range(M-1, -1, -1):\\n w = [bit_component(h, i*N+ii) for ii in range(N)]\\n #print(i, w)\\n w = sum( [wx*2**j for j, wx in enumerate(w)] )\\n #print(i, w, gc(w))\\n l = gc(w)\\n l = T_inv(ve, vd, l)\\n for j in range(N):\\n p[j] += bit_component(l, j) << i\\n ve = ve ^ rotate_left(e(w), vd+1)\\n vd = (vd + d(w) + 1) % N\\n return p\",\n \"def enthalpy(temp,pres):\\n g = liq_g(0,0,temp,pres)\\n g_t = liq_g(1,0,temp,pres)\\n h = g - temp*g_t\\n return h\",\n \"def detect_edges_hed(self):\\n inp = cv2.dnn.blobFromImage(self.input_image, scalefactor=1.0,\\n size=(self.WIDTH, self.HEIGHT),\\n mean=(104.00698793, 116.66876762, 122.67891434),\\n swapRB=False, crop=False)\\n self.net.setInput(inp)\\n out = self.net.forward()\\n hed = out[0, 0]\\n hed = (255 * hed).astype(\\\"uint8\\\")\\n hed = cv2.fastNlMeansDenoising(hed, SMOOTH_FACTOR, SMOOTH_FACTOR, 21)\\n save_image_opencv(hed, 'hed')\\n hed_skel = skeletonize(hed).astype(\\\"uint8\\\")\\n save_image_opencv(hed_skel, 'hed_skel')\\n thresheld_hed = cv2.threshold(hed_skel, 0, 255,\\n cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]\\n save_image_opencv(thresheld_hed, 'thresheld_hed')\\n return hed, thresheld_hed\",\n \"def test_hof(a, b):\\n def f(g, x):\\n return g(x) * g(x + 10.0)\\n\\n def g(x):\\n return x * b\\n\\n return f(g, a) + f(g, b)\",\n \"def hilfe(self):\\n sKreis_hilfe(3)\",\n \"def current_operator(h0):\\n h = h0.copy()\\n h = h0.get_multicell() # multicell Hamiltonian\\n if h.dimensionality != 1: raise # only for 1d\\n if not h.is_multicell: # no multicell\\n def fj(k):\\n phik = np.exp(1j*2.*np.pi*k) # complex phase\\n jk = 1j*(h.inter*phik - h.inter.H*np.conjugate(phik)) \\n return jk\\n else: # multicell Hamiltonian\\n def fj(k):\\n jk = h.intra*0. # initialize\\n for t in h.hopping:\\n phik = np.exp(1j*2.*np.pi*k*t.dir[0]) # complex phase\\n jk = jk + 1j*t.m*phik*t.dir[0]\\n return jk\\n return fj\",\n \"def Mo96(self,dc,nu):\\n return 1. + (nu**2.-1.)/dc\",\n \"def magma_zheevd_m(ngpu, jobz, uplo, n, A, lda, w, work, lwork,\\n rwork, lrwork, iwork, liwork):\\n\\n uplo = _uplo_conversion[uplo]\\n info = c_int_type()\\n status = _libmagma.magma_zheevd_m(ngpu, jobz, uplo, n, int(A), lda,\\n int(w), int(work), lwork, int(rwork),\\n lrwork, int(iwork), liwork, ctypes.byref(info))\\n magmaCheckStatus(status)\",\n \"def fix_COO_and_NH(pdb):\\n M = Molecule(pdb)\\n ds = M.ds\\n g = M.g\\n m = Chem.MolFromPDBFile(pdb, removeHs=True) # don't use True, otherwise Error\\n mc = Chem.EditableMol(m)\\n q = Chem.MolFromSmarts( 'C(~[O])~[O]' )\\n matches = m.GetSubstructMatches(q)\\n #bom = Chem.GetAdjacencyMatrix(m,useBO=True)\\n for (i,j,k) in matches:\\n d1, d2 = ds[i,j], ds[i,k]\\n b1 = m.GetBondBetweenAtoms(i,j)\\n b2 = m.GetBondBetweenAtoms(i,k)\\n if d1 < d2:\\n bij = 2.0; bik = 1.0\\n else:\\n bij = 1.0; bik = 2.0\\n mc.RemoveBond(i,j)\\n mc.RemoveBond(i,k)\\n mc.AddBond(i,j,bo2bt['%.1f'%bij])\\n mc.AddBond(i,k,bo2bt['%.1f'%bik])\\n mu = mc.GetMol()\\n return mu\\n # NX4, e.g., >[N+]<, >[NH+]-, >[NH2+], -[NH3+]\\n #q = Chem.MolFromSmarts( '[NX4]' )\\n\\n # [*]~NX2, e.g., >C=[NH2+]\\n\\n # [*]~NX, e.g., >C=[NH+]-\",\n \"def test_hyperbolic_functions(self):\\r\\n inputs = ['0', '0.5', '1', '2', '1+j']\\r\\n neg_inputs = ['0', '-0.5', '-1', '-2', '-1-j']\\r\\n negate = lambda x: [-k for k in x]\\r\\n\\r\\n # sinh is odd\\r\\n sinh_vals = [0, 0.521, 1.175, 3.627, 0.635 + 1.298j]\\r\\n self.assert_function_values('sinh', inputs, sinh_vals)\\r\\n self.assert_function_values('sinh', neg_inputs, negate(sinh_vals))\\r\\n\\r\\n # cosh is even - do not negate\\r\\n cosh_vals = [1, 1.128, 1.543, 3.762, 0.834 + 0.989j]\\r\\n self.assert_function_values('cosh', inputs, cosh_vals)\\r\\n self.assert_function_values('cosh', neg_inputs, cosh_vals)\\r\\n\\r\\n # tanh is odd\\r\\n tanh_vals = [0, 0.462, 0.762, 0.964, 1.084 + 0.272j]\\r\\n self.assert_function_values('tanh', inputs, tanh_vals)\\r\\n self.assert_function_values('tanh', neg_inputs, negate(tanh_vals))\\r\\n\\r\\n # sech is even - do not negate\\r\\n sech_vals = [1, 0.887, 0.648, 0.266, 0.498 - 0.591j]\\r\\n self.assert_function_values('sech', inputs, sech_vals)\\r\\n self.assert_function_values('sech', neg_inputs, sech_vals)\\r\\n\\r\\n # the following functions do not have 0 in their domain\\r\\n inputs = inputs[1:]\\r\\n neg_inputs = neg_inputs[1:]\\r\\n\\r\\n # csch is odd\\r\\n csch_vals = [1.919, 0.851, 0.276, 0.304 - 0.622j]\\r\\n self.assert_function_values('csch', inputs, csch_vals)\\r\\n self.assert_function_values('csch', neg_inputs, negate(csch_vals))\\r\\n\\r\\n # coth is odd\\r\\n coth_vals = [2.164, 1.313, 1.037, 0.868 - 0.218j]\\r\\n self.assert_function_values('coth', inputs, coth_vals)\\r\\n self.assert_function_values('coth', neg_inputs, negate(coth_vals))\",\n \"def mobius(decomp): #fix 1 value\\n return 0 if any([decomp[p] >= 2 for p in decomp]) else (-1) ** (breadth(decomp) % 2)\",\n \"def zernike_diff(Nstar=1,seeing=[0.9,0.,0.],npix=npix,zenith=0,filter='g', theta=0., corrector='corrector',x=None,y=None,z=None,zernike_max_order=20,regular=False):\\n hdu = genImgVallCCD(Nstar=Nstar,seeing=seeing,npix=npix,zenith=zenith,filter=filter, theta=theta, corrector=corrector,x=x,y=y,z=z,regular=regular)\\n nn = len(hdu)\\n data = []\\n colnames = ['x','y','M20','M22','M31','M33']\\n for hdui in hdu[1:]:\\n Nobj = hdui.data.shape[0]\\n M20=np.zeros(Nobj)\\n M22=np.zeros(Nobj).astype(complex)\\n M31=np.zeros(Nobj).astype(complex)\\n M33=np.zeros(Nobj).astype(complex)\\n #sigma = 1.1/0.27\\n sigma = 1.08/0.27\\n for i in range(Nobj):\\n M20[i],M22[i],M31[i],M33[i]=complexMoments(data=hdui.data[i][4:].reshape(npix,npix),sigma=sigma)\\n x=hdui.header['ccdXcen']\\n y=hdui.header['ccdYcen']\\n data.append([x,y,np.median(M20), np.median(M22), np.median(M31), np.median(M33)])\\n data=np.array(data)\\n betaAll=[]\\n betaErrAll=[]\\n R2adjAll=[]\\n beta,betaErr,R2_adj = zernikeFit(data[:,0].real,data[:,1].real,data[:,2].real,max_order=zernike_max_order)\\n betaAll.append(beta)\\n betaErrAll.append(betaErr)\\n R2adjAll.append(R2_adj)\\n for i in range(3,6):\\n beta,betaErr,R2_adj = zernikeFit(data[:,0].real,data[:,1].real,data[:,i].real,max_order=zernike_max_order)\\n betaAll.append(beta)\\n betaErrAll.append(betaErr)\\n R2adjAll.append(R2_adj)\\n beta,betaErr,R2_adj = zernikeFit(data[:,0].real,data[:,1].real,data[:,i].imag,max_order=zernike_max_order)\\n betaAll.append(beta)\\n betaErrAll.append(betaErr)\\n R2adjAll.append(R2_adj)\\n betaAll = np.array(betaAll)\\n betaErrAll = np.array(betaErrAll)\\n R2adjAll = np.array(R2adjAll)\\n return betaAll,betaErrAll, R2adjAll\",\n \"def half_gcdex(f, g):\\n lev, dom, per, F, G = f.unify(g)\\n s, h = dmp_half_gcdex(F, G, dom)\\n return per(s), per(h)\",\n \"def test_2_layer():\\r\\n # angular frequency in radians * THz\\r\\n w = 100 * nu.THz\\r\\n # Relative permittivity of metal and dielectric\\r\\n em = -4.56 + 0.12j\\r\\n ed = 1.23 + 0.01j\\r\\n ex_list = ez_list = [ed, em]\\r\\n # Relative permeabilities\\r\\n mu_list = [1,1]\\r\\n # Dictionary of input parameters\\r\\n input_params = {'w': w, 'd_list': [inf,inf], 'ex_list': ex_list,\\r\\n 'ez_list': ez_list, 'mu_list': mu_list}\\r\\n \\r\\n # Calculate the theoretical kx\\r\\n theo_kx = (w / nu.c0) * cmath.sqrt((em * ed) / (em + ed))\\r\\n if theo_kx.imag < 0:\\r\\n theo_kx *= -1\\r\\n print('Theoretical kx:',\\r\\n '(%.7g+%.7gj) rad/um' % (theo_kx.real / nu.um**-1, theo_kx.imag / nu.um**-1))\\r\\n \\r\\n # If I use the theoretical kx value, the mode should be correct and\\r\\n # all my tests should pass.\\r\\n params = deepcopy(input_params)\\r\\n params['kx'] = theo_kx\\r\\n params = find_all_params_from_kx(params)\\r\\n kzd, kzm = params['kz_list']\\r\\n # check that kz_list is correct\\r\\n assert_floats_are_equal(kzd**2, (w**2 / nu.c0**2) * ed**2 / (em + ed))\\r\\n assert_floats_are_equal(kzm**2, (w**2 / nu.c0**2) * em**2 / (em + ed))\\r\\n # check that layer_bottom_list is correct\\r\\n assert params['layer_bottom_list'][0] == -inf\\r\\n assert params['layer_bottom_list'][1] == 0\\r\\n # Check that the boundary condition matrix agrees with hand-calculation\\r\\n bc_mat = bc_matrix(params)\\r\\n # ...top-left is Ex0down / H0down\\r\\n assert_floats_are_equal(bc_mat[0,0], -kzd / (w * ed * nu.eps0))\\r\\n # ...top-right is -Ex1up / H1up\\r\\n assert_floats_are_equal(bc_mat[0,1], -kzm / (w * em * nu.eps0))\\r\\n # ...bottom-left is eps0 * Ez0down / H0down\\r\\n assert_floats_are_equal(bc_mat[1,0], ed * -theo_kx / (w * ed * nu.eps0))\\r\\n # ...bottom-right is -eps1 * Ez1up / H1up\\r\\n assert_floats_are_equal(bc_mat[1,1], -em * -theo_kx / (w * em * nu.eps0))\\r\\n # Check that one of the eigenvalues is almost zero (compared to the size\\r\\n # of the matrix elements).\\r\\n eigenvalues = np.linalg.eig(bc_mat)[0]\\r\\n assert abs(eigenvalues).min() / abs(bc_mat).max() < 1e-6\\r\\n # Check that the mode passes all tests.\\r\\n assert check_mode(params, thorough=True) is True\\r\\n # Check that I can scale the fields and it still passes all tests.\\r\\n params_scaled = rescale_fields(1.23+4.56j, params)\\r\\n assert check_mode(params_scaled, thorough=True) is True\\r\\n \\r\\n # Now try my kx-finding algorithm, to see if it finds the right value.\\r\\n kx_list = find_kx(input_params)\\r\\n print('kx_list:',\\r\\n ['(%.7g+%.7gj) rad/um' % (kx.real / nu.um**-1, kx.imag / nu.um**-1)\\r\\n for kx in kx_list])\\r\\n kx = kx_list[0]\\r\\n assert_floats_are_equal(theo_kx, kx)\\r\\n \\r\\n plot_mode(params)\\r\\n \\r\\n print('If you see this message, all the tests succeeded!!')\",\n \"def hemianopsia_soft(hemi='left',slope=5.0,dprime_fnc=dprime_basic):\\n def hemianopsia_fnc(distance):\\n if (hemi == 'left'):\\n return dprime_fnc(distance) * sigmoid(distance[0],slope)\\n elif (hemi == 'right'):\\n return dprime_fnc(distance) * sigmoid(-distance[0],slope)\\n else:\\n assert False, \\\"Unimplemented branch for the argument bling\\\"\\n return hemianopsia_fnc\",\n \"def test_hill_formula(self):\\n # make sure smiles match reference\\n molecule_smiles = create_ethanol()\\n assert molecule_smiles.hill_formula == \\\"C2H6O\\\"\\n # make sure is not order dependent\\n molecule_smiles_reverse = create_reversed_ethanol()\\n assert molecule_smiles.hill_formula == molecule_smiles_reverse.hill_formula\\n # make sure single element names are put first\\n order_mol = Molecule.from_smiles(\\\"C(Br)CB\\\")\\n assert order_mol.hill_formula == \\\"C2H6BBr\\\"\\n # test molecule with no carbon\\n no_carb_mol = Molecule.from_smiles(\\\"OS(=O)(=O)O\\\")\\n assert no_carb_mol.hill_formula == \\\"H2O4S\\\"\\n # test no carbon and hydrogen\\n br_i = Molecule.from_smiles(\\\"BrI\\\")\\n assert br_i.hill_formula == \\\"BrI\\\"\\n # make sure files and smiles match\\n molecule_file = Molecule.from_file(get_data_file_path(\\\"molecules/ethanol.sdf\\\"))\\n assert molecule_smiles.hill_formula == molecule_file.hill_formula\\n # make sure the topology molecule gives the same formula\\n from openforcefield.topology.topology import Topology, TopologyMolecule\\n\\n topology = Topology.from_molecules(molecule_smiles)\\n topmol = TopologyMolecule(molecule_smiles, topology)\\n assert molecule_smiles.hill_formula == Molecule.to_hill_formula(topmol)\\n # make sure the networkx matches\\n assert molecule_smiles.hill_formula == Molecule.to_hill_formula(\\n molecule_smiles.to_networkx()\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57660997","0.56802636","0.5665918","0.5624264","0.559748","0.55954516","0.5568438","0.5507126","0.5500543","0.5387872","0.53738797","0.534831","0.5345321","0.53414637","0.5333701","0.5332214","0.53233445","0.53016967","0.5296686","0.5290382","0.5285452","0.52381265","0.5234824","0.5226292","0.522","0.52175117","0.5210483","0.52064","0.5205207","0.519419","0.5191068","0.5178392","0.5163471","0.51458675","0.51453906","0.5144496","0.51374555","0.51339066","0.5133479","0.5116599","0.51035094","0.5101471","0.50941586","0.50930697","0.50891495","0.50846404","0.50655556","0.50628453","0.50620574","0.5059643","0.5058443","0.50520486","0.50460535","0.5037342","0.5029017","0.50126594","0.5011933","0.5008556","0.5007174","0.49954998","0.4989143","0.49869806","0.4978726","0.49771848","0.4971292","0.49688584","0.4967936","0.49635145","0.49633166","0.49604857","0.4957939","0.49571395","0.49565798","0.49529856","0.49529114","0.49424136","0.4942343","0.49376395","0.4935935","0.49339616","0.49305564","0.492473","0.491807","0.49156398","0.49126974","0.4910364","0.490546","0.49048918","0.49043804","0.49042785","0.49038616","0.4901323","0.49010888","0.49004564","0.48991325","0.48983994","0.48964095","0.48948187","0.48940328","0.48776788","0.487531"],"string":"[\n \"0.57660997\",\n \"0.56802636\",\n \"0.5665918\",\n \"0.5624264\",\n \"0.559748\",\n \"0.55954516\",\n \"0.5568438\",\n \"0.5507126\",\n \"0.5500543\",\n \"0.5387872\",\n \"0.53738797\",\n \"0.534831\",\n \"0.5345321\",\n \"0.53414637\",\n \"0.5333701\",\n \"0.5332214\",\n \"0.53233445\",\n \"0.53016967\",\n \"0.5296686\",\n \"0.5290382\",\n \"0.5285452\",\n \"0.52381265\",\n \"0.5234824\",\n \"0.5226292\",\n \"0.522\",\n \"0.52175117\",\n \"0.5210483\",\n \"0.52064\",\n \"0.5205207\",\n \"0.519419\",\n \"0.5191068\",\n \"0.5178392\",\n \"0.5163471\",\n \"0.51458675\",\n \"0.51453906\",\n \"0.5144496\",\n \"0.51374555\",\n \"0.51339066\",\n \"0.5133479\",\n \"0.5116599\",\n \"0.51035094\",\n \"0.5101471\",\n \"0.50941586\",\n \"0.50930697\",\n \"0.50891495\",\n \"0.50846404\",\n \"0.50655556\",\n \"0.50628453\",\n \"0.50620574\",\n \"0.5059643\",\n \"0.5058443\",\n \"0.50520486\",\n \"0.50460535\",\n \"0.5037342\",\n \"0.5029017\",\n \"0.50126594\",\n \"0.5011933\",\n \"0.5008556\",\n \"0.5007174\",\n \"0.49954998\",\n \"0.4989143\",\n \"0.49869806\",\n \"0.4978726\",\n \"0.49771848\",\n \"0.4971292\",\n \"0.49688584\",\n \"0.4967936\",\n \"0.49635145\",\n \"0.49633166\",\n \"0.49604857\",\n \"0.4957939\",\n \"0.49571395\",\n \"0.49565798\",\n \"0.49529856\",\n \"0.49529114\",\n \"0.49424136\",\n \"0.4942343\",\n \"0.49376395\",\n \"0.4935935\",\n \"0.49339616\",\n \"0.49305564\",\n \"0.492473\",\n \"0.491807\",\n \"0.49156398\",\n \"0.49126974\",\n \"0.4910364\",\n \"0.490546\",\n \"0.49048918\",\n \"0.49043804\",\n \"0.49042785\",\n \"0.49038616\",\n \"0.4901323\",\n \"0.49010888\",\n \"0.49004564\",\n \"0.48991325\",\n \"0.48983994\",\n \"0.48964095\",\n \"0.48948187\",\n \"0.48940328\",\n \"0.48776788\",\n \"0.487531\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":487,"cells":{"query":{"kind":"string","value":"see cmd_calls/TestGotoField.txt for command list."},"document":{"kind":"string","value":"def test_goto_field_boss_calibs(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doSlew = False\n cmdState.doHartmann = False\n cmdState.doGuider = False\n self._goto_field_boss(10, 57, 0, 0, cmdState)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_goto_field_apogee(self):\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n self._goto_feld_apogee(13, 46, 0, 0, cmdState)","def test_goto_field_apogee_no_guider(self):\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doGuider = False\n self._goto_feld_apogee(3, 11, 0, 0, cmdState)","def test_goto_field_apogee_no_slew(self):\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doSlew = False\n self._goto_feld_apogee(9, 37, 0, 0, cmdState)","def test_select_field():","def test_goto_field_apogee_bypass_gangToCart(self):\n self._prep_bypass('gangToCart', clear=True)\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n self._goto_feld_apogee(13, 44, 4, 0, cmdState)","def test_goto_field_cartridge_mismatch(self):\n\n sopTester.updateModel('guider', TestHelper.guiderState['bossLoaded'])\n\n mcpState = TestHelper.mcpState['boss_science']\n mcpState.update({'instrumentNum': [15]})\n sopTester.updateModel('mcp', mcpState)\n\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n\n masterThread.goto_field(self.cmd, cmdState, myGlobals.actorState)\n self._check_cmd(0, 14, 0, 0, finish=True, didFail=True)","def navigate_to_field(self, field):\n raise NotImplementedError()","def goto(self, item):\n command = 'goto ' + str(item)\n self.run_command(command)","def goto(self, offset):\n self._vim.command('goto {}'.format(offset))","def test_goto_field_apogee_no_slew_shutter_open(self):\n sopTester.updateModel('apogee', TestHelper.apogeeState['B_open'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doSlew = False\n self._goto_feld_apogee(10, 37, 0, 0, cmdState)","def test_goto_field_apogee_no_slew_decenter_off(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n sopTester.updateModel('guider', TestHelper.guiderState['guiderOnDecenter'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doSlew = False\n self._goto_feld_apogee(9, 37, 0, 0, cmdState)","def getLoc(field, *args):\n\tpath = cFuncs.fixPath(cmds.fileDialog2(fileMode = 2, ds=1)[0])\n\tcmds.textFieldButtonGrp(widgets[field], e=True, tx = path)","def cg_goto(self, cmd):\n label = self.makeLabel(cmd)\n self.asm(unindent(f\"\"\"\n @{label}\n 0;JMP\n \"\"\"))","def test_entities__Entity__addField__2(entities, entity, field):\n entity.addField(field)\n assert IDummy == entities[u'Field-1'].interface","def test_30_navigate(self):\n break_bar = {\"gdb\": \"break Bar\\n\", \"lldb\": \"breakpoint set --fullname Bar\\n\"}\n for backend, spec in subtests.items():\n with self.subTest(backend=backend):\n e.Ty(spec['launch'], delay=1)\n e.Ty(break_bar[backend])\n e.In(\"<esc>:wincmd k<cr>\")\n e.In(\":e src/test.cpp\\n\")\n e.In(\":10<cr>\")\n e.In(\"<f8>\")\n\n cur, breaks = e.GetSigns()\n self.assertFalse(cur)\n self.assertEqual([5, 10], breaks)\n\n # Go to another file\n e.Ty(\":e src/lib.hpp\\n\")\n cur, breaks = e.GetSigns()\n self.assertFalse(cur)\n self.assertEqual([], breaks)\n e.Ty(\":8\\n\")\n e.In(\"<f8>\")\n cur, breaks = e.GetSigns()\n self.assertFalse(cur)\n self.assertEqual([8], breaks)\n\n # Return to the first file\n e.Ty(\":e src/test.cpp\\n\")\n cur, breaks = e.GetSigns()\n self.assertFalse(cur)\n self.assertEqual([5, 10], breaks)\n\n e.In('ZZ')","def test_cmd_field():\n FNAME = 'xonsh-SESSIONID.json'\n FNAME += '.cmdfield'\n hist = History(filename=FNAME, here='yup', **HIST_TEST_KWARGS)\n # in-memory\n with mock_xonsh_env({'HISTCONTROL': set()}):\n hf = hist.append({'rtn': 1})\n yield assert_is_none, hf\n yield assert_equal, 1, hist.rtns[0]\n yield assert_equal, 1, hist.rtns[-1]\n yield assert_equal, None, hist.outs[-1]\n # slice\n yield assert_equal, [1], hist.rtns[:]\n # on disk\n hf = hist.flush()\n yield assert_is_not_none, hf\n yield assert_equal, 1, hist.rtns[0]\n yield assert_equal, 1, hist.rtns[-1]\n yield assert_equal, None, hist.outs[-1]\n os.remove(FNAME)","def cmdScrollFieldReporter(*args, annotation: Union[AnyStr, bool]=\"\", backgroundColor:\n Union[List[float, float, float], bool]=None, clear: bool=True,\n copySelection: bool=True, cutSelection: bool=True, defineTemplate:\n AnyStr=\"\", docTag: Union[AnyStr, bool]=\"\", dragCallback: Script=None,\n dropCallback: Script=None, echoAllCommands: bool=True, enable:\n bool=True, enableBackground: bool=True, enableKeyboardFocus:\n bool=True, exists: bool=True, filterSourceType: Union[AnyStr,\n bool]=\"\", fullPathName: bool=True, hasFocus: bool=True, height:\n Union[int, bool]=0, highlightColor: Union[List[float, float, float],\n bool]=None, isObscured: bool=True, lineNumbers: bool=True, manage:\n bool=True, noBackground: bool=True, numberOfPopupMenus: bool=True,\n parent: Union[AnyStr, bool]=\"\", pasteSelection: bool=True,\n popupMenuArray: bool=True, preventOverride: bool=True,\n receiveFocusCommand: Script=None, saveSelection: AnyStr=\"\",\n saveSelectionToShelf: bool=True, select: List[int, int]=None,\n selectAll: bool=True, stackTrace: bool=True, statusBarMessage:\n AnyStr=\"\", suppressErrors: bool=True, suppressInfo: bool=True,\n suppressResults: bool=True, suppressStackTrace: bool=True,\n suppressWarnings: bool=True, text: Union[AnyStr, bool]=\"\",\n textLength: bool=True, useTemplate: AnyStr=\"\", visible: bool=True,\n visibleChangeCommand: Union[Script, bool]=None, width: Union[int,\n bool]=0, q=True, query=True, e=True, edit=True,\n **kwargs)->Union[AnyStr, Any]:\n pass","def goto(n):\n n = int('{}'.format(n))\n get_controller().step_to(n)","def cmdScrollFieldExecuter(*args, annotation: Union[AnyStr, bool]=\"\", appendText: AnyStr=\"\",\n autoCloseBraces: bool=True, backgroundColor: Union[List[float, float,\n float], bool]=None, clear: bool=True, commandCompletion: bool=True,\n copySelection: bool=True, currentLine: Union[int, bool]=0,\n cutSelection: bool=True, defineTemplate: AnyStr=\"\", docTag:\n Union[AnyStr, bool]=\"\", dragCallback: Script=None, dropCallback:\n Script=None, enable: bool=True, enableBackground: bool=True,\n enableKeyboardFocus: bool=True, execute: bool=True, executeAll:\n bool=True, exists: bool=True, fileChangedCommand: Script=None,\n filename: bool=True, filterKeyPress: Union[Script, bool]=None,\n fullPathName: bool=True, hasFocus: bool=True, hasSelection:\n bool=True, height: Union[int, bool]=0, highlightColor:\n Union[List[float, float, float], bool]=None, insertText: AnyStr=\"\",\n isObscured: bool=True, load: bool=True, loadContents: AnyStr=\"\",\n loadFile: AnyStr=\"\", manage: bool=True, modificationChangedCommand:\n Script=None, modified: bool=True, noBackground: bool=True,\n numberOfLines: Union[int, bool]=0, numberOfPopupMenus: bool=True,\n objectPathCompletion: bool=True, parent: Union[AnyStr, bool]=\"\",\n pasteSelection: bool=True, popupMenuArray: bool=True,\n preventOverride: bool=True, redo: bool=True, removeStoredContents:\n AnyStr=\"\", replaceAll: List[AnyStr, AnyStr]=None, saveFile:\n AnyStr=\"\", saveSelection: AnyStr=\"\", saveSelectionToShelf: bool=True,\n searchAndSelect: bool=True, searchDown: bool=True, searchMatchCase:\n bool=True, searchString: Union[AnyStr, bool]=\"\", searchWraps:\n bool=True, select: List[int, int]=None, selectAll: bool=True,\n selectedText: bool=True, showLineNumbers: bool=True,\n showTooltipHelp: bool=True, source: bool=True, sourceType:\n Union[AnyStr, bool]=\"\", spacesPerTab: Union[int, bool]=4,\n statusBarMessage: AnyStr=\"\", storeContents: AnyStr=\"\",\n tabsForIndent: bool=True, text: Union[AnyStr, bool]=\"\", textLength:\n bool=True, undo: bool=True, useTemplate: AnyStr=\"\", visible:\n bool=True, visibleChangeCommand: Union[Script, bool]=None, width:\n Union[int, bool]=0, q=True, query=True, e=True, edit=True,\n **kwargs)->Union[AnyStr, Any]:\n pass","def _is_goto(self, words):\n if words[0] == 'goto':\n if len(words) != 2:\n raise SyntaxError(\"File line {}: Invalid number of arguments for C_GOTO command.\".format(self._file_line))\n return True\n else:\n return False","def test_back_to_home_at_start_of_line(self):\n before_b = \"\"\"\\\n if a:\n b = 'xyz'\n \"\"\"\n after_b = \"\"\"\\\n if a:\n b = 'xyz'\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"2.0\", \"2.0\"),\n after_sel=(\"2.4\", \"2.4\"),\n command_name=\"back-to-home\",\n )","def test_select_detail_returns_the_correct_menu(self):\n # make some DB entries\n dataset = self.create_mixed_test_data()\n test_log_entries = dataset['test_log_entries']\n self.menu.records = test_log_entries\n # choose an index\n selected_index = 1\n # execute the method\n user_input = str(selected_index + 1)\n with patch('builtins.input', side_effect=user_input):\n result = self.menu.select_detail()\n\n # assert that the correct menu is retured\n expected_result = self.menu.present_next_result\n\n self.assertEqual(result, expected_result)","def test_02_visit_again(self):","def test_goto_field_boss_ffs_open_fails(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n self.cmd.failOn = 'mcp ffs.open'\n self._goto_field_boss(21, 102, 1, 1, cmdState, didFail=True, finish=True)","def test_forward_char(self):\n before_b = \"\"\"\\\n first line\n line 1\n line a\n line b\n line c\n last line\n \"\"\"\n after_b = \"\"\"\\\n first line\n line 1\n line a\n line b\n line c\n last line\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"1.2\", \"1.2\"),\n after_sel=(\"1.3\", \"1.3\"),\n command_name=\"forward-char\",\n )","def test_models_edx_ui_textbook_pdf_search_navigated_next_with_valid_statement(\n statement,\n):\n assert statement.event_type == \"textbook.pdf.search.navigatednext\"\n assert statement.name == \"textbook.pdf.search.navigatednext\"","def __goto(self):\n from QScintilla.GotoDialog import GotoDialog\n \n aw = self.activeWindow()\n lines = aw.lines()\n curLine = aw.getCursorPosition()[0] + 1\n dlg = GotoDialog(lines, curLine, self.ui, None, True)\n if dlg.exec_() == QDialog.Accepted:\n aw.gotoLine(dlg.getLinenumber(), expand=True)","def test_01_visit(self):","def go_to_line(self, value=None):\n self.searcher = Toplevel()\n self.searcher.wm_title(\"Go To Line\")\n self.line_number = Entry(self.searcher)\n on_clicker = Button(self.searcher, command=self.go_to, text=\"Go\")\n self.line_number.pack()\n on_clicker.pack()","def test_goto_field_boss_guider(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n sopTester.updateModel('guider', TestHelper.guiderState['guiderOnDecenter'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doSlew = False\n cmdState.doHartmann = False\n cmdState.doCalibs = False\n cmdState.arcTime = 0\n cmdState.flatTime = 0\n self._goto_field_boss(9, 37, 0, 0, cmdState)","def test_entities__Entity__addField__1(entities, entity, field):\n entity.addField(field)\n assert ['Field-1'] == list(entities.keys())\n assert field is entities[u'Field-1']","def test_field_code(self):\n inv_search = \"subject:p\"\n spi_search = \"f f p\"\n self._compare_searches(inv_search, spi_search)","def goto(self, index):\n raise NotImplementedError","def test_make_form_field():","def test_field_keyword_and_message_passing_test():\n with temporary_dir() as output_dir:\n copyfile(\n TEST_ROBOT_OUTPUT_FILES / \"robot_with_failures.xml\",\n Path(output_dir) / \"output.xml\",\n )\n robot_importer.import_robot_test_results(FlowTaskFactory(), output_dir)\n\n test_result = models.TestResult.objects.get(method__name=\"Passing test\")\n assert test_result.message == \"Life is good, yo.\"\n assert test_result.robot_keyword is None","def test_ref_and_ptr(self):\n self.build()\n (self.target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(\n self, \"Stop here to check by ref and ptr.\",\n lldb.SBFileSpec(\"main.cpp\", False))\n # The reference should print just like the value:\n self.check_ii(\"ref\")\n\n self.expect(\"frame variable ptr\",\n substrs=[\"ptr =\", \"size=7\"])\n self.expect(\"expr ptr\",\n substrs=[\"size=7\"])","def processJumpTable(jt_ea):","def test_entities__Entity__getField__2(entity):\n assert IDummy['dummy2'] == entity.getField('dummy2')","def test_docfields(self):\n with sphinx_build('pyexample'):\n with open('_build/text/docfx_yaml/example.example.Foo.yml') as yml_file:\n data = yaml.safe_load(yml_file)\n for item in data['items']:\n if item['uid'] == 'example.example.Foo.method_okay':\n self.assertEqual(\n item['syntax']['return'],\n {'type': ['boolean'], 'description': 'That the method is okay'},\n )\n self.assertEqual(\n item['syntax']['parameters'][1]['defaultValue'],\n 'None',\n )\n self.assertEqual(\n item['syntax']['parameters'][1]['description'],\n 'The foo param',\n )\n self.assertEqual(\n item['syntax']['content'],\n 'method_okay(self, foo=None, bar=None)',\n )","def test_remove_previous_focus(self):\n target_1 = 'generic_field'\n result_1 = self.form.assign_focus_field(target_1)\n focused_1 = self.find_focus_field()\n\n target_2 = 'another_field'\n result_2 = self.form.assign_focus_field(target_2)\n focused_2 = self.find_focus_field()\n\n self.assertNotEqual(target_1, target_2)\n self.assertIn(target_1, self.form.fields)\n self.assertEqual(1, len(focused_1))\n self.assertEqual(target_1, focused_1[0])\n self.assertEqual(target_1, result_1)\n self.assertIn(target_2, self.form.fields)\n self.assertEqual(1, len(focused_2))\n self.assertEqual(target_2, focused_2[0])\n self.assertEqual(target_2, result_2)","def test_get_field(test_client):\n test_dict = {\"kfc\": {\"item\": \"chickens\"}}\n assert test_client.get_field(\"kfc.item\", doc=test_dict) == \"chickens\"","def test_issue_edit_label(self):\n pass","def step(self, action):","def jump(self):\n print(\"Inside ElfRider.jump\")","def goto(cls, quad):\n\t\treturn quad.result","def test_back_to_home_at_end_of_line(self):\n before_b = \"\"\"\\\n if a:\n b = 'xyz'\n \"\"\"\n after_b = \"\"\"\\\n if a:\n b = 'xyz'\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"2.12\", \"2.12\"),\n after_sel=(\"2.4\", \"2.4\"),\n command_name=\"back-to-home\",\n )","def test_search_table_with_field(self) -> None:\n responses.add(responses.GET, local_app.config['SEARCHSERVICE_BASE'] + SEARCH_ENDPOINT,\n json={}, status=HTTPStatus.OK)\n\n with local_app.test_client() as test:\n response = test.get('/api/search/field/'\n 'tag_names/field_val/test', query_string=dict(query_term='test',\n page_index='0'))\n self.assertEqual(response.status_code, HTTPStatus.OK)","def test(self):\n self.build()\n exe = self.getBuildArtifact(\"a.out\")\n self.runCmd(\"file \" + exe, CURRENT_EXECUTABLE_SET)\n\n lldbutil.run_to_source_breakpoint(\n self, '// Breakpoint for bitfield', lldb.SBFileSpec(\"main.c\"))\n\n self.expect(\"fr var a\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = A$'])\n self.expect(\"fr var b\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = B$'])\n self.expect(\"fr var c\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = C$'])\n self.expect(\"fr var ab\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = AB$'])\n self.expect(\"fr var ac\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = A | C$'])\n self.expect(\"fr var all\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = ALL$'])\n # Test that an enum that doesn't match the heuristic we use in\n # ClangASTContext::DumpEnumValue, gets printed as a raw integer.\n self.expect(\"fr var omega\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = 7$'])\n # Test the behavior in case have a variable of a type considered\n # 'bitfield' by the heuristic, but the value isn't actually fully\n # covered by the enumerators.\n self.expect(\"p (enum bitfield)nonsense\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = B | C | 0x10$'])\n\n # Break inside the main.\n bkpt_id = lldbutil.run_break_set_by_file_and_line(\n self, \"main.c\", self.line, num_expected_locations=1, loc_exact=True)\n self.runCmd(\"c\", RUN_SUCCEEDED)\n\n # The stop reason of the thread should be breakpoint.\n self.expect(\"thread list\", STOPPED_DUE_TO_BREAKPOINT,\n substrs=['stopped',\n 'stop reason = breakpoint'])\n\n # The breakpoint should have a hit count of 1.\n self.expect(\"breakpoint list -f\", BREAKPOINT_HIT_ONCE,\n substrs=[' resolved, hit count = 1'])\n\n # Look up information about the 'days' enum type.\n # Check for correct display.\n self.expect(\"image lookup -t days\", DATA_TYPES_DISPLAYED_CORRECTLY,\n substrs=['enum days {',\n 'Monday',\n 'Tuesday',\n 'Wednesday',\n 'Thursday',\n 'Friday',\n 'Saturday',\n 'Sunday',\n 'kNumDays',\n '}'])\n\n enum_values = ['-4',\n 'Monday',\n 'Tuesday',\n 'Wednesday',\n 'Thursday',\n 'Friday',\n 'Saturday',\n 'Sunday',\n 'kNumDays',\n '5']\n\n # Make sure a pointer to an anonymous enum type does crash LLDB and displays correctly using\n # frame variable and expression commands\n self.expect(\n 'frame variable f.op',\n DATA_TYPES_DISPLAYED_CORRECTLY,\n substrs=[\n 'ops *',\n 'f.op'],\n patterns=['0x0+$'])\n self.expect(\n 'frame variable *f.op',\n DATA_TYPES_DISPLAYED_CORRECTLY,\n substrs=[\n 'ops',\n '*f.op',\n '<parent is NULL>'])\n self.expect(\n 'expr f.op',\n DATA_TYPES_DISPLAYED_CORRECTLY,\n substrs=[\n 'ops *',\n '$'],\n patterns=['0x0+$'])\n self.expect(\n 'expr *f.op',\n DATA_TYPES_DISPLAYED_CORRECTLY,\n substrs=['error:'],\n error=True)\n\n bkpt = self.target().FindBreakpointByID(bkpt_id)\n for enum_value in enum_values:\n self.expect(\n \"frame variable day\",\n 'check for valid enumeration value',\n substrs=[enum_value])\n lldbutil.continue_to_breakpoint(self.process(), bkpt)","def move_to_target():\n keyboard.send('f')","def write_goto(output_file, command, label, curr_function):\n if command == \"if-goto\":\n output_file.write(\"@SP\" + \"\\n\" +\n \"AM = M - 1\" + \"\\n\" +\n \"D = M\" + \"\\n\" +\n \"@\" + curr_function[0] + \"$\" + label + \"\\n\" +\n \"D; JNE\" + \"\\n\")\n else:\n output_file.write(\"@\" + curr_function[0] + \"$\" + label + \"\\n\" +\n \"0; JMP\" + \"\\n\")","def test_text_field():","def test_get_explore_fields_gets_fields(\n fc: fetcher.Fetcher, test_model, test_explores_stats\n):\n test_explore = test_explores_stats[0]\n explore = fc.get_explores(model=test_model[\"name\"], explore=test_explore[\"name\"])\n assert isinstance(explore, list)\n explore = explore[0]\n assert isinstance(explore, models.LookmlModelExplore)\n assert explore.model_name == test_model[\"name\"]\n assert explore.name == test_explore[\"name\"]\n fields = fc.get_explore_fields(explore)\n assert isinstance(fields, list)\n assert fields == test_explore[\"all_fields\"]","def __le__(self, *args):\n return _ida_hexrays.cgoto_t___le__(self, *args)","def test_select_detail_displays_the_correct_record(self):\n # make some DB entries\n dataset = self.create_mixed_test_data()\n test_log_entries = dataset['test_log_entries']\n self.menu.records = test_log_entries\n # choose an index\n selected_index = 1\n # execute the method\n user_input = str(selected_index + 1)\n with patch('builtins.input', side_effect=user_input):\n self.menu.select_detail()\n\n # assert that the db entry that current_record looks up is the same\n # as the one chosen.\n self.assertEqual(test_log_entries[selected_index],\n self.menu.records[self.menu.current_record])","def navigate_to_field(self, field):\n if self.field:\n raise AssertionError(u'Already at a field, cannot nest fields: {}'.format(self))\n return Location(self.query_path, field=field, visit_counter=self.visit_counter)","def go_to(self, value=None):\n self.go_to_this_line = self.line_number.get()\n self.my_text.mark_set(INSERT, str(float(self.go_to_this_line)))\n self.current_area()\n self.my_text.see(INSERT)\n self.searcher.destroy()","def test_entities__Entity__getField__1(entity):\n with pytest.raises(KeyError):\n entity.getField('asdf')","def test_first_page_passes(self):\n\n self.page.open_site(PageLocators.PREVIOUS_LINK)\n self.page.fill_all_fields()\n self.page.send_the_data()","def test_hidden_field():","def TestOneStep(self):\n pass","def _guider_start(self, nCall, nInfo, nWarn, nErr, finish=False, didFail=False):\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n result = masterThread.guider_start(self.cmd, cmdState, myGlobals.actorState, 'gotoField')\n self.assertEqual(result, not didFail)\n self._check_cmd(nCall, nInfo, nWarn, nErr, finish, didFail=didFail)","def jump(act_line: int, offset: str):\n return act_line + int(offset)","def getfield(value, arg):\n #import pdb; pdb.set_trace()\n if hasattr(value, \"fields\"):\n fields = getattr(value, \"fields\")\n if str(arg) in fields:\n return str(fields[str(arg)])","def handle_next_breakpoint(self, bit):\n self.check_required()\n self.options.shift_breakpoint()\n self.arguments = self.options.get_arguments()\n self.current_argument = self.arguments.pop(0)","def __ge__(self, *args):\n return _ida_hexrays.cgoto_t___ge__(self, *args)","def test_focus(self, name=None):\n focus_func = getattr(self.form, 'assign_focus_field', None)\n fields = self.get_current_fields()\n if focus_func and issubclass(self.__class__, FocusMixIn):\n name = name or getattr(self.form, 'named_focus', None)\n expected = focus_func(name, fields)\n else:\n expected = 'username' if 'username' in fields else None\n expected = name or expected or None\n if not expected:\n self.assertTrue(True)\n return\n focus_list = self.find_focus_field()\n self.assertEqual(1, len(focus_list))\n self.assertEqual(expected, focus_list[0])","def test_goto_field_boss_flat_on_fails(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n self.cmd.failOn = 'mcp ff.on'\n self._goto_field_boss(16, 71, 0, 1, cmdState, didFail=True, finish=True)","def scrollField(*args, annotation: Union[AnyStr, bool]=\"\", backgroundColor: Union[List[float,\n float, float], bool]=None, changeCommand: Script=None, clear: bool=True,\n command: AnyStr=\"\", defineTemplate: AnyStr=\"\", docTag: Union[AnyStr, bool]=\"\",\n dragCallback: Script=None, dropCallback: Script=None, editable: bool=True,\n enable: bool=True, enableBackground: bool=True, enableKeyboardFocus: bool=True,\n enterCommand: Script=None, exists: bool=True, font: Union[AnyStr, bool]=\"\",\n fontPointSize: Union[int, bool]=0, fullPathName: bool=True, height: Union[int,\n bool]=0, highlightColor: Union[List[float, float, float], bool]=None,\n insertText: AnyStr=\"\", insertionPosition: Union[int, bool]=0, isObscured:\n bool=True, keyPressCommand: Script=None, manage: bool=True, noBackground:\n bool=True, numberOfLines: Union[int, bool]=0, numberOfPopupMenus: bool=True,\n parent: Union[AnyStr, bool]=\"\", popupMenuArray: bool=True, preventOverride:\n bool=True, qtFont: Union[AnyStr, bool]=\"\", selection: bool=True,\n statusBarMessage: AnyStr=\"\", text: Union[AnyStr, bool]=\"\", useTemplate:\n AnyStr=\"\", visible: bool=True, visibleChangeCommand: Union[Script, bool]=None,\n width: Union[int, bool]=0, wordWrap: bool=True, q=True, query=True, e=True,\n edit=True, **kwargs)->Union[AnyStr, Any]:\n pass","def other_search(self):\n test = self.ask_zoekarg.text()\n if test:\n self.parent().search_arg = test\n self.parent().do_select()","def test(self):\n # 0x13 is nop\n self.gdb.command(\"p *((int*) 0x%x)=0x13\" % self.target.ram)\n self.gdb.command(\"p *((int*) 0x%x)=0x13\" % (self.target.ram + 4))\n self.gdb.command(\"p *((int*) 0x%x)=0x13\" % (self.target.ram + 8))\n self.gdb.p(\"$pc=0x%x\" % self.target.ram)\n self.gdb.stepi()\n assertEqual((self.target.ram + 4), self.gdb.p(\"$pc\"))\n self.gdb.stepi()\n assertEqual((self.target.ram + 8), self.gdb.p(\"$pc\"))","def get_jump(self):\n return self.jump","def test_goto_definition_at_zero(Script):\n assert Script(\"a\").infer(1, 1) == []\n s = Script(\"str\").infer(1, 1)\n assert len(s) == 1\n assert list(s)[0].description == 'class str'\n assert Script(\"\").infer(1, 0) == []","def goto(action, value, error_handle):\n print_info(\"failed: failure action= goto %s\" % value)\n error_handle['action'] = 'GOTO'\n error_handle['value'] = value\n return error_handle","def test_case_main(self, case_results):\n\n log_test_case(self.name, 'drag up and down')\n drag_by_param(95, 50, 95, 85, 1)\n drag_by_param(95, 85, 95, 50, 1)\n sleep(1)\n drag_by_param(95, 50, 95, 85, 1)\n drag_by_param(95, 85, 95, 50, 1)\n sleep(1)\n self.ime = IME()\n click_imageview_by_id('menu_search')\n #entertext_edittext_on_focused('Mi')\n #clear_edittext_by_index(0)\n '''\n PRIVATE_del = ['del']\n self.ime.IME_input(1, PRIVATE_del)\n self.ime.IME_input(1, PRIVATE_del)\n self.ime.IME_input(1, PRIVATE_del)\n '''\n\n self.ime.IME_input_english(1, 'tes')\n sleep(2)\n if search_text(SC.PRIVATE_CONTACT_NAME):\n log_test_case(self.name, 'search name ok...')\n click_textview_by_text(SC.PRIVATE_CONTACT_NAME)\n #click_in_list_by_index(1)\n else:\n log_test_case(self.name, 'search failed...')\n return\n\n self.call_from_contact()\n\n #send sms to mike\n click_textview_by_id('secondary_action_button')\n self.ime.IME_input_english(1, 'send')\n #click_imageview_by_desc(\"send\")\n click_button_by_id('send_button_sms')\n sleep(3)\n goback()\n\n #click_textview_by_text('binz')\n # show a moment\n sleep(1)\n\n #send EMAIL\n if search_text('jubao@qunar.com'):\n click_textview_by_text('jubao@qunar.com')\n\n #\n if search_text('Complete action using'):\n click_textview_by_text('Email')\n click_button_by_id('button_always')\n entertext_edittext_on_focused('email title')\n\n click_imageview_by_id(\"send\")\n\n else:\n goback()\n\n # go address map\n scroll_to_bottom()\n if search_text('ADDRESS'):\n click_textview_by_text('pudong,shanghai,china')\n else:\n goback()","def test_get_goal(self):\n pass","def test_focus_on_limited_fields(self):\n original_named_focus = self.form.named_focus\n original_fields_focus = self.form.fields_focus\n original_given_focus = self.form.given_focus\n original_fields = self.form.fields\n self.form.named_focus = None\n self.form.given_focus = None\n allowed = [name for name, field in self.form.fields.items()\n if not field.disabled and not isinstance(field.widget, (HiddenInput, MultipleHiddenInput))]\n self.assertGreater(len(allowed), 1)\n fields_focus = allowed[1:]\n self.form.fields_focus = fields_focus\n expected = fields_focus[0]\n actual = self.form.assign_focus_field(None, fields=self.form.fields_focus)\n\n self.assertEqual(expected, actual)\n self.assertEqual(self.form.given_focus, actual)\n\n self.form.name_focus = original_named_focus\n self.form.fields_focus = original_fields_focus\n self.form.given_focus = original_given_focus\n self.form.fields = original_fields","def step(self, action):\n pass","def step(self, action):\n pass","def fooFunction(item_index):\n print(\"item %d pressed\" % (item_index))","def _is_ifgoto(self, words):\n if words[0] == 'if-goto':\n if len(words) != 2:\n raise SyntaxError(\"File line {}: Invalid number of arguments for C_IFGOTO command.\".format(self._file_line))\n return True\n else:\n return False","def help_select(self):\n print(SELECT)","def test_010(self):\n caller = self.get_caller([SingleMethod])\n self.assertEqual(\"I have very little to say.\", caller())","def test_parse_fields(pawprint_default_tracker_db):\n\n tracker = pawprint_default_tracker_db\n\n # SELECT * FROM table\n args = ()\n assert tracker._parse_fields(*args) == \"*\"\n\n # SELECT event FROM table\n args = (\"event\",)\n assert tracker._parse_fields(*args) == \"event\"\n\n # SELECT user_id, timestamp FROM table\n args = (\"user_id\", \"timestamp\")\n assert tracker._parse_fields(*args) == \"user_id, timestamp\"\n\n # SELECT metadata #>> '{a, b}' FROM table\n args = (\"metadata__a__b\",)\n assert tracker._parse_fields(*args) == \"metadata #> '{a, b}' AS json_field\"","def _examineOrSelect(self):\n d = getattr(self.client, self.method)('foobox')\n self.assertEqual(\n self.transport.value(), b'0001 ' + self.command + b' foobox\\r\\n')\n return d","def do_step(self) -> None:","def write_goto_in_func(self, label):\n label = self.label_by_scope(label)\n self.write(\"@\" + label + \"\\n0;JMP\\n\")\n # @label\n # 0;JMP","def step():\n \n step = models.Step(action=u\"goto\", target=u\"http://www.joesfunerals.com\")","def test_03_visit_special(self):","def test_int_field():","def jumpto(self, item, offset):\n try:\n self.ret = idc.jumpto(offset)\n except:\n self.ret = False\n\n return self.ret","def click_header_field_link(self, label):\n locator = lex_locators[\"record\"][\"header\"][\"field_value_link\"].format(label)\n self._jsclick(locator)","def test_code010(self, *test_code_args, **test_code_kwargs):\n print(\"This is test_code010 from TestDefinition #\", self.ID, \", test case #\", self.test_case_ID, sep='')","def write_go_to(self, label):\n self._write_line('goto ' + label)","def test_goto_field_boss_hartmann(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doSlew = False\n cmdState.doCalibs = False\n cmdState.arcTime = 0\n cmdState.flatTime = 0\n cmdState.doGuider = False\n self._goto_field_boss(5, 29, 0, 0, cmdState)","def test_get_genome_7(self):\n self.tkt1.data_add = set([\"retrieve_record\"])\n gnm = tickets.get_genome(self.tkt1, gnm_type=\"add\")\n with self.subTest():\n self.assertEqual(gnm.host_genus, \"\")\n with self.subTest():\n self.assertEqual(gnm.retrieve_record, 1)","def test_goto_field_boss_slew(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doGuider = False\n cmdState.doHartmann = False\n cmdState.doCalibs = False\n cmdState.arcTime = 0\n cmdState.flatTime = 0\n self._goto_field_boss(3, 26, 0, 0, cmdState)","def test_forward_char_extend_selection(self):\n before_b = \"\"\"\\\n first line\n line 1\n line a\n line b\n line c\n last line\n \"\"\"\n after_b = \"\"\"\\\n first line\n line 1\n line a\n line b\n line c\n last line\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"1.1\", \"1.1\"),\n after_sel=(\"1.1\", \"1.2\"),\n command_name=\"forward-char-extend-selection\",\n )","def _MocaCtlGetField(self, outfcn, field):\n\n m_re = re.compile(field + r'\\s*:\\s+(\\S+)')\n for line in outfcn():\n mr = m_re.search(line)\n if mr is not None:\n return mr.group(1)\n return None","def probe_at_single_point(self, field, *args, **kwargs):\n raise NotImplementedError","def test(self):\n # -- Test --\n\n # (1)\n\n # (2)\n\n # (3)\n\n # (4)\n # -- Test --"],"string":"[\n \"def test_goto_field_apogee(self):\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n self._goto_feld_apogee(13, 46, 0, 0, cmdState)\",\n \"def test_goto_field_apogee_no_guider(self):\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n cmdState.doGuider = False\\n self._goto_feld_apogee(3, 11, 0, 0, cmdState)\",\n \"def test_goto_field_apogee_no_slew(self):\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n cmdState.doSlew = False\\n self._goto_feld_apogee(9, 37, 0, 0, cmdState)\",\n \"def test_select_field():\",\n \"def test_goto_field_apogee_bypass_gangToCart(self):\\n self._prep_bypass('gangToCart', clear=True)\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n self._goto_feld_apogee(13, 44, 4, 0, cmdState)\",\n \"def test_goto_field_cartridge_mismatch(self):\\n\\n sopTester.updateModel('guider', TestHelper.guiderState['bossLoaded'])\\n\\n mcpState = TestHelper.mcpState['boss_science']\\n mcpState.update({'instrumentNum': [15]})\\n sopTester.updateModel('mcp', mcpState)\\n\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n\\n masterThread.goto_field(self.cmd, cmdState, myGlobals.actorState)\\n self._check_cmd(0, 14, 0, 0, finish=True, didFail=True)\",\n \"def navigate_to_field(self, field):\\n raise NotImplementedError()\",\n \"def goto(self, item):\\n command = 'goto ' + str(item)\\n self.run_command(command)\",\n \"def goto(self, offset):\\n self._vim.command('goto {}'.format(offset))\",\n \"def test_goto_field_apogee_no_slew_shutter_open(self):\\n sopTester.updateModel('apogee', TestHelper.apogeeState['B_open'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n cmdState.doSlew = False\\n self._goto_feld_apogee(10, 37, 0, 0, cmdState)\",\n \"def test_goto_field_apogee_no_slew_decenter_off(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\\n sopTester.updateModel('guider', TestHelper.guiderState['guiderOnDecenter'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n cmdState.doSlew = False\\n self._goto_feld_apogee(9, 37, 0, 0, cmdState)\",\n \"def getLoc(field, *args):\\n\\tpath = cFuncs.fixPath(cmds.fileDialog2(fileMode = 2, ds=1)[0])\\n\\tcmds.textFieldButtonGrp(widgets[field], e=True, tx = path)\",\n \"def cg_goto(self, cmd):\\n label = self.makeLabel(cmd)\\n self.asm(unindent(f\\\"\\\"\\\"\\n @{label}\\n 0;JMP\\n \\\"\\\"\\\"))\",\n \"def test_entities__Entity__addField__2(entities, entity, field):\\n entity.addField(field)\\n assert IDummy == entities[u'Field-1'].interface\",\n \"def test_30_navigate(self):\\n break_bar = {\\\"gdb\\\": \\\"break Bar\\\\n\\\", \\\"lldb\\\": \\\"breakpoint set --fullname Bar\\\\n\\\"}\\n for backend, spec in subtests.items():\\n with self.subTest(backend=backend):\\n e.Ty(spec['launch'], delay=1)\\n e.Ty(break_bar[backend])\\n e.In(\\\"<esc>:wincmd k<cr>\\\")\\n e.In(\\\":e src/test.cpp\\\\n\\\")\\n e.In(\\\":10<cr>\\\")\\n e.In(\\\"<f8>\\\")\\n\\n cur, breaks = e.GetSigns()\\n self.assertFalse(cur)\\n self.assertEqual([5, 10], breaks)\\n\\n # Go to another file\\n e.Ty(\\\":e src/lib.hpp\\\\n\\\")\\n cur, breaks = e.GetSigns()\\n self.assertFalse(cur)\\n self.assertEqual([], breaks)\\n e.Ty(\\\":8\\\\n\\\")\\n e.In(\\\"<f8>\\\")\\n cur, breaks = e.GetSigns()\\n self.assertFalse(cur)\\n self.assertEqual([8], breaks)\\n\\n # Return to the first file\\n e.Ty(\\\":e src/test.cpp\\\\n\\\")\\n cur, breaks = e.GetSigns()\\n self.assertFalse(cur)\\n self.assertEqual([5, 10], breaks)\\n\\n e.In('ZZ')\",\n \"def test_cmd_field():\\n FNAME = 'xonsh-SESSIONID.json'\\n FNAME += '.cmdfield'\\n hist = History(filename=FNAME, here='yup', **HIST_TEST_KWARGS)\\n # in-memory\\n with mock_xonsh_env({'HISTCONTROL': set()}):\\n hf = hist.append({'rtn': 1})\\n yield assert_is_none, hf\\n yield assert_equal, 1, hist.rtns[0]\\n yield assert_equal, 1, hist.rtns[-1]\\n yield assert_equal, None, hist.outs[-1]\\n # slice\\n yield assert_equal, [1], hist.rtns[:]\\n # on disk\\n hf = hist.flush()\\n yield assert_is_not_none, hf\\n yield assert_equal, 1, hist.rtns[0]\\n yield assert_equal, 1, hist.rtns[-1]\\n yield assert_equal, None, hist.outs[-1]\\n os.remove(FNAME)\",\n \"def cmdScrollFieldReporter(*args, annotation: Union[AnyStr, bool]=\\\"\\\", backgroundColor:\\n Union[List[float, float, float], bool]=None, clear: bool=True,\\n copySelection: bool=True, cutSelection: bool=True, defineTemplate:\\n AnyStr=\\\"\\\", docTag: Union[AnyStr, bool]=\\\"\\\", dragCallback: Script=None,\\n dropCallback: Script=None, echoAllCommands: bool=True, enable:\\n bool=True, enableBackground: bool=True, enableKeyboardFocus:\\n bool=True, exists: bool=True, filterSourceType: Union[AnyStr,\\n bool]=\\\"\\\", fullPathName: bool=True, hasFocus: bool=True, height:\\n Union[int, bool]=0, highlightColor: Union[List[float, float, float],\\n bool]=None, isObscured: bool=True, lineNumbers: bool=True, manage:\\n bool=True, noBackground: bool=True, numberOfPopupMenus: bool=True,\\n parent: Union[AnyStr, bool]=\\\"\\\", pasteSelection: bool=True,\\n popupMenuArray: bool=True, preventOverride: bool=True,\\n receiveFocusCommand: Script=None, saveSelection: AnyStr=\\\"\\\",\\n saveSelectionToShelf: bool=True, select: List[int, int]=None,\\n selectAll: bool=True, stackTrace: bool=True, statusBarMessage:\\n AnyStr=\\\"\\\", suppressErrors: bool=True, suppressInfo: bool=True,\\n suppressResults: bool=True, suppressStackTrace: bool=True,\\n suppressWarnings: bool=True, text: Union[AnyStr, bool]=\\\"\\\",\\n textLength: bool=True, useTemplate: AnyStr=\\\"\\\", visible: bool=True,\\n visibleChangeCommand: Union[Script, bool]=None, width: Union[int,\\n bool]=0, q=True, query=True, e=True, edit=True,\\n **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def goto(n):\\n n = int('{}'.format(n))\\n get_controller().step_to(n)\",\n \"def cmdScrollFieldExecuter(*args, annotation: Union[AnyStr, bool]=\\\"\\\", appendText: AnyStr=\\\"\\\",\\n autoCloseBraces: bool=True, backgroundColor: Union[List[float, float,\\n float], bool]=None, clear: bool=True, commandCompletion: bool=True,\\n copySelection: bool=True, currentLine: Union[int, bool]=0,\\n cutSelection: bool=True, defineTemplate: AnyStr=\\\"\\\", docTag:\\n Union[AnyStr, bool]=\\\"\\\", dragCallback: Script=None, dropCallback:\\n Script=None, enable: bool=True, enableBackground: bool=True,\\n enableKeyboardFocus: bool=True, execute: bool=True, executeAll:\\n bool=True, exists: bool=True, fileChangedCommand: Script=None,\\n filename: bool=True, filterKeyPress: Union[Script, bool]=None,\\n fullPathName: bool=True, hasFocus: bool=True, hasSelection:\\n bool=True, height: Union[int, bool]=0, highlightColor:\\n Union[List[float, float, float], bool]=None, insertText: AnyStr=\\\"\\\",\\n isObscured: bool=True, load: bool=True, loadContents: AnyStr=\\\"\\\",\\n loadFile: AnyStr=\\\"\\\", manage: bool=True, modificationChangedCommand:\\n Script=None, modified: bool=True, noBackground: bool=True,\\n numberOfLines: Union[int, bool]=0, numberOfPopupMenus: bool=True,\\n objectPathCompletion: bool=True, parent: Union[AnyStr, bool]=\\\"\\\",\\n pasteSelection: bool=True, popupMenuArray: bool=True,\\n preventOverride: bool=True, redo: bool=True, removeStoredContents:\\n AnyStr=\\\"\\\", replaceAll: List[AnyStr, AnyStr]=None, saveFile:\\n AnyStr=\\\"\\\", saveSelection: AnyStr=\\\"\\\", saveSelectionToShelf: bool=True,\\n searchAndSelect: bool=True, searchDown: bool=True, searchMatchCase:\\n bool=True, searchString: Union[AnyStr, bool]=\\\"\\\", searchWraps:\\n bool=True, select: List[int, int]=None, selectAll: bool=True,\\n selectedText: bool=True, showLineNumbers: bool=True,\\n showTooltipHelp: bool=True, source: bool=True, sourceType:\\n Union[AnyStr, bool]=\\\"\\\", spacesPerTab: Union[int, bool]=4,\\n statusBarMessage: AnyStr=\\\"\\\", storeContents: AnyStr=\\\"\\\",\\n tabsForIndent: bool=True, text: Union[AnyStr, bool]=\\\"\\\", textLength:\\n bool=True, undo: bool=True, useTemplate: AnyStr=\\\"\\\", visible:\\n bool=True, visibleChangeCommand: Union[Script, bool]=None, width:\\n Union[int, bool]=0, q=True, query=True, e=True, edit=True,\\n **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def _is_goto(self, words):\\n if words[0] == 'goto':\\n if len(words) != 2:\\n raise SyntaxError(\\\"File line {}: Invalid number of arguments for C_GOTO command.\\\".format(self._file_line))\\n return True\\n else:\\n return False\",\n \"def test_back_to_home_at_start_of_line(self):\\n before_b = \\\"\\\"\\\"\\\\\\n if a:\\n b = 'xyz'\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n if a:\\n b = 'xyz'\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"2.0\\\", \\\"2.0\\\"),\\n after_sel=(\\\"2.4\\\", \\\"2.4\\\"),\\n command_name=\\\"back-to-home\\\",\\n )\",\n \"def test_select_detail_returns_the_correct_menu(self):\\n # make some DB entries\\n dataset = self.create_mixed_test_data()\\n test_log_entries = dataset['test_log_entries']\\n self.menu.records = test_log_entries\\n # choose an index\\n selected_index = 1\\n # execute the method\\n user_input = str(selected_index + 1)\\n with patch('builtins.input', side_effect=user_input):\\n result = self.menu.select_detail()\\n\\n # assert that the correct menu is retured\\n expected_result = self.menu.present_next_result\\n\\n self.assertEqual(result, expected_result)\",\n \"def test_02_visit_again(self):\",\n \"def test_goto_field_boss_ffs_open_fails(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n self.cmd.failOn = 'mcp ffs.open'\\n self._goto_field_boss(21, 102, 1, 1, cmdState, didFail=True, finish=True)\",\n \"def test_forward_char(self):\\n before_b = \\\"\\\"\\\"\\\\\\n first line\\n line 1\\n line a\\n line b\\n line c\\n last line\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n first line\\n line 1\\n line a\\n line b\\n line c\\n last line\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.2\\\", \\\"1.2\\\"),\\n after_sel=(\\\"1.3\\\", \\\"1.3\\\"),\\n command_name=\\\"forward-char\\\",\\n )\",\n \"def test_models_edx_ui_textbook_pdf_search_navigated_next_with_valid_statement(\\n statement,\\n):\\n assert statement.event_type == \\\"textbook.pdf.search.navigatednext\\\"\\n assert statement.name == \\\"textbook.pdf.search.navigatednext\\\"\",\n \"def __goto(self):\\n from QScintilla.GotoDialog import GotoDialog\\n \\n aw = self.activeWindow()\\n lines = aw.lines()\\n curLine = aw.getCursorPosition()[0] + 1\\n dlg = GotoDialog(lines, curLine, self.ui, None, True)\\n if dlg.exec_() == QDialog.Accepted:\\n aw.gotoLine(dlg.getLinenumber(), expand=True)\",\n \"def test_01_visit(self):\",\n \"def go_to_line(self, value=None):\\n self.searcher = Toplevel()\\n self.searcher.wm_title(\\\"Go To Line\\\")\\n self.line_number = Entry(self.searcher)\\n on_clicker = Button(self.searcher, command=self.go_to, text=\\\"Go\\\")\\n self.line_number.pack()\\n on_clicker.pack()\",\n \"def test_goto_field_boss_guider(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\\n sopTester.updateModel('guider', TestHelper.guiderState['guiderOnDecenter'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n cmdState.doSlew = False\\n cmdState.doHartmann = False\\n cmdState.doCalibs = False\\n cmdState.arcTime = 0\\n cmdState.flatTime = 0\\n self._goto_field_boss(9, 37, 0, 0, cmdState)\",\n \"def test_entities__Entity__addField__1(entities, entity, field):\\n entity.addField(field)\\n assert ['Field-1'] == list(entities.keys())\\n assert field is entities[u'Field-1']\",\n \"def test_field_code(self):\\n inv_search = \\\"subject:p\\\"\\n spi_search = \\\"f f p\\\"\\n self._compare_searches(inv_search, spi_search)\",\n \"def goto(self, index):\\n raise NotImplementedError\",\n \"def test_make_form_field():\",\n \"def test_field_keyword_and_message_passing_test():\\n with temporary_dir() as output_dir:\\n copyfile(\\n TEST_ROBOT_OUTPUT_FILES / \\\"robot_with_failures.xml\\\",\\n Path(output_dir) / \\\"output.xml\\\",\\n )\\n robot_importer.import_robot_test_results(FlowTaskFactory(), output_dir)\\n\\n test_result = models.TestResult.objects.get(method__name=\\\"Passing test\\\")\\n assert test_result.message == \\\"Life is good, yo.\\\"\\n assert test_result.robot_keyword is None\",\n \"def test_ref_and_ptr(self):\\n self.build()\\n (self.target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(\\n self, \\\"Stop here to check by ref and ptr.\\\",\\n lldb.SBFileSpec(\\\"main.cpp\\\", False))\\n # The reference should print just like the value:\\n self.check_ii(\\\"ref\\\")\\n\\n self.expect(\\\"frame variable ptr\\\",\\n substrs=[\\\"ptr =\\\", \\\"size=7\\\"])\\n self.expect(\\\"expr ptr\\\",\\n substrs=[\\\"size=7\\\"])\",\n \"def processJumpTable(jt_ea):\",\n \"def test_entities__Entity__getField__2(entity):\\n assert IDummy['dummy2'] == entity.getField('dummy2')\",\n \"def test_docfields(self):\\n with sphinx_build('pyexample'):\\n with open('_build/text/docfx_yaml/example.example.Foo.yml') as yml_file:\\n data = yaml.safe_load(yml_file)\\n for item in data['items']:\\n if item['uid'] == 'example.example.Foo.method_okay':\\n self.assertEqual(\\n item['syntax']['return'],\\n {'type': ['boolean'], 'description': 'That the method is okay'},\\n )\\n self.assertEqual(\\n item['syntax']['parameters'][1]['defaultValue'],\\n 'None',\\n )\\n self.assertEqual(\\n item['syntax']['parameters'][1]['description'],\\n 'The foo param',\\n )\\n self.assertEqual(\\n item['syntax']['content'],\\n 'method_okay(self, foo=None, bar=None)',\\n )\",\n \"def test_remove_previous_focus(self):\\n target_1 = 'generic_field'\\n result_1 = self.form.assign_focus_field(target_1)\\n focused_1 = self.find_focus_field()\\n\\n target_2 = 'another_field'\\n result_2 = self.form.assign_focus_field(target_2)\\n focused_2 = self.find_focus_field()\\n\\n self.assertNotEqual(target_1, target_2)\\n self.assertIn(target_1, self.form.fields)\\n self.assertEqual(1, len(focused_1))\\n self.assertEqual(target_1, focused_1[0])\\n self.assertEqual(target_1, result_1)\\n self.assertIn(target_2, self.form.fields)\\n self.assertEqual(1, len(focused_2))\\n self.assertEqual(target_2, focused_2[0])\\n self.assertEqual(target_2, result_2)\",\n \"def test_get_field(test_client):\\n test_dict = {\\\"kfc\\\": {\\\"item\\\": \\\"chickens\\\"}}\\n assert test_client.get_field(\\\"kfc.item\\\", doc=test_dict) == \\\"chickens\\\"\",\n \"def test_issue_edit_label(self):\\n pass\",\n \"def step(self, action):\",\n \"def jump(self):\\n print(\\\"Inside ElfRider.jump\\\")\",\n \"def goto(cls, quad):\\n\\t\\treturn quad.result\",\n \"def test_back_to_home_at_end_of_line(self):\\n before_b = \\\"\\\"\\\"\\\\\\n if a:\\n b = 'xyz'\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n if a:\\n b = 'xyz'\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"2.12\\\", \\\"2.12\\\"),\\n after_sel=(\\\"2.4\\\", \\\"2.4\\\"),\\n command_name=\\\"back-to-home\\\",\\n )\",\n \"def test_search_table_with_field(self) -> None:\\n responses.add(responses.GET, local_app.config['SEARCHSERVICE_BASE'] + SEARCH_ENDPOINT,\\n json={}, status=HTTPStatus.OK)\\n\\n with local_app.test_client() as test:\\n response = test.get('/api/search/field/'\\n 'tag_names/field_val/test', query_string=dict(query_term='test',\\n page_index='0'))\\n self.assertEqual(response.status_code, HTTPStatus.OK)\",\n \"def test(self):\\n self.build()\\n exe = self.getBuildArtifact(\\\"a.out\\\")\\n self.runCmd(\\\"file \\\" + exe, CURRENT_EXECUTABLE_SET)\\n\\n lldbutil.run_to_source_breakpoint(\\n self, '// Breakpoint for bitfield', lldb.SBFileSpec(\\\"main.c\\\"))\\n\\n self.expect(\\\"fr var a\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = A$'])\\n self.expect(\\\"fr var b\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = B$'])\\n self.expect(\\\"fr var c\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = C$'])\\n self.expect(\\\"fr var ab\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = AB$'])\\n self.expect(\\\"fr var ac\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = A | C$'])\\n self.expect(\\\"fr var all\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = ALL$'])\\n # Test that an enum that doesn't match the heuristic we use in\\n # ClangASTContext::DumpEnumValue, gets printed as a raw integer.\\n self.expect(\\\"fr var omega\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = 7$'])\\n # Test the behavior in case have a variable of a type considered\\n # 'bitfield' by the heuristic, but the value isn't actually fully\\n # covered by the enumerators.\\n self.expect(\\\"p (enum bitfield)nonsense\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = B | C | 0x10$'])\\n\\n # Break inside the main.\\n bkpt_id = lldbutil.run_break_set_by_file_and_line(\\n self, \\\"main.c\\\", self.line, num_expected_locations=1, loc_exact=True)\\n self.runCmd(\\\"c\\\", RUN_SUCCEEDED)\\n\\n # The stop reason of the thread should be breakpoint.\\n self.expect(\\\"thread list\\\", STOPPED_DUE_TO_BREAKPOINT,\\n substrs=['stopped',\\n 'stop reason = breakpoint'])\\n\\n # The breakpoint should have a hit count of 1.\\n self.expect(\\\"breakpoint list -f\\\", BREAKPOINT_HIT_ONCE,\\n substrs=[' resolved, hit count = 1'])\\n\\n # Look up information about the 'days' enum type.\\n # Check for correct display.\\n self.expect(\\\"image lookup -t days\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n substrs=['enum days {',\\n 'Monday',\\n 'Tuesday',\\n 'Wednesday',\\n 'Thursday',\\n 'Friday',\\n 'Saturday',\\n 'Sunday',\\n 'kNumDays',\\n '}'])\\n\\n enum_values = ['-4',\\n 'Monday',\\n 'Tuesday',\\n 'Wednesday',\\n 'Thursday',\\n 'Friday',\\n 'Saturday',\\n 'Sunday',\\n 'kNumDays',\\n '5']\\n\\n # Make sure a pointer to an anonymous enum type does crash LLDB and displays correctly using\\n # frame variable and expression commands\\n self.expect(\\n 'frame variable f.op',\\n DATA_TYPES_DISPLAYED_CORRECTLY,\\n substrs=[\\n 'ops *',\\n 'f.op'],\\n patterns=['0x0+$'])\\n self.expect(\\n 'frame variable *f.op',\\n DATA_TYPES_DISPLAYED_CORRECTLY,\\n substrs=[\\n 'ops',\\n '*f.op',\\n '<parent is NULL>'])\\n self.expect(\\n 'expr f.op',\\n DATA_TYPES_DISPLAYED_CORRECTLY,\\n substrs=[\\n 'ops *',\\n '$'],\\n patterns=['0x0+$'])\\n self.expect(\\n 'expr *f.op',\\n DATA_TYPES_DISPLAYED_CORRECTLY,\\n substrs=['error:'],\\n error=True)\\n\\n bkpt = self.target().FindBreakpointByID(bkpt_id)\\n for enum_value in enum_values:\\n self.expect(\\n \\\"frame variable day\\\",\\n 'check for valid enumeration value',\\n substrs=[enum_value])\\n lldbutil.continue_to_breakpoint(self.process(), bkpt)\",\n \"def move_to_target():\\n keyboard.send('f')\",\n \"def write_goto(output_file, command, label, curr_function):\\n if command == \\\"if-goto\\\":\\n output_file.write(\\\"@SP\\\" + \\\"\\\\n\\\" +\\n \\\"AM = M - 1\\\" + \\\"\\\\n\\\" +\\n \\\"D = M\\\" + \\\"\\\\n\\\" +\\n \\\"@\\\" + curr_function[0] + \\\"$\\\" + label + \\\"\\\\n\\\" +\\n \\\"D; JNE\\\" + \\\"\\\\n\\\")\\n else:\\n output_file.write(\\\"@\\\" + curr_function[0] + \\\"$\\\" + label + \\\"\\\\n\\\" +\\n \\\"0; JMP\\\" + \\\"\\\\n\\\")\",\n \"def test_text_field():\",\n \"def test_get_explore_fields_gets_fields(\\n fc: fetcher.Fetcher, test_model, test_explores_stats\\n):\\n test_explore = test_explores_stats[0]\\n explore = fc.get_explores(model=test_model[\\\"name\\\"], explore=test_explore[\\\"name\\\"])\\n assert isinstance(explore, list)\\n explore = explore[0]\\n assert isinstance(explore, models.LookmlModelExplore)\\n assert explore.model_name == test_model[\\\"name\\\"]\\n assert explore.name == test_explore[\\\"name\\\"]\\n fields = fc.get_explore_fields(explore)\\n assert isinstance(fields, list)\\n assert fields == test_explore[\\\"all_fields\\\"]\",\n \"def __le__(self, *args):\\n return _ida_hexrays.cgoto_t___le__(self, *args)\",\n \"def test_select_detail_displays_the_correct_record(self):\\n # make some DB entries\\n dataset = self.create_mixed_test_data()\\n test_log_entries = dataset['test_log_entries']\\n self.menu.records = test_log_entries\\n # choose an index\\n selected_index = 1\\n # execute the method\\n user_input = str(selected_index + 1)\\n with patch('builtins.input', side_effect=user_input):\\n self.menu.select_detail()\\n\\n # assert that the db entry that current_record looks up is the same\\n # as the one chosen.\\n self.assertEqual(test_log_entries[selected_index],\\n self.menu.records[self.menu.current_record])\",\n \"def navigate_to_field(self, field):\\n if self.field:\\n raise AssertionError(u'Already at a field, cannot nest fields: {}'.format(self))\\n return Location(self.query_path, field=field, visit_counter=self.visit_counter)\",\n \"def go_to(self, value=None):\\n self.go_to_this_line = self.line_number.get()\\n self.my_text.mark_set(INSERT, str(float(self.go_to_this_line)))\\n self.current_area()\\n self.my_text.see(INSERT)\\n self.searcher.destroy()\",\n \"def test_entities__Entity__getField__1(entity):\\n with pytest.raises(KeyError):\\n entity.getField('asdf')\",\n \"def test_first_page_passes(self):\\n\\n self.page.open_site(PageLocators.PREVIOUS_LINK)\\n self.page.fill_all_fields()\\n self.page.send_the_data()\",\n \"def test_hidden_field():\",\n \"def TestOneStep(self):\\n pass\",\n \"def _guider_start(self, nCall, nInfo, nWarn, nErr, finish=False, didFail=False):\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n result = masterThread.guider_start(self.cmd, cmdState, myGlobals.actorState, 'gotoField')\\n self.assertEqual(result, not didFail)\\n self._check_cmd(nCall, nInfo, nWarn, nErr, finish, didFail=didFail)\",\n \"def jump(act_line: int, offset: str):\\n return act_line + int(offset)\",\n \"def getfield(value, arg):\\n #import pdb; pdb.set_trace()\\n if hasattr(value, \\\"fields\\\"):\\n fields = getattr(value, \\\"fields\\\")\\n if str(arg) in fields:\\n return str(fields[str(arg)])\",\n \"def handle_next_breakpoint(self, bit):\\n self.check_required()\\n self.options.shift_breakpoint()\\n self.arguments = self.options.get_arguments()\\n self.current_argument = self.arguments.pop(0)\",\n \"def __ge__(self, *args):\\n return _ida_hexrays.cgoto_t___ge__(self, *args)\",\n \"def test_focus(self, name=None):\\n focus_func = getattr(self.form, 'assign_focus_field', None)\\n fields = self.get_current_fields()\\n if focus_func and issubclass(self.__class__, FocusMixIn):\\n name = name or getattr(self.form, 'named_focus', None)\\n expected = focus_func(name, fields)\\n else:\\n expected = 'username' if 'username' in fields else None\\n expected = name or expected or None\\n if not expected:\\n self.assertTrue(True)\\n return\\n focus_list = self.find_focus_field()\\n self.assertEqual(1, len(focus_list))\\n self.assertEqual(expected, focus_list[0])\",\n \"def test_goto_field_boss_flat_on_fails(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n self.cmd.failOn = 'mcp ff.on'\\n self._goto_field_boss(16, 71, 0, 1, cmdState, didFail=True, finish=True)\",\n \"def scrollField(*args, annotation: Union[AnyStr, bool]=\\\"\\\", backgroundColor: Union[List[float,\\n float, float], bool]=None, changeCommand: Script=None, clear: bool=True,\\n command: AnyStr=\\\"\\\", defineTemplate: AnyStr=\\\"\\\", docTag: Union[AnyStr, bool]=\\\"\\\",\\n dragCallback: Script=None, dropCallback: Script=None, editable: bool=True,\\n enable: bool=True, enableBackground: bool=True, enableKeyboardFocus: bool=True,\\n enterCommand: Script=None, exists: bool=True, font: Union[AnyStr, bool]=\\\"\\\",\\n fontPointSize: Union[int, bool]=0, fullPathName: bool=True, height: Union[int,\\n bool]=0, highlightColor: Union[List[float, float, float], bool]=None,\\n insertText: AnyStr=\\\"\\\", insertionPosition: Union[int, bool]=0, isObscured:\\n bool=True, keyPressCommand: Script=None, manage: bool=True, noBackground:\\n bool=True, numberOfLines: Union[int, bool]=0, numberOfPopupMenus: bool=True,\\n parent: Union[AnyStr, bool]=\\\"\\\", popupMenuArray: bool=True, preventOverride:\\n bool=True, qtFont: Union[AnyStr, bool]=\\\"\\\", selection: bool=True,\\n statusBarMessage: AnyStr=\\\"\\\", text: Union[AnyStr, bool]=\\\"\\\", useTemplate:\\n AnyStr=\\\"\\\", visible: bool=True, visibleChangeCommand: Union[Script, bool]=None,\\n width: Union[int, bool]=0, wordWrap: bool=True, q=True, query=True, e=True,\\n edit=True, **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def other_search(self):\\n test = self.ask_zoekarg.text()\\n if test:\\n self.parent().search_arg = test\\n self.parent().do_select()\",\n \"def test(self):\\n # 0x13 is nop\\n self.gdb.command(\\\"p *((int*) 0x%x)=0x13\\\" % self.target.ram)\\n self.gdb.command(\\\"p *((int*) 0x%x)=0x13\\\" % (self.target.ram + 4))\\n self.gdb.command(\\\"p *((int*) 0x%x)=0x13\\\" % (self.target.ram + 8))\\n self.gdb.p(\\\"$pc=0x%x\\\" % self.target.ram)\\n self.gdb.stepi()\\n assertEqual((self.target.ram + 4), self.gdb.p(\\\"$pc\\\"))\\n self.gdb.stepi()\\n assertEqual((self.target.ram + 8), self.gdb.p(\\\"$pc\\\"))\",\n \"def get_jump(self):\\n return self.jump\",\n \"def test_goto_definition_at_zero(Script):\\n assert Script(\\\"a\\\").infer(1, 1) == []\\n s = Script(\\\"str\\\").infer(1, 1)\\n assert len(s) == 1\\n assert list(s)[0].description == 'class str'\\n assert Script(\\\"\\\").infer(1, 0) == []\",\n \"def goto(action, value, error_handle):\\n print_info(\\\"failed: failure action= goto %s\\\" % value)\\n error_handle['action'] = 'GOTO'\\n error_handle['value'] = value\\n return error_handle\",\n \"def test_case_main(self, case_results):\\n\\n log_test_case(self.name, 'drag up and down')\\n drag_by_param(95, 50, 95, 85, 1)\\n drag_by_param(95, 85, 95, 50, 1)\\n sleep(1)\\n drag_by_param(95, 50, 95, 85, 1)\\n drag_by_param(95, 85, 95, 50, 1)\\n sleep(1)\\n self.ime = IME()\\n click_imageview_by_id('menu_search')\\n #entertext_edittext_on_focused('Mi')\\n #clear_edittext_by_index(0)\\n '''\\n PRIVATE_del = ['del']\\n self.ime.IME_input(1, PRIVATE_del)\\n self.ime.IME_input(1, PRIVATE_del)\\n self.ime.IME_input(1, PRIVATE_del)\\n '''\\n\\n self.ime.IME_input_english(1, 'tes')\\n sleep(2)\\n if search_text(SC.PRIVATE_CONTACT_NAME):\\n log_test_case(self.name, 'search name ok...')\\n click_textview_by_text(SC.PRIVATE_CONTACT_NAME)\\n #click_in_list_by_index(1)\\n else:\\n log_test_case(self.name, 'search failed...')\\n return\\n\\n self.call_from_contact()\\n\\n #send sms to mike\\n click_textview_by_id('secondary_action_button')\\n self.ime.IME_input_english(1, 'send')\\n #click_imageview_by_desc(\\\"send\\\")\\n click_button_by_id('send_button_sms')\\n sleep(3)\\n goback()\\n\\n #click_textview_by_text('binz')\\n # show a moment\\n sleep(1)\\n\\n #send EMAIL\\n if search_text('jubao@qunar.com'):\\n click_textview_by_text('jubao@qunar.com')\\n\\n #\\n if search_text('Complete action using'):\\n click_textview_by_text('Email')\\n click_button_by_id('button_always')\\n entertext_edittext_on_focused('email title')\\n\\n click_imageview_by_id(\\\"send\\\")\\n\\n else:\\n goback()\\n\\n # go address map\\n scroll_to_bottom()\\n if search_text('ADDRESS'):\\n click_textview_by_text('pudong,shanghai,china')\\n else:\\n goback()\",\n \"def test_get_goal(self):\\n pass\",\n \"def test_focus_on_limited_fields(self):\\n original_named_focus = self.form.named_focus\\n original_fields_focus = self.form.fields_focus\\n original_given_focus = self.form.given_focus\\n original_fields = self.form.fields\\n self.form.named_focus = None\\n self.form.given_focus = None\\n allowed = [name for name, field in self.form.fields.items()\\n if not field.disabled and not isinstance(field.widget, (HiddenInput, MultipleHiddenInput))]\\n self.assertGreater(len(allowed), 1)\\n fields_focus = allowed[1:]\\n self.form.fields_focus = fields_focus\\n expected = fields_focus[0]\\n actual = self.form.assign_focus_field(None, fields=self.form.fields_focus)\\n\\n self.assertEqual(expected, actual)\\n self.assertEqual(self.form.given_focus, actual)\\n\\n self.form.name_focus = original_named_focus\\n self.form.fields_focus = original_fields_focus\\n self.form.given_focus = original_given_focus\\n self.form.fields = original_fields\",\n \"def step(self, action):\\n pass\",\n \"def step(self, action):\\n pass\",\n \"def fooFunction(item_index):\\n print(\\\"item %d pressed\\\" % (item_index))\",\n \"def _is_ifgoto(self, words):\\n if words[0] == 'if-goto':\\n if len(words) != 2:\\n raise SyntaxError(\\\"File line {}: Invalid number of arguments for C_IFGOTO command.\\\".format(self._file_line))\\n return True\\n else:\\n return False\",\n \"def help_select(self):\\n print(SELECT)\",\n \"def test_010(self):\\n caller = self.get_caller([SingleMethod])\\n self.assertEqual(\\\"I have very little to say.\\\", caller())\",\n \"def test_parse_fields(pawprint_default_tracker_db):\\n\\n tracker = pawprint_default_tracker_db\\n\\n # SELECT * FROM table\\n args = ()\\n assert tracker._parse_fields(*args) == \\\"*\\\"\\n\\n # SELECT event FROM table\\n args = (\\\"event\\\",)\\n assert tracker._parse_fields(*args) == \\\"event\\\"\\n\\n # SELECT user_id, timestamp FROM table\\n args = (\\\"user_id\\\", \\\"timestamp\\\")\\n assert tracker._parse_fields(*args) == \\\"user_id, timestamp\\\"\\n\\n # SELECT metadata #>> '{a, b}' FROM table\\n args = (\\\"metadata__a__b\\\",)\\n assert tracker._parse_fields(*args) == \\\"metadata #> '{a, b}' AS json_field\\\"\",\n \"def _examineOrSelect(self):\\n d = getattr(self.client, self.method)('foobox')\\n self.assertEqual(\\n self.transport.value(), b'0001 ' + self.command + b' foobox\\\\r\\\\n')\\n return d\",\n \"def do_step(self) -> None:\",\n \"def write_goto_in_func(self, label):\\n label = self.label_by_scope(label)\\n self.write(\\\"@\\\" + label + \\\"\\\\n0;JMP\\\\n\\\")\\n # @label\\n # 0;JMP\",\n \"def step():\\n \\n step = models.Step(action=u\\\"goto\\\", target=u\\\"http://www.joesfunerals.com\\\")\",\n \"def test_03_visit_special(self):\",\n \"def test_int_field():\",\n \"def jumpto(self, item, offset):\\n try:\\n self.ret = idc.jumpto(offset)\\n except:\\n self.ret = False\\n\\n return self.ret\",\n \"def click_header_field_link(self, label):\\n locator = lex_locators[\\\"record\\\"][\\\"header\\\"][\\\"field_value_link\\\"].format(label)\\n self._jsclick(locator)\",\n \"def test_code010(self, *test_code_args, **test_code_kwargs):\\n print(\\\"This is test_code010 from TestDefinition #\\\", self.ID, \\\", test case #\\\", self.test_case_ID, sep='')\",\n \"def write_go_to(self, label):\\n self._write_line('goto ' + label)\",\n \"def test_goto_field_boss_hartmann(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n cmdState.doSlew = False\\n cmdState.doCalibs = False\\n cmdState.arcTime = 0\\n cmdState.flatTime = 0\\n cmdState.doGuider = False\\n self._goto_field_boss(5, 29, 0, 0, cmdState)\",\n \"def test_get_genome_7(self):\\n self.tkt1.data_add = set([\\\"retrieve_record\\\"])\\n gnm = tickets.get_genome(self.tkt1, gnm_type=\\\"add\\\")\\n with self.subTest():\\n self.assertEqual(gnm.host_genus, \\\"\\\")\\n with self.subTest():\\n self.assertEqual(gnm.retrieve_record, 1)\",\n \"def test_goto_field_boss_slew(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n cmdState.doGuider = False\\n cmdState.doHartmann = False\\n cmdState.doCalibs = False\\n cmdState.arcTime = 0\\n cmdState.flatTime = 0\\n self._goto_field_boss(3, 26, 0, 0, cmdState)\",\n \"def test_forward_char_extend_selection(self):\\n before_b = \\\"\\\"\\\"\\\\\\n first line\\n line 1\\n line a\\n line b\\n line c\\n last line\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n first line\\n line 1\\n line a\\n line b\\n line c\\n last line\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.1\\\", \\\"1.1\\\"),\\n after_sel=(\\\"1.1\\\", \\\"1.2\\\"),\\n command_name=\\\"forward-char-extend-selection\\\",\\n )\",\n \"def _MocaCtlGetField(self, outfcn, field):\\n\\n m_re = re.compile(field + r'\\\\s*:\\\\s+(\\\\S+)')\\n for line in outfcn():\\n mr = m_re.search(line)\\n if mr is not None:\\n return mr.group(1)\\n return None\",\n \"def probe_at_single_point(self, field, *args, **kwargs):\\n raise NotImplementedError\",\n \"def test(self):\\n # -- Test --\\n\\n # (1)\\n\\n # (2)\\n\\n # (3)\\n\\n # (4)\\n # -- Test --\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7691792","0.64816624","0.628449","0.5856036","0.58257854","0.5754098","0.56664455","0.56335163","0.5571063","0.5469148","0.54335827","0.53827053","0.52839625","0.51585394","0.5143092","0.5104858","0.5102512","0.5086537","0.50655967","0.50533384","0.5010544","0.49709177","0.49680653","0.49628344","0.49567345","0.49561286","0.4955987","0.49268192","0.4919463","0.49160644","0.4909401","0.49054995","0.48988038","0.4870134","0.48598042","0.484847","0.48315704","0.4827044","0.48177752","0.4817093","0.48133612","0.48062047","0.47985446","0.47976562","0.47937015","0.47868142","0.47815123","0.47748837","0.47668114","0.47656122","0.4750558","0.47476444","0.4736779","0.47367582","0.4735321","0.47338954","0.47263035","0.47256926","0.47215664","0.47182435","0.471734","0.47099608","0.47069192","0.4706346","0.46981135","0.46807685","0.46784687","0.46742418","0.4673319","0.46702877","0.46510392","0.46487918","0.46407804","0.46379107","0.46332577","0.46323773","0.4629916","0.4629916","0.46280533","0.462642","0.46259758","0.4622155","0.4617772","0.46128127","0.4610434","0.46103817","0.4608422","0.46082267","0.46067852","0.4604498","0.4601525","0.45991513","0.45991045","0.45989862","0.45982143","0.45882806","0.45881847","0.45742372","0.45695114","0.45679146"],"string":"[\n \"0.7691792\",\n \"0.64816624\",\n \"0.628449\",\n \"0.5856036\",\n \"0.58257854\",\n \"0.5754098\",\n \"0.56664455\",\n \"0.56335163\",\n \"0.5571063\",\n \"0.5469148\",\n \"0.54335827\",\n \"0.53827053\",\n \"0.52839625\",\n \"0.51585394\",\n \"0.5143092\",\n \"0.5104858\",\n \"0.5102512\",\n \"0.5086537\",\n \"0.50655967\",\n \"0.50533384\",\n \"0.5010544\",\n \"0.49709177\",\n \"0.49680653\",\n \"0.49628344\",\n \"0.49567345\",\n \"0.49561286\",\n \"0.4955987\",\n \"0.49268192\",\n \"0.4919463\",\n \"0.49160644\",\n \"0.4909401\",\n \"0.49054995\",\n \"0.48988038\",\n \"0.4870134\",\n \"0.48598042\",\n \"0.484847\",\n \"0.48315704\",\n \"0.4827044\",\n \"0.48177752\",\n \"0.4817093\",\n \"0.48133612\",\n \"0.48062047\",\n \"0.47985446\",\n \"0.47976562\",\n \"0.47937015\",\n \"0.47868142\",\n \"0.47815123\",\n \"0.47748837\",\n \"0.47668114\",\n \"0.47656122\",\n \"0.4750558\",\n \"0.47476444\",\n \"0.4736779\",\n \"0.47367582\",\n \"0.4735321\",\n \"0.47338954\",\n \"0.47263035\",\n \"0.47256926\",\n \"0.47215664\",\n \"0.47182435\",\n \"0.471734\",\n \"0.47099608\",\n \"0.47069192\",\n \"0.4706346\",\n \"0.46981135\",\n \"0.46807685\",\n \"0.46784687\",\n \"0.46742418\",\n \"0.4673319\",\n \"0.46702877\",\n \"0.46510392\",\n \"0.46487918\",\n \"0.46407804\",\n \"0.46379107\",\n \"0.46332577\",\n \"0.46323773\",\n \"0.4629916\",\n \"0.4629916\",\n \"0.46280533\",\n \"0.462642\",\n \"0.46259758\",\n \"0.4622155\",\n \"0.4617772\",\n \"0.46128127\",\n \"0.4610434\",\n \"0.46103817\",\n \"0.4608422\",\n \"0.46082267\",\n \"0.46067852\",\n \"0.4604498\",\n \"0.4601525\",\n \"0.45991513\",\n \"0.45991045\",\n \"0.45989862\",\n \"0.45982143\",\n \"0.45882806\",\n \"0.45881847\",\n \"0.45742372\",\n \"0.45695114\",\n \"0.45679146\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.47256958"},"document_rank":{"kind":"string","value":"57"}}},{"rowIdx":488,"cells":{"query":{"kind":"string","value":"Start with decentered guiding on, to check that we clear it. ff on, guider flat, ff off, ffs open 3xguider axes off, decenter off, guider on"},"document":{"kind":"string","value":"def test_goto_field_boss_guider(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n sopTester.updateModel('guider', TestHelper.guiderState['guiderOnDecenter'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doSlew = False\n cmdState.doHartmann = False\n cmdState.doCalibs = False\n cmdState.arcTime = 0\n cmdState.flatTime = 0\n self._goto_field_boss(9, 37, 0, 0, cmdState)"},"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 f_fixed(self):\n self.fx_free = self.fy_free = self.fz_free = False\n return self","def align(): # open EH and fast shutter\n\t#marAuxiliary.closeMarShield()\n\td2in()\n\td3in()\n\tsh('o')","def test_DFT_rect(centering='FFTRECT', outdir=None, outname='DFT1R_', npix=None, sampling=10., nlamd=None):\n\n print \"Testing DFT, style = \"+centering\n\n\n npupil = 156\n pctr = int(npupil/2)\n s = (npupil,npupil)\n\n\n # make things rectangular:\n if nlamd is None and npix is None:\n nlamd = (10,20)\n npix = [val*sampling for val in nlamd] #(100, 200) \n elif npix is None:\n npix = [val*sampling for val in nlamd] #(100, 200) \n elif nlamd is None:\n nlamd = [val/sampling for val in npix]\n u = nlamd\n print u\n #(u, float(u)/npix[0]*npix[1])\n #npix = (npix, 2*npix)\n\n\n # FFT style\n mft1 = matrixDFT.MatrixFourierTransform(centering=centering)\n\n #ctr = (float(npupil)/2.0 + mft1.offset(), float(npupil)/2.0 + mft1.offset())\n ctr = (float(npupil)/2.0 , float(npupil)/2.0)\n #print ctr\n pupil = makedisk(s=s, c=ctr, r=float(npupil)/2.0001, t=np.float64, grey=0)\n\n pupil[0:60, 0:60] = 0\n pupil[0:10] = 0\n\n pupil /= np.sqrt(pupil.sum())\n\n plt.clf()\n plt.subplots_adjust(left=0.02, right=0.98)\n plt.subplot(141)\n\n pmx = pupil.max()\n plt.imshow(pupil, vmin=0, vmax=pmx*1.5)\n\n\n if outdir is not None:\n fits.PrimaryHDU(pupil.astype(np.float32)).writeto(outdir+os.sep+outname+\"pupil.fits\", clobber=True)\n\n a = mft1.perform(pupil, u, npix)\n\n pre = (abs(pupil)**2).sum() \n post = (abs(a)**2).sum() \n ratio = post / pre\n calcr = 1./(1.0*u[0]*u[1] *npix[0]*npix[1]) # multiply post by this to make them equal\n print \"Pre-FFT total: \"+str( pre)\n print \"Post-FFT total: \"+str( post )\n print \"Ratio: \"+str( ratio)\n #print \"Calc ratio : \"+str( calcr)\n #print \"uncorrected: \"+str( ratio/calcr)\n\n\n complexinfo(a, str=\",ft1 asf\")\n asf = a.real.copy()\n if outdir is not None:\n fits.PrimaryHDU(asf.astype(np.float32)).writeto(outdir+os.sep+outname+\"asf.fits\", clobber=True)\n cpsf = a * a.conjugate()\n psf = cpsf.real.copy()\n if outdir is not None:\n fits.PrimaryHDU(psf.astype(np.float32)).writeto(outdir+os.sep+outname+\"psf.fits\", clobber=True)\n\n ax=plt.subplot(142)\n plt.imshow(asf, norm=matplotlib.colors.LogNorm(1e-8, 1.0))\n ax.set_title='ASF'\n\n ax=plt.subplot(143)\n plt.imshow(psf, norm=matplotlib.colors.LogNorm(1e-8, 1.0))\n ax.set_title='PSF'\n\n plt.subplot(144)\n\n pupil2 = mft1.inverse(a, u, npupil)\n pupil2r = (pupil2 * pupil2.conjugate()).real\n plt.imshow( pupil2r, vmin=0,vmax=pmx*1.5*0.01) # FIXME flux normalization is not right?? I think this has to do with squaring the pupil here, that's all.\n plt.gca().set_title='back to pupil'\n plt.draw()\n print \"Post-inverse FFT total: \"+str( abs(pupil2r).sum() )\n print \"Post-inverse pupil max: \"+str(pupil2r.max())\n\n plt.suptitle('Matrix DFT with rectangular arrays using centering={0}'.format(centering))\n\n plt.savefig('test_DFT_rectangular_results_{0}.pdf'.format(centering))","def proz_manually ():\r\n Check_180turn(left_boundary,right_boundary)\r\n ABS() # Baseline correction \r\n XCMD(\"closeall\",WAIT_TILL_DONE)","def clear(self):\n self.np.fill(OFF)\n self.np.show()\n return True","def full_reset(self):\n self.at_cmd('CFUN=1')","def zguider():\n gzero.gxoff = camera.status.guider[0] + gzero.gxoff\n gzero.gyoff = camera.status.guider[1] + gzero.gyoff\n guider(0,0)\n f = open('/data/guidezero','w')\n cPickle.dump(gzero,f)\n f.close()","def setNoZeroColor():\n dislin.nobgd()","def terminatePlane3D():\n dislin.grffin()","def reset(self):\n super(PolygonTool, self).reset()\n # self.__nsides = None\n # self.__increment = None\n # self.__external = False # make this adjustable?\n self.__center = None\n for _i in range(self.__nsides):\n self.__xpts[_i] = 0.0\n self.__ypts[_i] = 0.0","def test_offcenter(self):\n actual = cm.ring_mask((5, 5), 1, 2, center=(2, 3))\n expected = np.array([[False, False, False, True, False],\n [False, False, True, False, True],\n [False, True, False, False, False],\n [False, False, True, False, True],\n [False, False, False, True, False]])\n self.assertIsNone(np.testing.assert_array_equal(actual, expected))","def fill_single_world():\n if not front_is_clear():\n if not right_is_clear():\n if not left_is_clear():\n put_beeper()","def cerrar(self):\n self.x0 = np.array(self.x0, dtype=float)\n self.x = np.array(self.x, dtype=float)\n self.tipos = np.array(self.tipos, dtype=int)\n self.mask_fr = self.tipos == 1\n self.mask_in = self.tipos == 2\n self.num_fr = np.sum(self.mask_fr)\n self.num_in = np.sum(self.mask_in)\n self.open = False","def resetAlignmentCenter(self):\n cent = self.TiltSeries_._TiltAlignmentParas.cent\n imdimX = self.TiltSeries_._imdimX\n imdimY = self.TiltSeries_._imdimY\n print(imdimX, imdimY)\n if cent[0] != imdimX//2+1 or cent[1] != imdimY//2+1:\n #rint \"Centers do not match: cent=\"+str(cent)+\", imdim=\"+str(imdim)\n self.TiltSeries_._TiltAlignmentParas.cent = [imdimX//2+1, imdimY//2+1]","def reset_mask(self):\n\n self.mask = np.ones(self.dispersion.shape, dtype=bool)","def ToggleAllGizmoLocalMode( self ):\n\n value = self.gizmoMgr.GetGizmoLocal( 'pos' )\n self.gizmoMgr.SetGizmoLocal( 'pos', not value )\n self.gizmoMgr.SetGizmoLocal( 'rot', not value )\n self.gizmoMgr.SetGizmoLocal( 'scl', not value )","def test_offcenter(self):\n actual = cm.circle_mask((5, 5), 2, center=(2, 3))\n expected = np.array([[False, False, False, True, False],\n [False, False, True, True, True],\n [False, True, True, True, True],\n [False, False, True, True, True],\n [False, False, False, True, False]])\n self.assertIsNone(np.testing.assert_array_equal(actual, expected))","def Face_Cycle_L(self,event):\n t=event.widget.find_closest(event.x, event.y)[0]\n u=int(self.canvas.itemcget(t,\"tags\").split()[1])\n if u not in [4,13,22,31,40,49]:\n v=self.colours_face[self.ocol[self.canvas.itemcget(t,\"fill\")][0]][0][0]\n self.cubestring[int(u)]=v\n self.cube.cube = self.cubestring#Cube.set(self.cubestring)\n self.map_face()\n else:\n print(\"Cant Change Center Cubit\")","def modes_off(self):\n bm = self.fitsimage.get_bindmap()\n bm.reset_mode(self.fitsimage)","def ClearDisplay():\n display.fill(0)","def m_fixed(self):\n self.mx_free = self.my_free = self.mz_free = False\n return self","def update_flags(self):\n # view mode, filled vs wirefrom\n if self.view['wireframe']:\n gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_LINE)\n else:\n gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_FILL)\n\n # set fullscreen or windowed\n self.set_fullscreen(fullscreen=self.view['fullscreen'])\n\n # backface culling on or off\n if self.view['cull']:\n gl.glEnable(gl.GL_CULL_FACE)\n else:\n gl.glDisable(gl.GL_CULL_FACE)\n\n # case where we WANT an axis and NO vertexlist\n # is stored internally\n if self.view['axis'] and self._axis is None:\n from .. import creation\n # create an axis marker sized relative to the scene\n axis = creation.axis(origin_size=self.scene.scale / 100)\n # create ordered args for a vertex list\n args = rendering.mesh_to_vertexlist(axis)\n # store the axis as a reference\n self._axis = self.batch.add_indexed(*args)\n\n # case where we DON'T want an axis but a vertexlist\n # IS stored internally\n elif not self.view['axis'] and self._axis is not None:\n # remove the axis from the rendering batch\n self._axis.delete()\n # set the reference to None\n self._axis = None","def remove_spurious_landmarks(self):\r\n \r\n remove = np.argwhere(self.lm_counter < 0)\r\n self.lm = np.delete(self.lm, remove, axis=0)\r\n self.lm_cvar = np.delete(self.lm_cvar, remove, axis=0)\r\n self.lm_counter = np.delete(self.lm_counter, remove)\r\n \r\n return # Replace this.\r","def _mask_mode(self):\r\n self._mode_select(0)","def plot_clear():\n plt.cla()","def correct(self):\n self.parent.copyCurrentWinState(self.pltw)\n self.pltw.blklst[self.blkno][self.ypos] = self.data[1] - self.data[2]\n self.pltw.updatePlot()\n self.pltw.dirty = True\n self.pltw.activecurv = self.cpos\n self.parent.updateUI()\n self.hide()","def reset(self):\n self.posXY = (0,0)\n self.magXY = (1.0,1.0)\n self.rot = 0.0\n self.trans = 255\n self.isDone = False\n self.isFirst = True\n\n self.kill()\n self.Group = pyglet.graphics.OrderedGroup(self.order)\n self.isReady = self.check()","def test_DFT_rect_adj():\n test_DFT_rect(centering='ADJUSTIBLE', outname='DFT1Radj_')","def reset_energizer_flag(self): \r\n self.energizer_flag = False","def front_is_clear(): #py:front_is_clear\n return RUR._front_is_clear_()","def update_center(self): \r\n \r\n self.grfx[0].center = self.center\r\n\r\n self.update_bbox()","def free_curvature(self) -> None:\n self.n1.free = True\n self.n2.free = True","def clear_crossfilter1(self):\n print ('Trigger clear')\n self.query_dict = {}\n self.plot_data = None\n self.create_figure_new()\n layout_doc.children[4].children[0] = self.p","def enableRemoveDesign(self):\n if self.mode.selectedShipHull.aftQuadInfo == None:\n self.isDroneDesign = 1\n self.enableRemoveDroneDesign()\n else:\n self.isDroneDesign = 0\n self.enableRemoveShipDesign()","def pixel_space(self):\n self.drawer.settransform()\n self.coordspace_bbox = [0, 0, self.width, self.height]\n self.coordspace_transform = (1, 0, 0,\n 0, 1, 0)","def resetFrame(self):\n with self.lock:\n hbin = self.hbin\n vbin = self.vbin\n if hbin != 1:\n self.setHBin(1)\n if vbin != 1:\n self.setVBin(1)\n with self.lock:\n self.expArea = self.defaultExpArea\n x1, y1, x2, y2 = self.expArea\n self.xsize = x2 - x1\n self.ysize = y2 - y1","def _set_up_acq_opt_direct(self):\n raise NotImplementedError('Not implemented DiRect yet.')","def reset(self):\n if self.num == 1:\n self.rect.centerx = 320\n elif self.num == 2:\n self.rect.centerx = 341\n elif self.num == 3:\n self.rect.centerx = 362\n elif self.num == 4:\n self.rect.centerx = 383\n self.rect.centery = 371\n self.centerx = self.rect.centerx\n self.centery = self.rect.centery\n\n self.moving_right = False\n self.moving_left = False\n self.moving_up = True\n self.moving_down = False","def clear_crossfilter2(self):\n print ('Trigger clear')\n self.query_dict = {}\n self.plot_data = None\n self.create_figure_new()\n layout_doc.children[4].children[1] = self.p","def test_inverse( centering='SYMMETRIC'):\n\n\n npupil = 300 #156\n pctr = int(npupil/2)\n npix = 100 #1024\n u = 20 #100 # of lam/D\n\n npix, u = 2000, 200\n s = (npupil,npupil)\n\n\n\n\n mft1 = matrixDFT.MatrixFourierTransform(centering=centering)\n\n ctr = (float(npupil)/2.0, float(npupil)/2.0 )\n #print ctr\n pupil = makedisk(s=s, c=ctr, r=float(npupil)/2.0001, t=np.float64, grey=0)\n pupil /= np.sqrt(pupil.sum())\n\n pupil[100:200, 30:50] = 0\n pupil[0:50, 140:160] = 0\n\n plt.subplot(141)\n plt.imshow(pupil)\n\n print \"Pupil 1 total:\", pupil.sum() \n\n a = mft1.perform(pupil, u, npix)\n\n asf = a.real.copy()\n cpsf = a * a.conjugate()\n psf = cpsf.real.copy()\n print \"PSF total\", psf.sum()\n \n plt.subplot(142)\n plt.imshow(psf, norm=matplotlib.colors.LogNorm(1e-8, 1.0))\n\n plt.subplot(143)\n\n pupil2 = mft1.inverse(a, u, npupil)\n pupil2r = (pupil2 * pupil2.conjugate()).real\n plt.imshow( pupil2r)\n\n print \"Pupil 2 total:\", pupil2r.sum() \n\n\n\n a2 = mft1.perform(pupil2r, u, npix)\n psf2 = (a2*a2.conjugate()).real.copy()\n print \"PSF total\", psf2.sum()\n plt.subplot(144)\n plt.imshow(psf2, norm=matplotlib.colors.LogNorm(1e-8, 1.0))","def off_screen(self):\n return self._x < 0","def reset(self):\n self.vrp = np.matrix([0.5, 0.5, 1])\n self.vpn = np.matrix([0, 0, -1])\n self.vup = np.matrix([0, 1, 0])\n self.u = np.matrix([-1, 0, 0])\n self.extent = [1., 1., 1.]\n self.screen = [400., 400.]\n self.offset = [20., 20.]","def no_gradient_fusion():\n pass","def clean(self):\n\n if (self.clean_level == 'dusty') | (self.clean_level == 'clean'):\n idx, = np.where(self['B_flag'] == 0)\n self.data = self[idx, :]\n\n return","def __reset_crosshair(self):\n self.lhor.set_ydata(self.y_coord)\n self.lver.set_xdata(self.x_coord)","def clear():\n\tglobal _s\n\t_s.screen.fill(_s.back)\n\t_s.tab(0,0)\n\t_flip()","def cla(self):\n self.disable_mouse_rotation()\n Axes.cla(self)\n self.grid(rcParams['axes3d.grid'])","def _switch(self):\n self.fill= not self.fill","def initializeDomainBorder(self):\n #Read image of the structure\n if (self.PictureExistance == \"'yes'\"):\n self.__processImage()\n #re-define the domain size with the layers of boundaries and ghost points\n self.ny, self.nx = self.effectiveDomain.shape\n print('Now the size of domain is %g and %g' %(self.ny, self.nx))\n else:\n self.isDomain = sp.empty([self.ny, self.nx], dtype = np.bool)\n self.isSolid = sp.empty([self.ny, self.nx], dtype = np.bool)\n self.isDomain, self.isSolid = defineGeometry(self.nx, self.ny)\n if (self.PictureExistance == \"'yes'\"):\n self.originalXdim = self.nx\n self.isDomain = sp.empty([self.ny, self.nx], dtype = np.bool)\n self.isSolid = sp.empty([self.ny, self.nx], dtype = np.bool)\n #define the boundary position\n if (self.isCycles == \"'yes'\"):\n self.isBoundaryFluid2 = sp.empty([self.ny, self.nx], \\\n dtype = np.bool)\n# self.isFluidBoundary = sp.empty([self.ny, self.nx], dtype = np.bool)\n self.isDomain[:, :] = 1; self.isSolid[:, :] = 0\n for i in sp.arange(self.ny):\n for j in sp.arange(self.nx):\n if (self.effectiveDomain[i, j] == 0.0):\n self.isDomain[i, j] = 0\n self.isSolid[i, j] = 1\n self.voidSpace = np.count_nonzero(self.isDomain)\n print('The number of vexls in void space is %g.' % self.voidSpace)\n print('The porosity of the layout is %f.' % (self.voidSpace / (self.isDomain.size)))","def reset(self):\n self.position = np.zeros(self.ndegres)\n self.velocity = np.zeros(self.ndegres)\n self.state = np.zeros(2*self.ndegres)\n self.flag = 0\n self.h_ref = np.array([self.ref for _ in range(self.horizon)])\n self.action = np.zeros(self.ACTION_DIM) \n self.h_action = np.zeros(self.ACTION_DIM*self.horizon)","def unoccupied(self):\n self.is_occupied = 0\n for hex in self.fon:\n hex.remove_neighbor()\n hex.set_quality()","def set_defaults(self):\n if not self.HAS_DS9: # pragma: no cover\n return\n self.run('frame delete all')\n self.run('wcs degrees')\n if self.disp_parameters['tile']:\n self.run('tile yes')\n else:\n self.run('tile no')\n self.cs = str(self.disp_parameters['lock_image']).lower()\n self.lock()","def is_compact(self):\n return self.n_rays()==0 and self.n_lines()==0","def reset(self):\r\n # reset Wheel encoders\r\n self.start_time = time.time()\r\n [left_start, right_start] = self.Roomba.Query(43, 44)\r\n self.Motion.reset(left_start, right_start)\r\n # reset bumper\r\n self.bumper.reset()\r\n\r\n #reset grid world data\r\n self.action=[0.0,0.0]\r\n self.grid_state= [0,0,0]\r\n self.real_state = [0.0, 0.0, 0.0]\r\n self.trans_model = None\r\n pass","def clear(self):\n if self.flag == 0:\n for coord in INDICES:\n self.kill(coord)\n self.chart[coord] = DEAD","def fix(hobj):\n\n h.execute('create axon[2]', hobj)\n\n for sec in hobj.axon:\n sec.L = 30\n sec.diam = 1\n hobj.axonal.append(sec=sec)\n hobj.all.append(sec=sec) # need to remove this comment\n\n hobj.axon[0].connect(hobj.soma[0], 0.5, 0)\n hobj.axon[1].connect(hobj.axon[0], 1, 0)\n\n h.define_shape()","def setUseGizmos(value=True):\n global cc\n cc = not value","def clear_transforms(self): # -> None:\n ...","def flip_faceup(self):\r\n self.faceup = True","def cb_reset(event):\n axDirichlet.cla()\n # Reset Sliders\n sAlpha0.reset() # resetが駄目！一番最初に戻ってしまう\n sAlpha1.reset()\n sAlpha2.reset()\n alpha_update = [sAlpha0.val, sAlpha1.val, sAlpha2.val]\n print('alpha_update=', alpha_update)\n\n # ML\n lambda_ML = CatML.MLinfer(x_cat)\n\n axML.cla()\n drawBarGraph( axML, \"ML\", lambda_ML, bar_y_max, col_ML ) # Draw Bar graph\n\n\n # MAP\n dirichlet.set_param(alpha_update)\n lambda_MAP = CatMAP.MAPinfer(x_cat, dirichlet)\n\n axMAP.cla()\n drawBarGraph( axMAP, \"MAP\", lambda_MAP, bar_y_max, col_MAP ) # Draw Bar Graph\n\n # Bayes\n posteriorDirichlet.set_param(alpha_update)\n posteriorDirichlet.calcPosterior(x_cat)\n lambda_Bayes = np.zeros(3)\n for k in range(3):\n lambda_Bayes[k] = posteriorDirichlet.BayesInfer(k)\n\n axBayes.cla()\n drawBarGraph( axBayes, \"Bayes\", lambda_Bayes, bar_y_max, col_Bayes ) # Draw Bar Graph\n\n draw_pdf_contours(axDirichlet, dirichlet, True) # Draw Dirichlet\n\n print('Reset')\n print('lambda_ML =', lambda_ML)\n print('lambda_MAP =', lambda_MAP)\n print('lambda_Bayes=', lambda_Bayes)\n draw_point(axDirichlet, lambda_ML, col_ML)\n draw_point(axDirichlet, lambda_MAP, col_MAP)\n draw_point(axDirichlet, lambda_Bayes, col_Bayes)\n draw_point(axLikelihood, lambda_ML, col_ML)\n draw_point(axPosteriorDirichlet, lambda_MAP, col_MAP)\n draw_point(axPosteriorDirichlet, lambda_Bayes, col_Bayes)\n\n fig.canvas.draw_idle()","def middlemakevisible(self, pos):\n pass","def testCoords1D(realSpace, fourierSpace, X, dx):\n \n def cosines(freqs, Nyquist, real, fourier, x):\n for i in range(0, len(freqs)):\n real = real + np.cos(2*np.pi * freqs[i] * x)\n \n fourier = np.fft.fftshift(np.fft.fft(real))\n return real, fourier\n \n def gauss(sigma, mu, real, fourier, x): # Still need to fix\n real = 1/(sigma * np.sqrt(2 * np.pi)) * np.exp( - (x - mu)**2 / (2 * sigma**2) )\n fourier = np.fft.fftshift(real)\n return real, fourier\n \n def window(w, real, fourier, x):\n real = real*0 + 1\n mask = np.abs(x)-w/2 < 0\n real = real*mask\n #fourier = np.fft.fftshift(np.fft.fft(real))\n fourier = FFT1(real)\n #f1 = np.fft.fft(real)\n #ifft = np.fft.ifft(np.fft.fftshift(fourier))\n #ifft = np.fft.ifft(np.fft.ifftshift(fourier))\n ifft = IFFT1(fourier)\n return real, fourier, ifft\n \n N = len(realSpace)\n xVals = np.arange(-X/2, X/2 + dx, dx)\n f = np.linspace(0, X, N)/X\n const = 0*realSpace + 1\n impulse = np.fft.fft(const)\n #plt.plot(f, impulse)\n cosines, impulses = cosines([1], X/2, const*0, f, xVals)\n #plt.plot(xVals, cosines)\n # plt.plot(f*X, np.abs(impulses))\n gauss, gaussFT = gauss(1, 0, const*0, f, xVals)\n window, sinc, iwindow = window(X/4, const, f, xVals)\n plt.plot(f - f[-1]/2, np.abs(sinc))\n #plt.plot(xVals, iwindow)","def Face_Cycle_R(self,event):\n t=event.widget.find_closest(event.x, event.y)[0]\n u=int(self.canvas.itemcget(t,\"tags\").split()[1])\n if u not in [4,13,22,31,40,49]:\n v=self.colours_face[self.ocol[self.canvas.itemcget(t,\"fill\")][1]][0][0]\n self.cubestring[u]=v\n self.cube.cube = self.cubestring#Cube.set(self.cubestring)\n self.map_face()\n else:\n print(\"Cant Change Center Cubit\")","def debug_clear(self):\n if self.display:\n from capture_graphics_display import PacmanGraphics\n if isinstance(self.display, PacmanGraphics):\n self.display.clear_debug()","def resetTransformations():\n dislin.trfres()","def all_off(self):\n self.fill_off()\n self.update()\n self.fill_off()\n self.update()","def fiducial_evolution():\n \n # fiducial model\n wangle = 180*u.deg\n pk = pickle.load(open('../data/gd1_fiducial.pkl', 'rb'))\n x = pk['x'].to(u.kpc)\n xorig = x[:2]\n \n plt.close()\n fig, ax = plt.subplots(1,1,figsize=(6,6))\n \n plt.sca(ax)\n \n Nsnap = 8\n times = np.linspace(0,0.5,Nsnap)[::-1]\n angles = np.linspace(0,322,Nsnap)[::-1]*u.deg\n\n for e, t in enumerate(times):\n c = mpl.cm.Blues(0.05+0.85*(Nsnap-e)/Nsnap)\n #a = 0.5 + 0.5*(Nsnap-e)/Nsnap\n \n pk = pickle.load(open('../data/gd1_fiducial_t{:.4f}.pkl'.format(t), 'rb'))\n x = pk['x'].to(u.kpc)\n x_, y_ = x[0], x[1]\n \n plt.plot(x_[120:-120], y_[120:-120], '.', color=c, ms=10, zorder=Nsnap-e, rasterized=False)\n \n xt = 24*np.cos(angles[e]+90*u.deg)\n yt = 24*np.sin(angles[e]+90*u.deg)\n if e<Nsnap-1:\n txt = plt.text(xt, yt, '+ {:.2f} Gyr'.format(t), va='center', ha='center', fontsize='small', color='0.2', rotation=(angles[e]).value, zorder=10)\n txt.set_bbox(dict(facecolor='w', alpha=0.7, ec='none'))\n \n plt.text(0, 24, 'Flyby', va='center', ha='center', fontsize='small', color='0.2')\n\n lim = 27\n plt.xlim(-lim,lim)\n plt.ylim(-lim,lim)\n plt.gca().set_aspect('equal')\n \n plt.xlabel('x [kpc]')\n plt.ylabel('y [kpc]')\n \n plt.tight_layout()\n plt.savefig('../plots/loop_evolution.pdf')","def clear(self):\r\n self.SetPoint = 0.0\r\n\r\n self.PTerm = 0.0\r\n self.ITerm = 0.0\r\n self.DTerm = 0.0\r\n self.last_error = 0.0\r\n\r\n # Windup Guard\r\n self.int_error = 0.0\r\n self.windup_guard = 20.0\r\n\r\n self.output = 0.0","def before_flip(self):\n from klibs.KLGraphics import blit\n\n if P.show_gaze_dot and self.el.recording:\n try:\n blit(self.tracker_dot, 5, self.el.gaze())\n except RuntimeError:\n pass","def proz_noe():\r\n print(\"processing: \",CURDATA()[0]) \r\n Check_180turn(left_boundary,right_boundary)\r\n EFP() # Exponential window multiplication + Fourier Transformation + phase correction\r\n ABS() # Baseline correction \r\n Check_180turn(left_boundary,right_boundary)","def enable3D(self):\r\n if(self.dataController.fileLoaded==True):\r\n self.dataController.toggleInteractiveMode()\r\n\r\n self.midsagittalView = False\r\n self.frontView = False\r\n self.topView = False\r\n self.bottomView = False\r\n self.threeDView = True","def onSetToCustDims(self, evt):\n\t\tself.halfResampleZ.Enable(0)\n\t\tself.fourthResampleZ.Enable(0)\n\t\t\n\t\tfor obj in [self.factorLabel, self.dimLabel, self.newDimX, self.newDimY, self.newDimZ, self.factorX, self.factorY, self.factorZ]:\n\t\t\tobj.Enable(1)\n\t\ttry:\n\t\t\trx = int(self.newDimX.GetValue())\n\t\t\try = int(self.newDimY.GetValue())\n\t\t\trz = int(self.newDimZ.GetValue())\n\t\t\tself.currSize = (rx, ry, rz)\n\t\texcept:\n\t\t\tpass","def flip(self):\n \n if self.faceup:\n self.faceup = False\n else:\n self.faceup = True","def zero(self):\n\t\tself.angle = 0.0\n\t\tself.draw()\n\t\ttime.sleep(self.delay)","def reset(self):\n self.u0.fill(0.)\n self.u1.fill(0.)\n self.u2.fill(0.)\n self.time = 0.","def _e0s_center(self, hdr):\n # Called E0SNano in OpenMIMS\n # b field index and e0s center enabled added to sub dict from main nano header\n d = {}\n d['b field index'], d['detector'], d['start'], \\\n d['step size'], d['count time'], d['center'], \\\n d['80% width'], d['E0S center enabled'] = \\\n unpack(self._bo + '5i 2d i', hdr.read(40))\n\n d['E0S center enabled'] = bool(d['E0S center enabled'])\n d['count time'] /= 100 # 10 ms increments to seconds\n if d['detector'] < 0:\n d['detector'] = None\n if d['b field index'] < 0:\n d['b field index'] = None\n return d","def restorePositionsOfUnownedAntennas() :\n if ( s.getInitializationFlag() == True ): return\n unownedAnts = subarrayAntSetup( True )\n progress(\"Setting positions of unowned and uninitialized antennas %s\" % helpers.formatAsRanges( unownedAnts) )\n progress(\"....Pads\")\n restoreAntCommand(pad, unownedAnts, subarray=DEFAULT)\n progress( \"....Pad Offsets\" )\n restoreAntCommand( padOffset, unownedAnts, subarray=DEFAULT )\n progress(\"....Antenna positional offset and axis non-intersection\")\n restoreAntCommand( antennaOffset, unownedAnts, subarray=DEFAULT )\n restoreAntCommand( axisNonIntersection, unownedAnts, subarray=DEFAULT )","def flip(self):","def backToMiddlePos():\n\tprogMode(True) # Active le couple de servos\n\taxDriver.goToPosition(axDriver.BROADCASTID, 0x1FF) # Renvoie a la position 0x1FF","def setup_draw(self):\n pass","def reset(self):\r\n self.x = self.initX\r\n self.y = self.initY\r\n self.dir= self.initDir","def clickClearReferences(self, event):\n self.whiteReference = None\n self.lightBtn.color = '0.85'\n self.darkReference = None\n self.darkBtn.color = '0.85'\n plt.pause(0.3)\n self.axes.autoscale_view()","def clear(self):\n\n self.index = 1\n self.degen = 1.\n self.nnnn_out = False\n self.json_out = False\n self.verbose = False\n self.ipol = 0\n self.ellip = 0.\n self.nepts = 0\n self.genfmt_order = 2\n self.genfmt_vers = \"\"\n self.exch_label = \"\"\n self.rs = 0.\n self.vint = 0.\n self.xmu = 0.\n self.edge = 0.\n self.kf = 0.\n self.rnorman = 0.\n self.gamach = 0.\n self.nepts = FEFF_maxpts\n\n dargs = dict(dtype=np.float64, order='F')\n largs = dict(dtype=np.int32, order='F')\n\n self.evec = np.zeros(3, **dargs)\n self.xivec = np.zeros(3, **dargs)\n self.ipot = np.zeros(1+FEFF_maxleg, **largs)\n self.beta = np.zeros(1+FEFF_maxleg, **dargs)\n self.eta = np.zeros(2+FEFF_maxleg, **dargs)\n self.ri = np.zeros(FEFF_maxleg, **dargs)\n self.rat = np.zeros((3, 2+FEFF_maxleg), **dargs)\n self.iz = np.zeros(1+FEFF_maxpot, **largs)\n self.kfeff = np.zeros(FEFF_maxpts, **dargs)\n self.real_phc = np.zeros(FEFF_maxpts, **dargs)\n self.mag_feff = np.zeros(FEFF_maxpts, **dargs)\n self.pha_feff = np.zeros(FEFF_maxpts, **dargs)\n self.red_fact = np.zeros(FEFF_maxpts, **dargs)\n self.lam = np.zeros(FEFF_maxpts, **dargs)\n self.rep = np.zeros(FEFF_maxpts, **dargs)\n self.nleg = 1","def setup():\n size(SPACE['w'], SPACE['h'])\n colorMode(RGB, 1)","def vis_mechanically_coupled_regions(img_dir,output_dir,data,dbscn_length,dbscn_min_size,display_not_save=False):\n #Read in the image that is segmented/labelled for nuclei\n img=imread(img_dir)\n\n #save plots to show clusters\n fig = plt.figure(figsize=(6, 2))\n ax0 = fig.add_subplot(131)\n ax1 = fig.add_subplot(132)\n ax3 = fig.add_subplot(133)\n #show segmented image labels\n ax0.imshow(img,aspect='auto') \n ax0.axis('off')\n #nuclear centroid color-coded by their orientation\n img1=ax1.scatter(data[\"Y\"], data[\"X\"], c=data[\"angles\"],s=1)\n ax1.set_xlim(0,img.shape[0])\n ax1.set_ylim(img.shape[1],0)\n plt.colorbar(img1)\n ax1.axis('off')\n\n # plot the cluster assignments\n img3=ax3.scatter(data[data[\"clusters\"]> -1][\"Y\"], data[data[\"clusters\"]> -1][\"X\"], \n c=data[data[\"clusters\"]> -1][\"clusters\"],cmap=\"plasma\",s=1)\n ax3.set_xlim(0,img.shape[0])\n ax3.set_ylim(img.shape[1],0)\n ax3.axis('off')\n\n #add titles\n ax0.title.set_text('Segmented Image')\n ax1.title.set_text('Filtered Orientation')\n ax3.title.set_text('Clusters')\n\n if display_not_save:\n plt.show()\n else: \n plt.savefig((output_dir+\"/\"+img_dir.rsplit('/', 1)[-1][:-4]+\"_\"+str(dbscn_length)+\"_\"+ str(dbscn_min_size)+\".png\"),dpi=600, bbox_inches = 'tight',pad_inches = 0)\n fig.clf()\n plt.close(fig)\n plt.close('all')\n \n \n del fig,ax0,ax1,ax3,img1,img3","def clean_axes(axl):\n cleanAxes(axl)","def setPxMode(self, b):\n self.setFlag(self.GraphicsItemFlag.ItemIgnoresTransformations, b)","def clear(self):\n self.cmd(0x33) # $33 8-bit mode\n self.cmd(0x32) # $32 8-bit mode\n self.cmd(0x28) # $28 8-bit mode\n self.cmd(0x0C) # $0C 8-bit mode\n self.cmd(0x06) # $06 8-bit mode\n self.cmd(0x01) # $01 8-bit mode","def _set_draw_mode(draw_mode):\n###############################################################################\n global _draw_mode\n _draw_mode = draw_mode","def fig_craco_fiducial(outfile='fig_craco_fiducial.png',\n zmax=2.5,DMmax=2500,\n show_Macquart=False,\n log=True,\n label='$\\\\log_{10} \\; p(DM_{\\\\rm EG},z)$',\n Aconts=[0.01, 0.1, 0.5],\n cmap='jet', show=False, figsize=None,\n vmnx=(None,None),\n grid=None, survey=None):\n # Generate the grid\n if grid is None or survey is None:\n survey, grid = analy_H0_I.craco_mc_survey_grid()\n\n # Unpack\n full_zDMgrid, zvals, dmvals = grid.rates, grid.zvals, grid.dmvals\n FRBZ=survey.frbs['Z']\n FRBDM=survey.DMEGs\n \n ##### imshow of grid #######\n fsize = 14.\n plt.figure(figsize=figsize)\n ax1=plt.axes()\n plt.sca(ax1)\n \n plt.xlabel('z')\n plt.ylabel('${\\\\rm DM}_{\\\\rm EG}$')\n #plt.title(title+str(H0))\n \n # Cut down grid\n zvals, dmvals, zDMgrid = figures.proc_pgrid(\n full_zDMgrid, \n zvals, (0, zmax),\n dmvals, (0, DMmax))\n ddm=dmvals[1]-dmvals[0]\n dz=zvals[1]-zvals[0]\n nz, ndm = zDMgrid.shape\n\n # Contours\n alevels = figures.find_Alevels(full_zDMgrid, Aconts, log=True)\n \n # Ticks\n tvals, ticks = figures.ticks_pgrid(zvals)# , fmt='str4')\n plt.xticks(tvals, ticks)\n tvals, ticks = figures.ticks_pgrid(dmvals, fmt='int')# , fmt='str4')\n plt.yticks(tvals, ticks)\n\n # Image \n im=plt.imshow(zDMgrid.T,cmap=cmap,origin='lower', \n vmin=vmnx[0], vmax=vmnx[1],\n interpolation='None',\n aspect='auto')\n \n styles=['--','-.',':']\n ax=plt.gca()\n cs=ax.contour(zDMgrid.T,levels=alevels,origin='lower',colors=\"white\",linestyles=styles)\n\n ax=plt.gca()\n \n muDMhost=np.log(10**grid.state.host.lmean)\n sigmaDMhost=np.log(10**grid.state.host.lsigma)\n meanHost = np.exp(muDMhost + sigmaDMhost**2/2.)\n medianHost = np.exp(muDMhost) \n print(f\"Host: mean={meanHost}, median={medianHost}\")\n plt.ylim(0,ndm-1)\n plt.xlim(0,nz-1)\n zmax=zvals[-1]\n nz=zvals.size\n #DMbar, zeval = igm.average_DM(zmax, cumul=True, neval=nz+1)\n DM_cosmic = pcosmic.get_mean_DM(zvals, grid.state)\n\n \n #idea is that 1 point is 1, hence...\n zeval = zvals/dz\n DMEG_mean = (DM_cosmic+meanHost)/ddm\n DMEG_median = (DM_cosmic+medianHost)/ddm\n\n # Check median\n f_median = scipy.interpolate.interp1d(\n zvals, DM_cosmic+medianHost, \n fill_value='extrapolate')\n eval_DMEG = f_median(FRBZ)\n above = FRBDM > eval_DMEG\n print(f\"There are {np.sum(above)/len(FRBZ)} above the median\")\n\n if show_Macquart:\n plt.plot(zeval,DMEG_mean,color='gray',linewidth=2,\n label='Macquart relation (mean)')\n plt.plot(zeval,DMEG_median,color='gray',\n linewidth=2, ls='--',\n label='Macquart relation (median)')\n l=plt.legend(loc='lower right',fontsize=12)\n #l=plt.legend(bbox_to_anchor=(0.2, 0.8),fontsize=8)\n #for text in l.get_texts():\n #\ttext.set_color(\"white\")\n \n # limit to a reasonable range if logscale\n if log and vmnx[0] is None:\n themax=zDMgrid.max()\n themin=int(themax-4)\n themax=int(themax)\n plt.clim(themin,themax)\n \n ##### add FRB host galaxies at some DM/redshift #####\n if FRBZ is not None:\n iDMs=FRBDM/ddm\n iZ=FRBZ/dz\n # Restrict to plot range\n gd = (FRBDM < DMmax) & (FRBZ < zmax)\n plt.plot(iZ[gd],iDMs[gd],'ko',linestyle=\"\",markersize=2.)\n\n cbar=plt.colorbar(im,fraction=0.046, shrink=1.2,aspect=15,pad=0.05)\n cbar.set_label(label)\n\n fig_utils.set_fontsize(ax, fsize)\n \n plt.tight_layout()\n \n if show:\n plt.show()\n else:\n plt.savefig(outfile, dpi=300)\n print(f\"Wrote: {outfile}\")\n plt.close()","def clear(self):\n row, col = self.selected\n if self.cubes[row][col].value == 0:\n self.cubes[row][col].set_temp(0)","def clear_flags(self):\n self.flags.clear()","def clear(self):\n self.SetPoint = 0.0\n\n self.PTerm = 0.0\n self.ITerm = 0.0\n self.DTerm = 0.0\n self.last_error = 0.0\n\n # Windup Guard\n self.int_error = 0.0\n self.windup_guard = 20.0\n\n self.output = 0.0","def clear(self):\n self.SetPoint = 0.0\n\n self.PTerm = 0.0\n self.ITerm = 0.0\n self.DTerm = 0.0\n self.last_error = 0.0\n\n # Windup Guard\n self.int_error = 0.0\n self.windup_guard = 20.0\n\n self.output = 0.0","def clear(self):\n self.SetPoint = 0.0\n\n self.PTerm = 0.0\n self.ITerm = 0.0\n self.DTerm = 0.0\n self.last_error = 0.0\n\n # Windup Guard\n self.int_error = 0.0\n self.windup_guard = 20.0\n\n self.output = 0.0","def off(self):","def cleanup(self):\n self.subpixel, self.pixel = self.stepup(self.subpixel, self.pixel, AxisDistance.pixelsize)\n self.pixel, self.tile = self.stepup(self.pixel, self.tile, AxisDistance.tilesize)","def segmentNeedle(self):\n #productive #event\n profprint()\n if self.fiducialButton.isEnabled():\n print \"new checked state: \",not self.fiducialButton.checked\n self.onStartStopGivingNeedleTipsToggled(not self.fiducialButton.checked)","def reset() -> None:\n\t_flag.clear()","def freespaceImageAnalysis( fids, guesses = None, fit=True, bgInput=None, bgPcInput=None, shapes=[None], zeroCorrection=0, zeroCorrectionPC=0,\n keys=None, fitModule=bump, extraPicDictionaries=None, newAnnotation=False, onlyThisPic=None, pltVSize=5, \n plotSigmas=False, plotCounts=False, manualColorRange=None, calcTemperature=False, clearOutput=True, \n dataRange=None, guessTemp=10e-6, trackFitCenter=False, picsPerRep=1, startPic=0, binningParams=None, \n win=pw.PictureWindow(), transferAnalysisOpts=None, tferBinningParams=None, tferWin= pw.PictureWindow(),\n extraTferAnalysisArgs={}, emGainSetting=300, lastConditionIsBackGround=True, showTferAnalysisPlots=True,\n show2dFitsAndResiduals=True, plotFitAmps=False, indvColorRanges=False, fitF2D=gaussian_2d.f_notheta, \n rmHighCounts=True, useBase=True, weightBackgroundByLoading=True, returnPics=False, forceNoAnnotation=False):\n fids = [fids] if type(fids) == int else fids\n keys = [None for _ in fids] if keys is None else keys\n sortedStackedPics = {}\n initThresholds = [None]\n picsForBg = []\n bgWeights = []\n isAnnotatedList = []\n for filenum, fid in enumerate(fids):\n if transferAnalysisOpts is not None:\n res = ta.stage1TransferAnalysis( fid, transferAnalysisOpts, useBase=useBase, **extraTferAnalysisArgs )\n (initAtoms, tferAtoms, initAtomsPs, tferAtomsPs, key, keyName, initPicCounts, tferPicCounts, repetitions, initThresholds,\n avgPics, tferThresholds, initAtomImages, tferAtomImages, basicInfoStr, ensembleHits, groupedPostSelectedPics, isAnnotated) = res\n isAnnotatedList.append(isAnnotated)\n # assumes that you only want to look at the first condition. \n for varPics in groupedPostSelectedPics: # don't remember why 0 works if false...\n picsForBg.append(varPics[-1 if lastConditionIsBackGround else 0])\n bgWeights.append(len(varPics[0]))\n allFSIPics = [ varpics[0][startPic::picsPerRep] for varpics in groupedPostSelectedPics]\n if showTferAnalysisPlots:\n fig, axs = plt.subplots(1,2)\n mp.makeAvgPlts( axs[0], axs[1], avgPics, transferAnalysisOpts, ['r','g','b'] ) \n allFSIPics = [win.window( np.array(pics) ) for pics in allFSIPics]\n allFSIPics = ah.softwareBinning( binningParams, allFSIPics )\n elif type(fid) == int:\n ### For looking at either PGC imgs or FSI imgs \n with exp.ExpFile(fid) as file:\n # I think this only makes sense if there is a specific bg pic in the rotation\n picsForBg.append(list(file.get_pics()))\n allFSIPics = file.get_pics()[startPic::picsPerRep]\n _, key = file.get_key()\n if len(np.array(key).shape) == 2:\n key = key[:,0]\n file.get_basic_info()\n allFSIPics = win.window( allFSIPics )\n allFSIPics = ah.softwareBinning( binningParams, allFSIPics )\n allFSIPics = np.reshape( allFSIPics, (len(key), int(allFSIPics.shape[0]/len(key)), allFSIPics.shape[1], allFSIPics.shape[2]) )\n else:\n ### Assumes given pics have the same start pic and increment (picsPerRep).\n # doesn't combine well w/ transfer analysis\n picsForBg.append(fid)\n allFSIPics = fid[startPic::picsPerRep]\n print(\"Assuming input is list of all pics, then splices to get FSI pics. Old code assumed the given were FSI pics.\")\n allFSIPics = win.window( allFSIPics )\n allFSIPics = ah.softwareBinning( binningParams, allFSIPics )\n allFSIPics = np.reshape( allFSIPics, (len(key), int(allFSIPics.shape[0]/len(key)), allFSIPics.shape[1], allFSIPics.shape[2]) )\n # ##############\n if keys[filenum] is not None:\n key = keys[filenum]\n for i, keyV in enumerate(key):\n keyV = misc.round_sig_str(keyV)\n sortedStackedPics[keyV] = np.append(sortedStackedPics[keyV], allFSIPics[i],axis=0) if (keyV in sortedStackedPics) else allFSIPics[i] \n if lastConditionIsBackGround:\n bgInput, pcBgInput = getBgImgs(picsForBg, startPic = startPic, picsPerRep = picsPerRep, rmHighCounts=rmHighCounts, bgWeights=bgWeights, \n weightBackgrounds=weightBackgroundByLoading)\n elif bgInput == 'lastPic':\n bgInput, pcBgInput = getBgImgs(picsForBg, startPic = picsPerRep-1, picsPerRep = picsPerRep, rmHighCounts=rmHighCounts, bgWeights=bgWeights,\n weightBackgrounds=weightBackgroundByLoading )\n if bgInput is not None: # was broken and not working if not given bg\n bgInput = win.window(bgInput)\n bgInput = ah.softwareBinning(binningParams, bgInput)\n if bgPcInput is not None:\n bgPcInput = win.window(bgPcInput)\n bgPcInput = ah.softwareBinning(binningParams, bgPcInput) \n \n if extraPicDictionaries is not None:\n if type(extraPicDictionaries) == dict:\n extraPicDictionaries = [extraPicDictionaries]\n for dictionary in extraPicDictionaries:\n for keyV, pics in dictionary.items():\n sortedStackedPics[keyV] = (np.append(sortedStackedPics[keyV], pics,axis=0) if keyV in sortedStackedPics else pics) \n sortedStackedKeyFl = [float(keyStr) for keyStr in sortedStackedPics.keys()]\n sortedKey, sortedStackedPics = ah.applyDataRange(dataRange, sortedStackedPics, list(sorted(sortedStackedKeyFl)))\n numVars = len(sortedStackedPics.items())\n if len(np.array(shapes).shape) == 1:\n shapes = [shapes for _ in range(numVars)] \n if guesses is None:\n guesses = [[None for _ in range(4)] for _ in range(numVars)]\n if len(np.array(bgInput).shape) == 2 or bgInput == None:\n bgInput = [bgInput for _ in range(numVars)]\n if len(np.array(bgPcInput).shape) == 2 or bgPcInput == None:\n bgPcInput = [bgPcInput for _ in range(numVars)]\n \n datalen, avgFitSigmas, images, hFitParams, hFitErrs, vFitParams, vFitErrs, fitParams2D, fitErrs2D = [{} for _ in range(9)]\n titles = ['Bare', 'Photon-Count', 'Bare-mbg', 'Photon-Count-mbg']\n assert(len(sortedKey)>0)\n for vari, keyV in enumerate(sortedKey):\n keyV=misc.round_sig_str(keyV)\n if vari==0:\n initKeyv = keyV\n varPics = sortedStackedPics[keyV]\n # 0 is init atom pics for post-selection on atom number... if we wanted to.\n expansionPics = rmHighCountPics(varPics,7000) if rmHighCounts else varPics\n datalen[keyV] = len(expansionPics)\n expPhotonCountImage = photonCounting(expansionPics, 120)[0] / len(expansionPics)\n bgPhotonCountImage = np.zeros(expansionPics[0].shape) if bgPcInput[vari] is None else bgPcInput[vari]\n expAvg = np.mean(expansionPics, 0)\n bgAvg = np.zeros(expansionPics[0].shape) if (bgInput[vari] is None or len(bgInput[vari]) == 1) else bgInput[vari]\n \n if bgPhotonCountImage is None:\n print('no bg photon', expAvg.shape)\n bgPhotonCount = np.zeros(photonCountImage.shape)\n avg_mbg = expAvg - bgAvg\n avg_mbgpc = expPhotonCountImage - bgPhotonCountImage\n images[keyV] = [expAvg, expPhotonCountImage, avg_mbg, avg_mbgpc]\n hFitParams[keyV], hFitErrs[keyV], vFitParams[keyV], vFitErrs[keyV], fitParams2D[keyV], fitErrs2D[keyV] = [[] for _ in range(6)]\n for imnum, (im, guess) in enumerate(zip(images[keyV], guesses[vari])):\n if fit:\n # fancy guess_x and guess_y values use the initial fitted value, typically short time, as a guess.\n _, pictureFitParams2d, pictureFitErrors2d, v_params, v_errs, h_params, h_errs = ah.fitPic(\n im, guessSigma_x=5, guessSigma_y=5, showFit=False, \n guess_x=None if vari==0 else fitParams2D[initKeyv][imnum][1], guess_y=None if vari==0 else fitParams2D[initKeyv][imnum][2],\n fitF=fitF2D)\n fitParams2D[keyV].append(pictureFitParams2d)\n fitErrs2D[keyV].append(pictureFitErrors2d)\n hFitParams[keyV].append(h_params)\n hFitErrs[keyV].append(h_errs)\n vFitParams[keyV].append(v_params)\n vFitErrs[keyV].append(v_errs)\n # conversion from the num of pixels on the camera to microns at the focus of the tweezers\n cf = 16e-6/64\n mins, maxes = [[], []]\n imgs_ = np.array(list(images.values()))\n for imgInc in range(4):\n if indvColorRanges:\n mins.append(None)\n maxes.append(None)\n elif manualColorRange is None:\n mins.append(min(imgs_[:,imgInc].flatten()))\n maxes.append(max(imgs_[:,imgInc].flatten()))\n else:\n mins.append(manualColorRange[0])\n maxes.append(manualColorRange[1])\n numVariations = len(images)\n if onlyThisPic is None:\n fig, axs = plt.subplots(numVariations, 4, figsize=(20, pltVSize*numVariations))\n if numVariations == 1:\n axs = np.array([axs])\n bgFig, bgAxs = plt.subplots(1, 2, figsize=(20, pltVSize))\n else:\n numRows = int(np.ceil((numVariations+3)/4))\n fig, axs = plt.subplots(numRows, 4 if numVariations>1 else 3, figsize=(20, pltVSize*numRows))\n avgPicAx = axs.flatten()[-3]\n avgPicFig = fig\n bgAxs = [axs.flatten()[-1], axs.flatten()[-2]]\n bgFig = fig\n if show2dFitsAndResiduals:\n fig2d, axs2d = plt.subplots(*((2,numVariations) if numVariations>1 else (1,2)))\n keyPlt = np.zeros(len(images))\n (totalSignal, hfitCenter, hFitCenterErrs, hSigmas, hSigmaErrs, h_amp, hAmpErrs, vfitCenter, vFitCenterErrs, vSigmas, vSigmaErrs, v_amp, \n vAmpErrs, hSigma2D, hSigma2dErr, vSigma2D, vSigma2dErr) = [np.zeros((len(images), 4)) for _ in range(17)]\n \n for vari, ((keyV,ims), hParamSet, hErr_set, vParamSet, vErr_set, paramSet2D, errSet2D) in enumerate(zip(\n images.items(), *[dic.values() for dic in [hFitParams, hFitErrs, vFitParams, vFitErrs, fitParams2D, fitErrs2D]])):\n for which in range(4):\n if onlyThisPic is None:\n (im, ax, title, min_, max_, hparams, hErrs, vparams, vErrs, param2d, err2d\n ) = [obj[which] for obj in (ims, axs[vari], titles, mins, maxes, hParamSet, hErr_set, vParamSet, vErr_set, paramSet2D, errSet2D)] \n else:\n which = onlyThisPic\n ax = axs.flatten()[vari]\n (im, title, min_, max_, hparams, hErrs, vparams, vErrs, param2d, err2d\n ) = [obj[which] for obj in (ims, titles, mins, maxes, hParamSet, hErr_set, vParamSet, vErr_set, paramSet2D, errSet2D)] \n h_amp[vari][which], hfitCenter[vari][which], hSigmas[vari][which] = hparams[0], hparams[1], hparams[2]*cf*1e6\n hAmpErrs[vari][which], hFitCenterErrs[vari][which], hSigmaErrs[vari][which] = hErrs[0], hErrs[1], hErrs[2]*cf*1e6\n v_amp[vari][which], vfitCenter[vari][which], vSigmas[vari][which] = vparams[0], vparams[1], vparams[2]*cf*1e6\n vAmpErrs[vari][which], vFitCenterErrs[vari][which], vSigmaErrs[vari][which] = vErrs[0], vErrs[1], vErrs[2]*cf*1e6\n hSigma2D[vari][which], hSigma2dErr[vari][which], vSigma2D[vari][which], vSigma2dErr[vari][which] = [\n val*cf*1e6 for val in [param2d[-3], err2d[-3], param2d[-2], err2d[-2]]]\n \n totalSignal[vari][which] = np.sum(im.flatten())\n keyPlt[vari] = keyV\n res = mp.fancyImshow(fig, ax, im, imageArgs={'cmap':dark_viridis_cmap, 'vmin':min_, 'vmax':max_}, \n hFitParams=hparams, vFitParams=vparams, fitModule=fitModule, flipVAx = True, fitParams2D=param2d)\n ax.set_title(keyV + ': ' + str(datalen[keyV]) + ';\\n' + title + ': ' + misc.errString(hSigmas[vari][which],hSigmaErrs[vari][which]) \n + r'$\\mu m$ sigma, ' + misc.round_sig_str(totalSignal[vari][which],5), fontsize=12) \n if show2dFitsAndResiduals:\n X, Y = np.meshgrid(np.arange(len(im[0])), np.arange(len(im)))\n data_fitted = fitF2D((X,Y), *param2d)\n fitProper = data_fitted.reshape(im.shape[0],im.shape[1])\n ax1 = axs2d[0] if numVariations == 1 else axs2d[0,vari]\n ax2 = axs2d[1] if numVariations == 1 else axs2d[1,vari]\n imr = ax1.imshow(fitProper, vmin=min_, vmax=max_)\n mp.addAxColorbar(fig2d, ax1, imr)\n ax1.contour(np.arange(len(im[0])), np.arange(len(im)), fitProper, 4, colors='w', alpha=0.2)\n imr = ax2.imshow(fitProper-im)\n mp.addAxColorbar(fig2d, ax2, imr)\n ax2.contour(np.arange(len(im[0])), np.arange(len(im)), fitProper, 4, colors='w', alpha=0.2)\n if onlyThisPic is not None:\n break\n \n mp.fancyImshow(avgPicFig, avgPicAx, np.mean([img[onlyThisPic] for img in images.values()],axis=0), imageArgs={'cmap':dark_viridis_cmap},flipVAx = True)\n avgPicAx.set_title('Average Over Variations')\n ### Plotting background and photon counted background\n mp.fancyImshow(bgFig, bgAxs[0], bgAvg, imageArgs={'cmap':dark_viridis_cmap},flipVAx = True) \n bgAxs[0].set_title('Background image (' + str(len(picsForBg)/picsPerRep) + ')')\n mp.fancyImshow(bgFig, bgAxs[1], bgPhotonCountImage, imageArgs={'cmap':dark_viridis_cmap},flipVAx = True) \n bgAxs[1].set_title('Photon counted background image (' + str(len(picsForBg)/picsPerRep) + ')')\n fig.subplots_adjust(left=0,right=1,bottom=0.1, hspace=0.2, **({'top': 0.7, 'wspace': 0.4} if (onlyThisPic is None) else {'top': 0.9, 'wspace': 0.3}))\n \n disp.display(fig)\n temps, tempErrs, tempFitVs, = [],[],[]\n if calcTemperature: \n for sigmas, sigmaerrs in zip([hSigmas, vSigmas, hSigma2D, vSigma2D],[hSigmaErrs, vSigmaErrs, hSigma2dErr, vSigma2dErr]):\n mbgSigmas = np.array([elt[2] for elt in sigmas])\n mbgSigmaErrs = np.array([elt[2] for elt in sigmaerrs])\n myGuess = [0.0, min((mbgSigmas)*1e-6), guessTemp]\n temp, fitV, cov = ah.calcBallisticTemperature(keyPlt*1e-3, (mbgSigmas)*1e-6, guess = myGuess, sizeErrors = mbgSigmaErrs)\n error = np.sqrt(np.diag(cov))\n temps.append(temp)\n tempErrs.append(error[2])\n tempFitVs.append(fitV)\n numAxisCol = int(plotSigmas) + int(plotCounts) + int(trackFitCenter)\n if numAxisCol != 0:\n fig2, axs = plt.subplots(1, numAxisCol, figsize = (15, 5)) \n fig2.subplots_adjust(top=0.75, wspace = 0.4)\n colors = ['b','k','c','purple']\n if plotSigmas:\n ax = (axs if numAxisCol == 1 else axs[0]) \n stdStyle = dict(marker='o',linestyle='',capsize=3)\n if onlyThisPic is not None:\n ax.errorbar(keyPlt, hSigmas[:,onlyThisPic], hSigmaErrs[:,onlyThisPic], color=colors[0], label='h '+titles[onlyThisPic], **stdStyle);\n ax.errorbar(keyPlt, hSigma2D[:,onlyThisPic], hSigma2dErr[:,onlyThisPic], color=colors[1], label='2dh '+titles[onlyThisPic], **stdStyle);\n ax.errorbar(keyPlt, vSigmas[:,onlyThisPic], vSigmaErrs[:,onlyThisPic], color=colors[2], label='v '+titles[onlyThisPic], **stdStyle);\n ax.errorbar(keyPlt, vSigma2D[:,onlyThisPic], vSigma2dErr[:,onlyThisPic], color=colors[3], label='2dv '+titles[onlyThisPic], **stdStyle);\n else:\n for whichPic in range(4):\n ax.errorbar(keyPlt, hSigmas[:,whichPic], hSigmaErrs[:,whichPic], color='b', label='h '+titles[whichPic], **stdStyle);\n ax.errorbar(keyPlt, vSigmas[:,whichPic], vSigmaErrs[:,whichPic], color='c', label='v '+titles[whichPic], **stdStyle);\n ax.set_ylim(max(0,ax.get_ylim()[0]),min([ax.get_ylim()[1],5]))\n ax.set_ylabel(r'Fit Sigma ($\\mu m$)')\n \n if calcTemperature:\n # converting time to s, hSigmas in um \n xPoints = np.linspace(min(keyPlt), max(keyPlt))*1e-3\n for num, fitV in enumerate(tempFitVs):\n #ax.plot(xPoints*1e3, LargeBeamMotExpansion.f(xPoints, *myGuess)*1e6, label = 'guess')\n ax.plot(xPoints*1e3, LargeBeamMotExpansion.f(xPoints, *fitV)*1e6, color=colors[num])\n ax.legend()\n\n if plotFitAmps: \n ax = (axs if numAxisCol == 1 else axs[0])\n ampAx = ax.twinx()\n\n if onlyThisPic is not None:\n ampAx.errorbar(keyPlt, h_amp[:,onlyThisPic], hAmpErrs[:,onlyThisPic], label='h '+titles[onlyThisPic], color = 'orange', **stdStyle);\n ampAx.errorbar(keyPlt, v_amp[:,onlyThisPic], vAmpErrs[:,onlyThisPic], label='v '+titles[onlyThisPic], color = 'r', **stdStyle);\n else:\n for whichPic in range(4):\n ampAx.errorbar(keyPlt, h_amp[:,whichPic], hAmpErrs[:,whichPic], label='h '+titles[whichPic], color = 'orange', **stdStyle);\n ampAx.errorbar(keyPlt, v_amp[:,whichPic], vAmpErrs[:,whichPic], label='v '+titles[whichPic], color = 'r', **stdStyle);\n [tick.set_color('red') for tick in ampAx.yaxis.get_ticklines()]\n [tick.set_color('red') for tick in ampAx.yaxis.get_ticklabels()]\n ampAx.set_ylabel(r'Fit h_amps', color = 'r')\n \n hTotalPhotons, vTotalPhotons = None, None\n if plotCounts:\n # numAxCol = 1: ax = axs\n # numAxCol = 2: plotSigmas + plotCounts -- ax = axs[1]\n # numAxCol = 2: plotCounts + trackFitCenter -- ax = axs[0]\n # numAxCol = 3: ax = axs[1]\n if numAxisCol == 1:\n ax = axs\n elif numAxisCol == 2:\n ax = axs[1 if plotSigmas else 0]\n else:\n ax = axs[1]\n # Create axis to plot photon counts\n ax.set_ylabel(r'Integrated signal')\n photon_axis = ax.twinx()\n # This is not currently doing any correct for e.g. the loading rate.\n countToCameraPhotonEM = 0.018577 / (emGainSetting/200) # the float is is EM200. \n countToScatteredPhotonEM = 0.018577 / 0.07 / (emGainSetting/200)\n\n if onlyThisPic is not None:\n # calculate number of photons\n hamp = h_amp[:,onlyThisPic]*len(expansionPics[0][0]) # Horizontal \"un\"normalization for number of columns begin averaged.\n vamp = v_amp[:,onlyThisPic]*len(expansionPics[0]) \n hsigpx = hSigmas[:,onlyThisPic]/(16/64) # Convert from um back to to pixels.\n vsigpx = vSigmas[:,onlyThisPic]/(16/64)\n htotalCountsPerPic = bump.area_under(hamp, hsigpx)\n vtotalCountsPerPic = bump.area_under(vamp, vsigpx)\n hTotalPhotons = countToScatteredPhotonEM*htotalCountsPerPic\n vTotalPhotons = countToScatteredPhotonEM*vtotalCountsPerPic\n ax.plot(keyPlt, totalSignal[:,onlyThisPic], marker='o', linestyle='', label=titles[onlyThisPic]);\n photon_axis.plot(keyPlt, hTotalPhotons, marker='o', linestyle='', color = 'r', label='Horizontal')\n photon_axis.plot(keyPlt, vTotalPhotons, marker='o', linestyle='', color = 'orange', label='Vertical')\n else:\n for whichPic in range(4):\n # See above comments\n amp = h_amp[:,whichPic]*len(expansionPics[0][0]) \n sig = hSigmas[:,whichPic]/(16/64) \n totalCountsPerPic = bump.area_under(amp, sig)\n hTotalPhotons = countToScatteredPhotonEM*totalCountsPerPic\n ax.plot(keyPlt, totalSignal[:,whichPic], marker='o', linestyle='', label=titles[whichPic]);\n photon_axis.plot(keyPlt, hTotalPhotons, marker='o', linestyle='', color = ['red', 'orange', 'yellow', 'pink'][whichPic]) \n ax.legend()\n photon_axis.legend()\n [tick.set_color('red') for tick in photon_axis.yaxis.get_ticklines()]\n [tick.set_color('red') for tick in photon_axis.yaxis.get_ticklabels()]\n photon_axis.set_ylabel(r'Fit-Based Avg Scattered Photon/Img', color = 'r')\n if trackFitCenter:\n #numaxcol = 1: ax = axs\n #numaxcol = 2: trackfitcenter + plothSigmas: ax = axs[1]\n #numaxcol = 2: trackfitcenter + plotCounts: ax = axs[1]\n #numaxcol = 3: ax = axs[2]\n ax = (axs if numAxisCol == 1 else axs[-1])\n if onlyThisPic is not None:\n #ax.errorbar(keyPlt, hfitCenter[:,onlyThisPic], hFitCenterErrs[:,onlyThisPic], marker='o', linestyle='', capsize=3, label=titles[onlyThisPic]);\n ax.errorbar(keyPlt, vfitCenter[:,onlyThisPic], vFitCenterErrs[:,onlyThisPic], marker='o', linestyle='', capsize=3, label=titles[onlyThisPic]);\n #def accel(t, x0, a):\n # return x0 + 0.5*a*t**2\n #accelFit, AccelCov = opt.curve_fit(accel, keyPlt*1e-3, hfitCenter[:,onlyThisPic], sigma = hFitCenterErrs[:,onlyThisPic])\n #fitx = np.linspace(keyPlt[0], keyPlt[-1])*1e-3\n #fity = accel(fitx, *accelFit)\n #ax.plot(fitx*1e3, fity)\n else:\n for whichPic in range(4):\n ax.errorbar(keyPlt, hfitCenter[:,whichPic], hFitCenterErrs[:,whichPic], marker='o', linestyle='', capsize=3, label=titles[whichPic]);\n #accelErr = np.sqrt(np.diag(AccelCov))\n fig2.legend()\n ax.set_ylabel(r'Fit Centers (pix)')\n ax.set_xlabel('time (ms)')\n \n if numAxisCol != 0:\n disp.display(fig2) \n \n if not forceNoAnnotation:\n for fid, isAnnotated in zip(fids, isAnnotatedList):\n if not isAnnotated:\n if type(fid) == int or type(fid) == type(''):\n if newAnnotation or not exp.checkAnnotation(fid, force=False, quiet=True, useBase=useBase):\n exp.annotate(fid, useBase=useBase)\n if clearOutput:\n disp.clear_output()\n if calcTemperature: \n for temp, err, label in zip(temps, tempErrs, ['Hor', 'Vert', 'Hor2D', 'Vert2D']): \n print(label + ' temperature = ' + misc.errString(temp*1e6, err*1e6) + 'uk')\n\n for fid in fids:\n if type(fid) == int:\n expTitle, _, lev = exp.getAnnotation(fid)\n expTitle = ''.join('#' for _ in range(lev)) + ' File ' + str(fid) + ': ' + expTitle\n disp.display(disp.Markdown(expTitle))\n with exp.ExpFile(fid) as file:\n file.get_basic_info()\n if trackFitCenter:\n pass\n #print('Acceleration in Mpix/s^2 = ' + misc.errString(accelFit[1], accelErr[1]))\n if transferAnalysisOpts is not None and showTferAnalysisPlots:\n colors, colors2 = misc.getColors(len(transferAnalysisOpts.initLocs()) + 2)#, cmStr=dataColor)\n pltShape = (transferAnalysisOpts.initLocsIn[-1], transferAnalysisOpts.initLocsIn[-2])\n # mp.plotThresholdHists([initThresholds[0][0],initThresholds[1][0]], colors, shape=pltShape)\n mp.plotThresholdHists([initThresholds[0][0], initThresholds[0][0]], colors, shape=[1,2])\n returnDictionary = {'images':images, 'fits':hFitParams, 'errs':hFitErrs, 'hSigmas':hSigmas, 'sigmaErrors':hSigmaErrs, 'dataKey':keyPlt, \n 'hTotalPhotons':hTotalPhotons, 'tempCalc':temps, 'tempCalcErr':tempErrs, 'initThresholds':initThresholds[0], \n '2DFit':fitParams2D, '2DErr':fitErrs2D, 'bgPics':picsForBg, 'dataLength':datalen}\n if returnPics: \n returnDictionary['pics'] = sortedStackedPics\n return returnDictionary","def test_one_center(self):\n sv=system_vars_c().init_xyzlike([ [8, [0.0, 0.0, 0.0]]])\n atom2rcut=np.array([5.0])\n g = dft.gen_grid.Grids(sv)\n g.level = 1 # precision as implemented in pyscf\n g.radi_method=leggauss_ab\n g.build(atom2rcut=atom2rcut)\n\n #print( max( np.linalg.norm(g.coords, axis=1) ) )\n #print( g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0 )\n self.assertAlmostEqual(max( np.linalg.norm(g.coords, axis=1) ), 4.9955942742763986)\n self.assertAlmostEqual(g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0)\n self.assertEqual(len(g.weights), 6248)"],"string":"[\n \"def f_fixed(self):\\n self.fx_free = self.fy_free = self.fz_free = False\\n return self\",\n \"def align(): # open EH and fast shutter\\n\\t#marAuxiliary.closeMarShield()\\n\\td2in()\\n\\td3in()\\n\\tsh('o')\",\n \"def test_DFT_rect(centering='FFTRECT', outdir=None, outname='DFT1R_', npix=None, sampling=10., nlamd=None):\\n\\n print \\\"Testing DFT, style = \\\"+centering\\n\\n\\n npupil = 156\\n pctr = int(npupil/2)\\n s = (npupil,npupil)\\n\\n\\n # make things rectangular:\\n if nlamd is None and npix is None:\\n nlamd = (10,20)\\n npix = [val*sampling for val in nlamd] #(100, 200) \\n elif npix is None:\\n npix = [val*sampling for val in nlamd] #(100, 200) \\n elif nlamd is None:\\n nlamd = [val/sampling for val in npix]\\n u = nlamd\\n print u\\n #(u, float(u)/npix[0]*npix[1])\\n #npix = (npix, 2*npix)\\n\\n\\n # FFT style\\n mft1 = matrixDFT.MatrixFourierTransform(centering=centering)\\n\\n #ctr = (float(npupil)/2.0 + mft1.offset(), float(npupil)/2.0 + mft1.offset())\\n ctr = (float(npupil)/2.0 , float(npupil)/2.0)\\n #print ctr\\n pupil = makedisk(s=s, c=ctr, r=float(npupil)/2.0001, t=np.float64, grey=0)\\n\\n pupil[0:60, 0:60] = 0\\n pupil[0:10] = 0\\n\\n pupil /= np.sqrt(pupil.sum())\\n\\n plt.clf()\\n plt.subplots_adjust(left=0.02, right=0.98)\\n plt.subplot(141)\\n\\n pmx = pupil.max()\\n plt.imshow(pupil, vmin=0, vmax=pmx*1.5)\\n\\n\\n if outdir is not None:\\n fits.PrimaryHDU(pupil.astype(np.float32)).writeto(outdir+os.sep+outname+\\\"pupil.fits\\\", clobber=True)\\n\\n a = mft1.perform(pupil, u, npix)\\n\\n pre = (abs(pupil)**2).sum() \\n post = (abs(a)**2).sum() \\n ratio = post / pre\\n calcr = 1./(1.0*u[0]*u[1] *npix[0]*npix[1]) # multiply post by this to make them equal\\n print \\\"Pre-FFT total: \\\"+str( pre)\\n print \\\"Post-FFT total: \\\"+str( post )\\n print \\\"Ratio: \\\"+str( ratio)\\n #print \\\"Calc ratio : \\\"+str( calcr)\\n #print \\\"uncorrected: \\\"+str( ratio/calcr)\\n\\n\\n complexinfo(a, str=\\\",ft1 asf\\\")\\n asf = a.real.copy()\\n if outdir is not None:\\n fits.PrimaryHDU(asf.astype(np.float32)).writeto(outdir+os.sep+outname+\\\"asf.fits\\\", clobber=True)\\n cpsf = a * a.conjugate()\\n psf = cpsf.real.copy()\\n if outdir is not None:\\n fits.PrimaryHDU(psf.astype(np.float32)).writeto(outdir+os.sep+outname+\\\"psf.fits\\\", clobber=True)\\n\\n ax=plt.subplot(142)\\n plt.imshow(asf, norm=matplotlib.colors.LogNorm(1e-8, 1.0))\\n ax.set_title='ASF'\\n\\n ax=plt.subplot(143)\\n plt.imshow(psf, norm=matplotlib.colors.LogNorm(1e-8, 1.0))\\n ax.set_title='PSF'\\n\\n plt.subplot(144)\\n\\n pupil2 = mft1.inverse(a, u, npupil)\\n pupil2r = (pupil2 * pupil2.conjugate()).real\\n plt.imshow( pupil2r, vmin=0,vmax=pmx*1.5*0.01) # FIXME flux normalization is not right?? I think this has to do with squaring the pupil here, that's all.\\n plt.gca().set_title='back to pupil'\\n plt.draw()\\n print \\\"Post-inverse FFT total: \\\"+str( abs(pupil2r).sum() )\\n print \\\"Post-inverse pupil max: \\\"+str(pupil2r.max())\\n\\n plt.suptitle('Matrix DFT with rectangular arrays using centering={0}'.format(centering))\\n\\n plt.savefig('test_DFT_rectangular_results_{0}.pdf'.format(centering))\",\n \"def proz_manually ():\\r\\n Check_180turn(left_boundary,right_boundary)\\r\\n ABS() # Baseline correction \\r\\n XCMD(\\\"closeall\\\",WAIT_TILL_DONE)\",\n \"def clear(self):\\n self.np.fill(OFF)\\n self.np.show()\\n return True\",\n \"def full_reset(self):\\n self.at_cmd('CFUN=1')\",\n \"def zguider():\\n gzero.gxoff = camera.status.guider[0] + gzero.gxoff\\n gzero.gyoff = camera.status.guider[1] + gzero.gyoff\\n guider(0,0)\\n f = open('/data/guidezero','w')\\n cPickle.dump(gzero,f)\\n f.close()\",\n \"def setNoZeroColor():\\n dislin.nobgd()\",\n \"def terminatePlane3D():\\n dislin.grffin()\",\n \"def reset(self):\\n super(PolygonTool, self).reset()\\n # self.__nsides = None\\n # self.__increment = None\\n # self.__external = False # make this adjustable?\\n self.__center = None\\n for _i in range(self.__nsides):\\n self.__xpts[_i] = 0.0\\n self.__ypts[_i] = 0.0\",\n \"def test_offcenter(self):\\n actual = cm.ring_mask((5, 5), 1, 2, center=(2, 3))\\n expected = np.array([[False, False, False, True, False],\\n [False, False, True, False, True],\\n [False, True, False, False, False],\\n [False, False, True, False, True],\\n [False, False, False, True, False]])\\n self.assertIsNone(np.testing.assert_array_equal(actual, expected))\",\n \"def fill_single_world():\\n if not front_is_clear():\\n if not right_is_clear():\\n if not left_is_clear():\\n put_beeper()\",\n \"def cerrar(self):\\n self.x0 = np.array(self.x0, dtype=float)\\n self.x = np.array(self.x, dtype=float)\\n self.tipos = np.array(self.tipos, dtype=int)\\n self.mask_fr = self.tipos == 1\\n self.mask_in = self.tipos == 2\\n self.num_fr = np.sum(self.mask_fr)\\n self.num_in = np.sum(self.mask_in)\\n self.open = False\",\n \"def resetAlignmentCenter(self):\\n cent = self.TiltSeries_._TiltAlignmentParas.cent\\n imdimX = self.TiltSeries_._imdimX\\n imdimY = self.TiltSeries_._imdimY\\n print(imdimX, imdimY)\\n if cent[0] != imdimX//2+1 or cent[1] != imdimY//2+1:\\n #rint \\\"Centers do not match: cent=\\\"+str(cent)+\\\", imdim=\\\"+str(imdim)\\n self.TiltSeries_._TiltAlignmentParas.cent = [imdimX//2+1, imdimY//2+1]\",\n \"def reset_mask(self):\\n\\n self.mask = np.ones(self.dispersion.shape, dtype=bool)\",\n \"def ToggleAllGizmoLocalMode( self ):\\n\\n value = self.gizmoMgr.GetGizmoLocal( 'pos' )\\n self.gizmoMgr.SetGizmoLocal( 'pos', not value )\\n self.gizmoMgr.SetGizmoLocal( 'rot', not value )\\n self.gizmoMgr.SetGizmoLocal( 'scl', not value )\",\n \"def test_offcenter(self):\\n actual = cm.circle_mask((5, 5), 2, center=(2, 3))\\n expected = np.array([[False, False, False, True, False],\\n [False, False, True, True, True],\\n [False, True, True, True, True],\\n [False, False, True, True, True],\\n [False, False, False, True, False]])\\n self.assertIsNone(np.testing.assert_array_equal(actual, expected))\",\n \"def Face_Cycle_L(self,event):\\n t=event.widget.find_closest(event.x, event.y)[0]\\n u=int(self.canvas.itemcget(t,\\\"tags\\\").split()[1])\\n if u not in [4,13,22,31,40,49]:\\n v=self.colours_face[self.ocol[self.canvas.itemcget(t,\\\"fill\\\")][0]][0][0]\\n self.cubestring[int(u)]=v\\n self.cube.cube = self.cubestring#Cube.set(self.cubestring)\\n self.map_face()\\n else:\\n print(\\\"Cant Change Center Cubit\\\")\",\n \"def modes_off(self):\\n bm = self.fitsimage.get_bindmap()\\n bm.reset_mode(self.fitsimage)\",\n \"def ClearDisplay():\\n display.fill(0)\",\n \"def m_fixed(self):\\n self.mx_free = self.my_free = self.mz_free = False\\n return self\",\n \"def update_flags(self):\\n # view mode, filled vs wirefrom\\n if self.view['wireframe']:\\n gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_LINE)\\n else:\\n gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_FILL)\\n\\n # set fullscreen or windowed\\n self.set_fullscreen(fullscreen=self.view['fullscreen'])\\n\\n # backface culling on or off\\n if self.view['cull']:\\n gl.glEnable(gl.GL_CULL_FACE)\\n else:\\n gl.glDisable(gl.GL_CULL_FACE)\\n\\n # case where we WANT an axis and NO vertexlist\\n # is stored internally\\n if self.view['axis'] and self._axis is None:\\n from .. import creation\\n # create an axis marker sized relative to the scene\\n axis = creation.axis(origin_size=self.scene.scale / 100)\\n # create ordered args for a vertex list\\n args = rendering.mesh_to_vertexlist(axis)\\n # store the axis as a reference\\n self._axis = self.batch.add_indexed(*args)\\n\\n # case where we DON'T want an axis but a vertexlist\\n # IS stored internally\\n elif not self.view['axis'] and self._axis is not None:\\n # remove the axis from the rendering batch\\n self._axis.delete()\\n # set the reference to None\\n self._axis = None\",\n \"def remove_spurious_landmarks(self):\\r\\n \\r\\n remove = np.argwhere(self.lm_counter < 0)\\r\\n self.lm = np.delete(self.lm, remove, axis=0)\\r\\n self.lm_cvar = np.delete(self.lm_cvar, remove, axis=0)\\r\\n self.lm_counter = np.delete(self.lm_counter, remove)\\r\\n \\r\\n return # Replace this.\\r\",\n \"def _mask_mode(self):\\r\\n self._mode_select(0)\",\n \"def plot_clear():\\n plt.cla()\",\n \"def correct(self):\\n self.parent.copyCurrentWinState(self.pltw)\\n self.pltw.blklst[self.blkno][self.ypos] = self.data[1] - self.data[2]\\n self.pltw.updatePlot()\\n self.pltw.dirty = True\\n self.pltw.activecurv = self.cpos\\n self.parent.updateUI()\\n self.hide()\",\n \"def reset(self):\\n self.posXY = (0,0)\\n self.magXY = (1.0,1.0)\\n self.rot = 0.0\\n self.trans = 255\\n self.isDone = False\\n self.isFirst = True\\n\\n self.kill()\\n self.Group = pyglet.graphics.OrderedGroup(self.order)\\n self.isReady = self.check()\",\n \"def test_DFT_rect_adj():\\n test_DFT_rect(centering='ADJUSTIBLE', outname='DFT1Radj_')\",\n \"def reset_energizer_flag(self): \\r\\n self.energizer_flag = False\",\n \"def front_is_clear(): #py:front_is_clear\\n return RUR._front_is_clear_()\",\n \"def update_center(self): \\r\\n \\r\\n self.grfx[0].center = self.center\\r\\n\\r\\n self.update_bbox()\",\n \"def free_curvature(self) -> None:\\n self.n1.free = True\\n self.n2.free = True\",\n \"def clear_crossfilter1(self):\\n print ('Trigger clear')\\n self.query_dict = {}\\n self.plot_data = None\\n self.create_figure_new()\\n layout_doc.children[4].children[0] = self.p\",\n \"def enableRemoveDesign(self):\\n if self.mode.selectedShipHull.aftQuadInfo == None:\\n self.isDroneDesign = 1\\n self.enableRemoveDroneDesign()\\n else:\\n self.isDroneDesign = 0\\n self.enableRemoveShipDesign()\",\n \"def pixel_space(self):\\n self.drawer.settransform()\\n self.coordspace_bbox = [0, 0, self.width, self.height]\\n self.coordspace_transform = (1, 0, 0,\\n 0, 1, 0)\",\n \"def resetFrame(self):\\n with self.lock:\\n hbin = self.hbin\\n vbin = self.vbin\\n if hbin != 1:\\n self.setHBin(1)\\n if vbin != 1:\\n self.setVBin(1)\\n with self.lock:\\n self.expArea = self.defaultExpArea\\n x1, y1, x2, y2 = self.expArea\\n self.xsize = x2 - x1\\n self.ysize = y2 - y1\",\n \"def _set_up_acq_opt_direct(self):\\n raise NotImplementedError('Not implemented DiRect yet.')\",\n \"def reset(self):\\n if self.num == 1:\\n self.rect.centerx = 320\\n elif self.num == 2:\\n self.rect.centerx = 341\\n elif self.num == 3:\\n self.rect.centerx = 362\\n elif self.num == 4:\\n self.rect.centerx = 383\\n self.rect.centery = 371\\n self.centerx = self.rect.centerx\\n self.centery = self.rect.centery\\n\\n self.moving_right = False\\n self.moving_left = False\\n self.moving_up = True\\n self.moving_down = False\",\n \"def clear_crossfilter2(self):\\n print ('Trigger clear')\\n self.query_dict = {}\\n self.plot_data = None\\n self.create_figure_new()\\n layout_doc.children[4].children[1] = self.p\",\n \"def test_inverse( centering='SYMMETRIC'):\\n\\n\\n npupil = 300 #156\\n pctr = int(npupil/2)\\n npix = 100 #1024\\n u = 20 #100 # of lam/D\\n\\n npix, u = 2000, 200\\n s = (npupil,npupil)\\n\\n\\n\\n\\n mft1 = matrixDFT.MatrixFourierTransform(centering=centering)\\n\\n ctr = (float(npupil)/2.0, float(npupil)/2.0 )\\n #print ctr\\n pupil = makedisk(s=s, c=ctr, r=float(npupil)/2.0001, t=np.float64, grey=0)\\n pupil /= np.sqrt(pupil.sum())\\n\\n pupil[100:200, 30:50] = 0\\n pupil[0:50, 140:160] = 0\\n\\n plt.subplot(141)\\n plt.imshow(pupil)\\n\\n print \\\"Pupil 1 total:\\\", pupil.sum() \\n\\n a = mft1.perform(pupil, u, npix)\\n\\n asf = a.real.copy()\\n cpsf = a * a.conjugate()\\n psf = cpsf.real.copy()\\n print \\\"PSF total\\\", psf.sum()\\n \\n plt.subplot(142)\\n plt.imshow(psf, norm=matplotlib.colors.LogNorm(1e-8, 1.0))\\n\\n plt.subplot(143)\\n\\n pupil2 = mft1.inverse(a, u, npupil)\\n pupil2r = (pupil2 * pupil2.conjugate()).real\\n plt.imshow( pupil2r)\\n\\n print \\\"Pupil 2 total:\\\", pupil2r.sum() \\n\\n\\n\\n a2 = mft1.perform(pupil2r, u, npix)\\n psf2 = (a2*a2.conjugate()).real.copy()\\n print \\\"PSF total\\\", psf2.sum()\\n plt.subplot(144)\\n plt.imshow(psf2, norm=matplotlib.colors.LogNorm(1e-8, 1.0))\",\n \"def off_screen(self):\\n return self._x < 0\",\n \"def reset(self):\\n self.vrp = np.matrix([0.5, 0.5, 1])\\n self.vpn = np.matrix([0, 0, -1])\\n self.vup = np.matrix([0, 1, 0])\\n self.u = np.matrix([-1, 0, 0])\\n self.extent = [1., 1., 1.]\\n self.screen = [400., 400.]\\n self.offset = [20., 20.]\",\n \"def no_gradient_fusion():\\n pass\",\n \"def clean(self):\\n\\n if (self.clean_level == 'dusty') | (self.clean_level == 'clean'):\\n idx, = np.where(self['B_flag'] == 0)\\n self.data = self[idx, :]\\n\\n return\",\n \"def __reset_crosshair(self):\\n self.lhor.set_ydata(self.y_coord)\\n self.lver.set_xdata(self.x_coord)\",\n \"def clear():\\n\\tglobal _s\\n\\t_s.screen.fill(_s.back)\\n\\t_s.tab(0,0)\\n\\t_flip()\",\n \"def cla(self):\\n self.disable_mouse_rotation()\\n Axes.cla(self)\\n self.grid(rcParams['axes3d.grid'])\",\n \"def _switch(self):\\n self.fill= not self.fill\",\n \"def initializeDomainBorder(self):\\n #Read image of the structure\\n if (self.PictureExistance == \\\"'yes'\\\"):\\n self.__processImage()\\n #re-define the domain size with the layers of boundaries and ghost points\\n self.ny, self.nx = self.effectiveDomain.shape\\n print('Now the size of domain is %g and %g' %(self.ny, self.nx))\\n else:\\n self.isDomain = sp.empty([self.ny, self.nx], dtype = np.bool)\\n self.isSolid = sp.empty([self.ny, self.nx], dtype = np.bool)\\n self.isDomain, self.isSolid = defineGeometry(self.nx, self.ny)\\n if (self.PictureExistance == \\\"'yes'\\\"):\\n self.originalXdim = self.nx\\n self.isDomain = sp.empty([self.ny, self.nx], dtype = np.bool)\\n self.isSolid = sp.empty([self.ny, self.nx], dtype = np.bool)\\n #define the boundary position\\n if (self.isCycles == \\\"'yes'\\\"):\\n self.isBoundaryFluid2 = sp.empty([self.ny, self.nx], \\\\\\n dtype = np.bool)\\n# self.isFluidBoundary = sp.empty([self.ny, self.nx], dtype = np.bool)\\n self.isDomain[:, :] = 1; self.isSolid[:, :] = 0\\n for i in sp.arange(self.ny):\\n for j in sp.arange(self.nx):\\n if (self.effectiveDomain[i, j] == 0.0):\\n self.isDomain[i, j] = 0\\n self.isSolid[i, j] = 1\\n self.voidSpace = np.count_nonzero(self.isDomain)\\n print('The number of vexls in void space is %g.' % self.voidSpace)\\n print('The porosity of the layout is %f.' % (self.voidSpace / (self.isDomain.size)))\",\n \"def reset(self):\\n self.position = np.zeros(self.ndegres)\\n self.velocity = np.zeros(self.ndegres)\\n self.state = np.zeros(2*self.ndegres)\\n self.flag = 0\\n self.h_ref = np.array([self.ref for _ in range(self.horizon)])\\n self.action = np.zeros(self.ACTION_DIM) \\n self.h_action = np.zeros(self.ACTION_DIM*self.horizon)\",\n \"def unoccupied(self):\\n self.is_occupied = 0\\n for hex in self.fon:\\n hex.remove_neighbor()\\n hex.set_quality()\",\n \"def set_defaults(self):\\n if not self.HAS_DS9: # pragma: no cover\\n return\\n self.run('frame delete all')\\n self.run('wcs degrees')\\n if self.disp_parameters['tile']:\\n self.run('tile yes')\\n else:\\n self.run('tile no')\\n self.cs = str(self.disp_parameters['lock_image']).lower()\\n self.lock()\",\n \"def is_compact(self):\\n return self.n_rays()==0 and self.n_lines()==0\",\n \"def reset(self):\\r\\n # reset Wheel encoders\\r\\n self.start_time = time.time()\\r\\n [left_start, right_start] = self.Roomba.Query(43, 44)\\r\\n self.Motion.reset(left_start, right_start)\\r\\n # reset bumper\\r\\n self.bumper.reset()\\r\\n\\r\\n #reset grid world data\\r\\n self.action=[0.0,0.0]\\r\\n self.grid_state= [0,0,0]\\r\\n self.real_state = [0.0, 0.0, 0.0]\\r\\n self.trans_model = None\\r\\n pass\",\n \"def clear(self):\\n if self.flag == 0:\\n for coord in INDICES:\\n self.kill(coord)\\n self.chart[coord] = DEAD\",\n \"def fix(hobj):\\n\\n h.execute('create axon[2]', hobj)\\n\\n for sec in hobj.axon:\\n sec.L = 30\\n sec.diam = 1\\n hobj.axonal.append(sec=sec)\\n hobj.all.append(sec=sec) # need to remove this comment\\n\\n hobj.axon[0].connect(hobj.soma[0], 0.5, 0)\\n hobj.axon[1].connect(hobj.axon[0], 1, 0)\\n\\n h.define_shape()\",\n \"def setUseGizmos(value=True):\\n global cc\\n cc = not value\",\n \"def clear_transforms(self): # -> None:\\n ...\",\n \"def flip_faceup(self):\\r\\n self.faceup = True\",\n \"def cb_reset(event):\\n axDirichlet.cla()\\n # Reset Sliders\\n sAlpha0.reset() # resetが駄目！一番最初に戻ってしまう\\n sAlpha1.reset()\\n sAlpha2.reset()\\n alpha_update = [sAlpha0.val, sAlpha1.val, sAlpha2.val]\\n print('alpha_update=', alpha_update)\\n\\n # ML\\n lambda_ML = CatML.MLinfer(x_cat)\\n\\n axML.cla()\\n drawBarGraph( axML, \\\"ML\\\", lambda_ML, bar_y_max, col_ML ) # Draw Bar graph\\n\\n\\n # MAP\\n dirichlet.set_param(alpha_update)\\n lambda_MAP = CatMAP.MAPinfer(x_cat, dirichlet)\\n\\n axMAP.cla()\\n drawBarGraph( axMAP, \\\"MAP\\\", lambda_MAP, bar_y_max, col_MAP ) # Draw Bar Graph\\n\\n # Bayes\\n posteriorDirichlet.set_param(alpha_update)\\n posteriorDirichlet.calcPosterior(x_cat)\\n lambda_Bayes = np.zeros(3)\\n for k in range(3):\\n lambda_Bayes[k] = posteriorDirichlet.BayesInfer(k)\\n\\n axBayes.cla()\\n drawBarGraph( axBayes, \\\"Bayes\\\", lambda_Bayes, bar_y_max, col_Bayes ) # Draw Bar Graph\\n\\n draw_pdf_contours(axDirichlet, dirichlet, True) # Draw Dirichlet\\n\\n print('Reset')\\n print('lambda_ML =', lambda_ML)\\n print('lambda_MAP =', lambda_MAP)\\n print('lambda_Bayes=', lambda_Bayes)\\n draw_point(axDirichlet, lambda_ML, col_ML)\\n draw_point(axDirichlet, lambda_MAP, col_MAP)\\n draw_point(axDirichlet, lambda_Bayes, col_Bayes)\\n draw_point(axLikelihood, lambda_ML, col_ML)\\n draw_point(axPosteriorDirichlet, lambda_MAP, col_MAP)\\n draw_point(axPosteriorDirichlet, lambda_Bayes, col_Bayes)\\n\\n fig.canvas.draw_idle()\",\n \"def middlemakevisible(self, pos):\\n pass\",\n \"def testCoords1D(realSpace, fourierSpace, X, dx):\\n \\n def cosines(freqs, Nyquist, real, fourier, x):\\n for i in range(0, len(freqs)):\\n real = real + np.cos(2*np.pi * freqs[i] * x)\\n \\n fourier = np.fft.fftshift(np.fft.fft(real))\\n return real, fourier\\n \\n def gauss(sigma, mu, real, fourier, x): # Still need to fix\\n real = 1/(sigma * np.sqrt(2 * np.pi)) * np.exp( - (x - mu)**2 / (2 * sigma**2) )\\n fourier = np.fft.fftshift(real)\\n return real, fourier\\n \\n def window(w, real, fourier, x):\\n real = real*0 + 1\\n mask = np.abs(x)-w/2 < 0\\n real = real*mask\\n #fourier = np.fft.fftshift(np.fft.fft(real))\\n fourier = FFT1(real)\\n #f1 = np.fft.fft(real)\\n #ifft = np.fft.ifft(np.fft.fftshift(fourier))\\n #ifft = np.fft.ifft(np.fft.ifftshift(fourier))\\n ifft = IFFT1(fourier)\\n return real, fourier, ifft\\n \\n N = len(realSpace)\\n xVals = np.arange(-X/2, X/2 + dx, dx)\\n f = np.linspace(0, X, N)/X\\n const = 0*realSpace + 1\\n impulse = np.fft.fft(const)\\n #plt.plot(f, impulse)\\n cosines, impulses = cosines([1], X/2, const*0, f, xVals)\\n #plt.plot(xVals, cosines)\\n # plt.plot(f*X, np.abs(impulses))\\n gauss, gaussFT = gauss(1, 0, const*0, f, xVals)\\n window, sinc, iwindow = window(X/4, const, f, xVals)\\n plt.plot(f - f[-1]/2, np.abs(sinc))\\n #plt.plot(xVals, iwindow)\",\n \"def Face_Cycle_R(self,event):\\n t=event.widget.find_closest(event.x, event.y)[0]\\n u=int(self.canvas.itemcget(t,\\\"tags\\\").split()[1])\\n if u not in [4,13,22,31,40,49]:\\n v=self.colours_face[self.ocol[self.canvas.itemcget(t,\\\"fill\\\")][1]][0][0]\\n self.cubestring[u]=v\\n self.cube.cube = self.cubestring#Cube.set(self.cubestring)\\n self.map_face()\\n else:\\n print(\\\"Cant Change Center Cubit\\\")\",\n \"def debug_clear(self):\\n if self.display:\\n from capture_graphics_display import PacmanGraphics\\n if isinstance(self.display, PacmanGraphics):\\n self.display.clear_debug()\",\n \"def resetTransformations():\\n dislin.trfres()\",\n \"def all_off(self):\\n self.fill_off()\\n self.update()\\n self.fill_off()\\n self.update()\",\n \"def fiducial_evolution():\\n \\n # fiducial model\\n wangle = 180*u.deg\\n pk = pickle.load(open('../data/gd1_fiducial.pkl', 'rb'))\\n x = pk['x'].to(u.kpc)\\n xorig = x[:2]\\n \\n plt.close()\\n fig, ax = plt.subplots(1,1,figsize=(6,6))\\n \\n plt.sca(ax)\\n \\n Nsnap = 8\\n times = np.linspace(0,0.5,Nsnap)[::-1]\\n angles = np.linspace(0,322,Nsnap)[::-1]*u.deg\\n\\n for e, t in enumerate(times):\\n c = mpl.cm.Blues(0.05+0.85*(Nsnap-e)/Nsnap)\\n #a = 0.5 + 0.5*(Nsnap-e)/Nsnap\\n \\n pk = pickle.load(open('../data/gd1_fiducial_t{:.4f}.pkl'.format(t), 'rb'))\\n x = pk['x'].to(u.kpc)\\n x_, y_ = x[0], x[1]\\n \\n plt.plot(x_[120:-120], y_[120:-120], '.', color=c, ms=10, zorder=Nsnap-e, rasterized=False)\\n \\n xt = 24*np.cos(angles[e]+90*u.deg)\\n yt = 24*np.sin(angles[e]+90*u.deg)\\n if e<Nsnap-1:\\n txt = plt.text(xt, yt, '+ {:.2f} Gyr'.format(t), va='center', ha='center', fontsize='small', color='0.2', rotation=(angles[e]).value, zorder=10)\\n txt.set_bbox(dict(facecolor='w', alpha=0.7, ec='none'))\\n \\n plt.text(0, 24, 'Flyby', va='center', ha='center', fontsize='small', color='0.2')\\n\\n lim = 27\\n plt.xlim(-lim,lim)\\n plt.ylim(-lim,lim)\\n plt.gca().set_aspect('equal')\\n \\n plt.xlabel('x [kpc]')\\n plt.ylabel('y [kpc]')\\n \\n plt.tight_layout()\\n plt.savefig('../plots/loop_evolution.pdf')\",\n \"def clear(self):\\r\\n self.SetPoint = 0.0\\r\\n\\r\\n self.PTerm = 0.0\\r\\n self.ITerm = 0.0\\r\\n self.DTerm = 0.0\\r\\n self.last_error = 0.0\\r\\n\\r\\n # Windup Guard\\r\\n self.int_error = 0.0\\r\\n self.windup_guard = 20.0\\r\\n\\r\\n self.output = 0.0\",\n \"def before_flip(self):\\n from klibs.KLGraphics import blit\\n\\n if P.show_gaze_dot and self.el.recording:\\n try:\\n blit(self.tracker_dot, 5, self.el.gaze())\\n except RuntimeError:\\n pass\",\n \"def proz_noe():\\r\\n print(\\\"processing: \\\",CURDATA()[0]) \\r\\n Check_180turn(left_boundary,right_boundary)\\r\\n EFP() # Exponential window multiplication + Fourier Transformation + phase correction\\r\\n ABS() # Baseline correction \\r\\n Check_180turn(left_boundary,right_boundary)\",\n \"def enable3D(self):\\r\\n if(self.dataController.fileLoaded==True):\\r\\n self.dataController.toggleInteractiveMode()\\r\\n\\r\\n self.midsagittalView = False\\r\\n self.frontView = False\\r\\n self.topView = False\\r\\n self.bottomView = False\\r\\n self.threeDView = True\",\n \"def onSetToCustDims(self, evt):\\n\\t\\tself.halfResampleZ.Enable(0)\\n\\t\\tself.fourthResampleZ.Enable(0)\\n\\t\\t\\n\\t\\tfor obj in [self.factorLabel, self.dimLabel, self.newDimX, self.newDimY, self.newDimZ, self.factorX, self.factorY, self.factorZ]:\\n\\t\\t\\tobj.Enable(1)\\n\\t\\ttry:\\n\\t\\t\\trx = int(self.newDimX.GetValue())\\n\\t\\t\\try = int(self.newDimY.GetValue())\\n\\t\\t\\trz = int(self.newDimZ.GetValue())\\n\\t\\t\\tself.currSize = (rx, ry, rz)\\n\\t\\texcept:\\n\\t\\t\\tpass\",\n \"def flip(self):\\n \\n if self.faceup:\\n self.faceup = False\\n else:\\n self.faceup = True\",\n \"def zero(self):\\n\\t\\tself.angle = 0.0\\n\\t\\tself.draw()\\n\\t\\ttime.sleep(self.delay)\",\n \"def reset(self):\\n self.u0.fill(0.)\\n self.u1.fill(0.)\\n self.u2.fill(0.)\\n self.time = 0.\",\n \"def _e0s_center(self, hdr):\\n # Called E0SNano in OpenMIMS\\n # b field index and e0s center enabled added to sub dict from main nano header\\n d = {}\\n d['b field index'], d['detector'], d['start'], \\\\\\n d['step size'], d['count time'], d['center'], \\\\\\n d['80% width'], d['E0S center enabled'] = \\\\\\n unpack(self._bo + '5i 2d i', hdr.read(40))\\n\\n d['E0S center enabled'] = bool(d['E0S center enabled'])\\n d['count time'] /= 100 # 10 ms increments to seconds\\n if d['detector'] < 0:\\n d['detector'] = None\\n if d['b field index'] < 0:\\n d['b field index'] = None\\n return d\",\n \"def restorePositionsOfUnownedAntennas() :\\n if ( s.getInitializationFlag() == True ): return\\n unownedAnts = subarrayAntSetup( True )\\n progress(\\\"Setting positions of unowned and uninitialized antennas %s\\\" % helpers.formatAsRanges( unownedAnts) )\\n progress(\\\"....Pads\\\")\\n restoreAntCommand(pad, unownedAnts, subarray=DEFAULT)\\n progress( \\\"....Pad Offsets\\\" )\\n restoreAntCommand( padOffset, unownedAnts, subarray=DEFAULT )\\n progress(\\\"....Antenna positional offset and axis non-intersection\\\")\\n restoreAntCommand( antennaOffset, unownedAnts, subarray=DEFAULT )\\n restoreAntCommand( axisNonIntersection, unownedAnts, subarray=DEFAULT )\",\n \"def flip(self):\",\n \"def backToMiddlePos():\\n\\tprogMode(True) # Active le couple de servos\\n\\taxDriver.goToPosition(axDriver.BROADCASTID, 0x1FF) # Renvoie a la position 0x1FF\",\n \"def setup_draw(self):\\n pass\",\n \"def reset(self):\\r\\n self.x = self.initX\\r\\n self.y = self.initY\\r\\n self.dir= self.initDir\",\n \"def clickClearReferences(self, event):\\n self.whiteReference = None\\n self.lightBtn.color = '0.85'\\n self.darkReference = None\\n self.darkBtn.color = '0.85'\\n plt.pause(0.3)\\n self.axes.autoscale_view()\",\n \"def clear(self):\\n\\n self.index = 1\\n self.degen = 1.\\n self.nnnn_out = False\\n self.json_out = False\\n self.verbose = False\\n self.ipol = 0\\n self.ellip = 0.\\n self.nepts = 0\\n self.genfmt_order = 2\\n self.genfmt_vers = \\\"\\\"\\n self.exch_label = \\\"\\\"\\n self.rs = 0.\\n self.vint = 0.\\n self.xmu = 0.\\n self.edge = 0.\\n self.kf = 0.\\n self.rnorman = 0.\\n self.gamach = 0.\\n self.nepts = FEFF_maxpts\\n\\n dargs = dict(dtype=np.float64, order='F')\\n largs = dict(dtype=np.int32, order='F')\\n\\n self.evec = np.zeros(3, **dargs)\\n self.xivec = np.zeros(3, **dargs)\\n self.ipot = np.zeros(1+FEFF_maxleg, **largs)\\n self.beta = np.zeros(1+FEFF_maxleg, **dargs)\\n self.eta = np.zeros(2+FEFF_maxleg, **dargs)\\n self.ri = np.zeros(FEFF_maxleg, **dargs)\\n self.rat = np.zeros((3, 2+FEFF_maxleg), **dargs)\\n self.iz = np.zeros(1+FEFF_maxpot, **largs)\\n self.kfeff = np.zeros(FEFF_maxpts, **dargs)\\n self.real_phc = np.zeros(FEFF_maxpts, **dargs)\\n self.mag_feff = np.zeros(FEFF_maxpts, **dargs)\\n self.pha_feff = np.zeros(FEFF_maxpts, **dargs)\\n self.red_fact = np.zeros(FEFF_maxpts, **dargs)\\n self.lam = np.zeros(FEFF_maxpts, **dargs)\\n self.rep = np.zeros(FEFF_maxpts, **dargs)\\n self.nleg = 1\",\n \"def setup():\\n size(SPACE['w'], SPACE['h'])\\n colorMode(RGB, 1)\",\n \"def vis_mechanically_coupled_regions(img_dir,output_dir,data,dbscn_length,dbscn_min_size,display_not_save=False):\\n #Read in the image that is segmented/labelled for nuclei\\n img=imread(img_dir)\\n\\n #save plots to show clusters\\n fig = plt.figure(figsize=(6, 2))\\n ax0 = fig.add_subplot(131)\\n ax1 = fig.add_subplot(132)\\n ax3 = fig.add_subplot(133)\\n #show segmented image labels\\n ax0.imshow(img,aspect='auto') \\n ax0.axis('off')\\n #nuclear centroid color-coded by their orientation\\n img1=ax1.scatter(data[\\\"Y\\\"], data[\\\"X\\\"], c=data[\\\"angles\\\"],s=1)\\n ax1.set_xlim(0,img.shape[0])\\n ax1.set_ylim(img.shape[1],0)\\n plt.colorbar(img1)\\n ax1.axis('off')\\n\\n # plot the cluster assignments\\n img3=ax3.scatter(data[data[\\\"clusters\\\"]> -1][\\\"Y\\\"], data[data[\\\"clusters\\\"]> -1][\\\"X\\\"], \\n c=data[data[\\\"clusters\\\"]> -1][\\\"clusters\\\"],cmap=\\\"plasma\\\",s=1)\\n ax3.set_xlim(0,img.shape[0])\\n ax3.set_ylim(img.shape[1],0)\\n ax3.axis('off')\\n\\n #add titles\\n ax0.title.set_text('Segmented Image')\\n ax1.title.set_text('Filtered Orientation')\\n ax3.title.set_text('Clusters')\\n\\n if display_not_save:\\n plt.show()\\n else: \\n plt.savefig((output_dir+\\\"/\\\"+img_dir.rsplit('/', 1)[-1][:-4]+\\\"_\\\"+str(dbscn_length)+\\\"_\\\"+ str(dbscn_min_size)+\\\".png\\\"),dpi=600, bbox_inches = 'tight',pad_inches = 0)\\n fig.clf()\\n plt.close(fig)\\n plt.close('all')\\n \\n \\n del fig,ax0,ax1,ax3,img1,img3\",\n \"def clean_axes(axl):\\n cleanAxes(axl)\",\n \"def setPxMode(self, b):\\n self.setFlag(self.GraphicsItemFlag.ItemIgnoresTransformations, b)\",\n \"def clear(self):\\n self.cmd(0x33) # $33 8-bit mode\\n self.cmd(0x32) # $32 8-bit mode\\n self.cmd(0x28) # $28 8-bit mode\\n self.cmd(0x0C) # $0C 8-bit mode\\n self.cmd(0x06) # $06 8-bit mode\\n self.cmd(0x01) # $01 8-bit mode\",\n \"def _set_draw_mode(draw_mode):\\n###############################################################################\\n global _draw_mode\\n _draw_mode = draw_mode\",\n \"def fig_craco_fiducial(outfile='fig_craco_fiducial.png',\\n zmax=2.5,DMmax=2500,\\n show_Macquart=False,\\n log=True,\\n label='$\\\\\\\\log_{10} \\\\; p(DM_{\\\\\\\\rm EG},z)$',\\n Aconts=[0.01, 0.1, 0.5],\\n cmap='jet', show=False, figsize=None,\\n vmnx=(None,None),\\n grid=None, survey=None):\\n # Generate the grid\\n if grid is None or survey is None:\\n survey, grid = analy_H0_I.craco_mc_survey_grid()\\n\\n # Unpack\\n full_zDMgrid, zvals, dmvals = grid.rates, grid.zvals, grid.dmvals\\n FRBZ=survey.frbs['Z']\\n FRBDM=survey.DMEGs\\n \\n ##### imshow of grid #######\\n fsize = 14.\\n plt.figure(figsize=figsize)\\n ax1=plt.axes()\\n plt.sca(ax1)\\n \\n plt.xlabel('z')\\n plt.ylabel('${\\\\\\\\rm DM}_{\\\\\\\\rm EG}$')\\n #plt.title(title+str(H0))\\n \\n # Cut down grid\\n zvals, dmvals, zDMgrid = figures.proc_pgrid(\\n full_zDMgrid, \\n zvals, (0, zmax),\\n dmvals, (0, DMmax))\\n ddm=dmvals[1]-dmvals[0]\\n dz=zvals[1]-zvals[0]\\n nz, ndm = zDMgrid.shape\\n\\n # Contours\\n alevels = figures.find_Alevels(full_zDMgrid, Aconts, log=True)\\n \\n # Ticks\\n tvals, ticks = figures.ticks_pgrid(zvals)# , fmt='str4')\\n plt.xticks(tvals, ticks)\\n tvals, ticks = figures.ticks_pgrid(dmvals, fmt='int')# , fmt='str4')\\n plt.yticks(tvals, ticks)\\n\\n # Image \\n im=plt.imshow(zDMgrid.T,cmap=cmap,origin='lower', \\n vmin=vmnx[0], vmax=vmnx[1],\\n interpolation='None',\\n aspect='auto')\\n \\n styles=['--','-.',':']\\n ax=plt.gca()\\n cs=ax.contour(zDMgrid.T,levels=alevels,origin='lower',colors=\\\"white\\\",linestyles=styles)\\n\\n ax=plt.gca()\\n \\n muDMhost=np.log(10**grid.state.host.lmean)\\n sigmaDMhost=np.log(10**grid.state.host.lsigma)\\n meanHost = np.exp(muDMhost + sigmaDMhost**2/2.)\\n medianHost = np.exp(muDMhost) \\n print(f\\\"Host: mean={meanHost}, median={medianHost}\\\")\\n plt.ylim(0,ndm-1)\\n plt.xlim(0,nz-1)\\n zmax=zvals[-1]\\n nz=zvals.size\\n #DMbar, zeval = igm.average_DM(zmax, cumul=True, neval=nz+1)\\n DM_cosmic = pcosmic.get_mean_DM(zvals, grid.state)\\n\\n \\n #idea is that 1 point is 1, hence...\\n zeval = zvals/dz\\n DMEG_mean = (DM_cosmic+meanHost)/ddm\\n DMEG_median = (DM_cosmic+medianHost)/ddm\\n\\n # Check median\\n f_median = scipy.interpolate.interp1d(\\n zvals, DM_cosmic+medianHost, \\n fill_value='extrapolate')\\n eval_DMEG = f_median(FRBZ)\\n above = FRBDM > eval_DMEG\\n print(f\\\"There are {np.sum(above)/len(FRBZ)} above the median\\\")\\n\\n if show_Macquart:\\n plt.plot(zeval,DMEG_mean,color='gray',linewidth=2,\\n label='Macquart relation (mean)')\\n plt.plot(zeval,DMEG_median,color='gray',\\n linewidth=2, ls='--',\\n label='Macquart relation (median)')\\n l=plt.legend(loc='lower right',fontsize=12)\\n #l=plt.legend(bbox_to_anchor=(0.2, 0.8),fontsize=8)\\n #for text in l.get_texts():\\n #\\ttext.set_color(\\\"white\\\")\\n \\n # limit to a reasonable range if logscale\\n if log and vmnx[0] is None:\\n themax=zDMgrid.max()\\n themin=int(themax-4)\\n themax=int(themax)\\n plt.clim(themin,themax)\\n \\n ##### add FRB host galaxies at some DM/redshift #####\\n if FRBZ is not None:\\n iDMs=FRBDM/ddm\\n iZ=FRBZ/dz\\n # Restrict to plot range\\n gd = (FRBDM < DMmax) & (FRBZ < zmax)\\n plt.plot(iZ[gd],iDMs[gd],'ko',linestyle=\\\"\\\",markersize=2.)\\n\\n cbar=plt.colorbar(im,fraction=0.046, shrink=1.2,aspect=15,pad=0.05)\\n cbar.set_label(label)\\n\\n fig_utils.set_fontsize(ax, fsize)\\n \\n plt.tight_layout()\\n \\n if show:\\n plt.show()\\n else:\\n plt.savefig(outfile, dpi=300)\\n print(f\\\"Wrote: {outfile}\\\")\\n plt.close()\",\n \"def clear(self):\\n row, col = self.selected\\n if self.cubes[row][col].value == 0:\\n self.cubes[row][col].set_temp(0)\",\n \"def clear_flags(self):\\n self.flags.clear()\",\n \"def clear(self):\\n self.SetPoint = 0.0\\n\\n self.PTerm = 0.0\\n self.ITerm = 0.0\\n self.DTerm = 0.0\\n self.last_error = 0.0\\n\\n # Windup Guard\\n self.int_error = 0.0\\n self.windup_guard = 20.0\\n\\n self.output = 0.0\",\n \"def clear(self):\\n self.SetPoint = 0.0\\n\\n self.PTerm = 0.0\\n self.ITerm = 0.0\\n self.DTerm = 0.0\\n self.last_error = 0.0\\n\\n # Windup Guard\\n self.int_error = 0.0\\n self.windup_guard = 20.0\\n\\n self.output = 0.0\",\n \"def clear(self):\\n self.SetPoint = 0.0\\n\\n self.PTerm = 0.0\\n self.ITerm = 0.0\\n self.DTerm = 0.0\\n self.last_error = 0.0\\n\\n # Windup Guard\\n self.int_error = 0.0\\n self.windup_guard = 20.0\\n\\n self.output = 0.0\",\n \"def off(self):\",\n \"def cleanup(self):\\n self.subpixel, self.pixel = self.stepup(self.subpixel, self.pixel, AxisDistance.pixelsize)\\n self.pixel, self.tile = self.stepup(self.pixel, self.tile, AxisDistance.tilesize)\",\n \"def segmentNeedle(self):\\n #productive #event\\n profprint()\\n if self.fiducialButton.isEnabled():\\n print \\\"new checked state: \\\",not self.fiducialButton.checked\\n self.onStartStopGivingNeedleTipsToggled(not self.fiducialButton.checked)\",\n \"def reset() -> None:\\n\\t_flag.clear()\",\n \"def freespaceImageAnalysis( fids, guesses = None, fit=True, bgInput=None, bgPcInput=None, shapes=[None], zeroCorrection=0, zeroCorrectionPC=0,\\n keys=None, fitModule=bump, extraPicDictionaries=None, newAnnotation=False, onlyThisPic=None, pltVSize=5, \\n plotSigmas=False, plotCounts=False, manualColorRange=None, calcTemperature=False, clearOutput=True, \\n dataRange=None, guessTemp=10e-6, trackFitCenter=False, picsPerRep=1, startPic=0, binningParams=None, \\n win=pw.PictureWindow(), transferAnalysisOpts=None, tferBinningParams=None, tferWin= pw.PictureWindow(),\\n extraTferAnalysisArgs={}, emGainSetting=300, lastConditionIsBackGround=True, showTferAnalysisPlots=True,\\n show2dFitsAndResiduals=True, plotFitAmps=False, indvColorRanges=False, fitF2D=gaussian_2d.f_notheta, \\n rmHighCounts=True, useBase=True, weightBackgroundByLoading=True, returnPics=False, forceNoAnnotation=False):\\n fids = [fids] if type(fids) == int else fids\\n keys = [None for _ in fids] if keys is None else keys\\n sortedStackedPics = {}\\n initThresholds = [None]\\n picsForBg = []\\n bgWeights = []\\n isAnnotatedList = []\\n for filenum, fid in enumerate(fids):\\n if transferAnalysisOpts is not None:\\n res = ta.stage1TransferAnalysis( fid, transferAnalysisOpts, useBase=useBase, **extraTferAnalysisArgs )\\n (initAtoms, tferAtoms, initAtomsPs, tferAtomsPs, key, keyName, initPicCounts, tferPicCounts, repetitions, initThresholds,\\n avgPics, tferThresholds, initAtomImages, tferAtomImages, basicInfoStr, ensembleHits, groupedPostSelectedPics, isAnnotated) = res\\n isAnnotatedList.append(isAnnotated)\\n # assumes that you only want to look at the first condition. \\n for varPics in groupedPostSelectedPics: # don't remember why 0 works if false...\\n picsForBg.append(varPics[-1 if lastConditionIsBackGround else 0])\\n bgWeights.append(len(varPics[0]))\\n allFSIPics = [ varpics[0][startPic::picsPerRep] for varpics in groupedPostSelectedPics]\\n if showTferAnalysisPlots:\\n fig, axs = plt.subplots(1,2)\\n mp.makeAvgPlts( axs[0], axs[1], avgPics, transferAnalysisOpts, ['r','g','b'] ) \\n allFSIPics = [win.window( np.array(pics) ) for pics in allFSIPics]\\n allFSIPics = ah.softwareBinning( binningParams, allFSIPics )\\n elif type(fid) == int:\\n ### For looking at either PGC imgs or FSI imgs \\n with exp.ExpFile(fid) as file:\\n # I think this only makes sense if there is a specific bg pic in the rotation\\n picsForBg.append(list(file.get_pics()))\\n allFSIPics = file.get_pics()[startPic::picsPerRep]\\n _, key = file.get_key()\\n if len(np.array(key).shape) == 2:\\n key = key[:,0]\\n file.get_basic_info()\\n allFSIPics = win.window( allFSIPics )\\n allFSIPics = ah.softwareBinning( binningParams, allFSIPics )\\n allFSIPics = np.reshape( allFSIPics, (len(key), int(allFSIPics.shape[0]/len(key)), allFSIPics.shape[1], allFSIPics.shape[2]) )\\n else:\\n ### Assumes given pics have the same start pic and increment (picsPerRep).\\n # doesn't combine well w/ transfer analysis\\n picsForBg.append(fid)\\n allFSIPics = fid[startPic::picsPerRep]\\n print(\\\"Assuming input is list of all pics, then splices to get FSI pics. Old code assumed the given were FSI pics.\\\")\\n allFSIPics = win.window( allFSIPics )\\n allFSIPics = ah.softwareBinning( binningParams, allFSIPics )\\n allFSIPics = np.reshape( allFSIPics, (len(key), int(allFSIPics.shape[0]/len(key)), allFSIPics.shape[1], allFSIPics.shape[2]) )\\n # ##############\\n if keys[filenum] is not None:\\n key = keys[filenum]\\n for i, keyV in enumerate(key):\\n keyV = misc.round_sig_str(keyV)\\n sortedStackedPics[keyV] = np.append(sortedStackedPics[keyV], allFSIPics[i],axis=0) if (keyV in sortedStackedPics) else allFSIPics[i] \\n if lastConditionIsBackGround:\\n bgInput, pcBgInput = getBgImgs(picsForBg, startPic = startPic, picsPerRep = picsPerRep, rmHighCounts=rmHighCounts, bgWeights=bgWeights, \\n weightBackgrounds=weightBackgroundByLoading)\\n elif bgInput == 'lastPic':\\n bgInput, pcBgInput = getBgImgs(picsForBg, startPic = picsPerRep-1, picsPerRep = picsPerRep, rmHighCounts=rmHighCounts, bgWeights=bgWeights,\\n weightBackgrounds=weightBackgroundByLoading )\\n if bgInput is not None: # was broken and not working if not given bg\\n bgInput = win.window(bgInput)\\n bgInput = ah.softwareBinning(binningParams, bgInput)\\n if bgPcInput is not None:\\n bgPcInput = win.window(bgPcInput)\\n bgPcInput = ah.softwareBinning(binningParams, bgPcInput) \\n \\n if extraPicDictionaries is not None:\\n if type(extraPicDictionaries) == dict:\\n extraPicDictionaries = [extraPicDictionaries]\\n for dictionary in extraPicDictionaries:\\n for keyV, pics in dictionary.items():\\n sortedStackedPics[keyV] = (np.append(sortedStackedPics[keyV], pics,axis=0) if keyV in sortedStackedPics else pics) \\n sortedStackedKeyFl = [float(keyStr) for keyStr in sortedStackedPics.keys()]\\n sortedKey, sortedStackedPics = ah.applyDataRange(dataRange, sortedStackedPics, list(sorted(sortedStackedKeyFl)))\\n numVars = len(sortedStackedPics.items())\\n if len(np.array(shapes).shape) == 1:\\n shapes = [shapes for _ in range(numVars)] \\n if guesses is None:\\n guesses = [[None for _ in range(4)] for _ in range(numVars)]\\n if len(np.array(bgInput).shape) == 2 or bgInput == None:\\n bgInput = [bgInput for _ in range(numVars)]\\n if len(np.array(bgPcInput).shape) == 2 or bgPcInput == None:\\n bgPcInput = [bgPcInput for _ in range(numVars)]\\n \\n datalen, avgFitSigmas, images, hFitParams, hFitErrs, vFitParams, vFitErrs, fitParams2D, fitErrs2D = [{} for _ in range(9)]\\n titles = ['Bare', 'Photon-Count', 'Bare-mbg', 'Photon-Count-mbg']\\n assert(len(sortedKey)>0)\\n for vari, keyV in enumerate(sortedKey):\\n keyV=misc.round_sig_str(keyV)\\n if vari==0:\\n initKeyv = keyV\\n varPics = sortedStackedPics[keyV]\\n # 0 is init atom pics for post-selection on atom number... if we wanted to.\\n expansionPics = rmHighCountPics(varPics,7000) if rmHighCounts else varPics\\n datalen[keyV] = len(expansionPics)\\n expPhotonCountImage = photonCounting(expansionPics, 120)[0] / len(expansionPics)\\n bgPhotonCountImage = np.zeros(expansionPics[0].shape) if bgPcInput[vari] is None else bgPcInput[vari]\\n expAvg = np.mean(expansionPics, 0)\\n bgAvg = np.zeros(expansionPics[0].shape) if (bgInput[vari] is None or len(bgInput[vari]) == 1) else bgInput[vari]\\n \\n if bgPhotonCountImage is None:\\n print('no bg photon', expAvg.shape)\\n bgPhotonCount = np.zeros(photonCountImage.shape)\\n avg_mbg = expAvg - bgAvg\\n avg_mbgpc = expPhotonCountImage - bgPhotonCountImage\\n images[keyV] = [expAvg, expPhotonCountImage, avg_mbg, avg_mbgpc]\\n hFitParams[keyV], hFitErrs[keyV], vFitParams[keyV], vFitErrs[keyV], fitParams2D[keyV], fitErrs2D[keyV] = [[] for _ in range(6)]\\n for imnum, (im, guess) in enumerate(zip(images[keyV], guesses[vari])):\\n if fit:\\n # fancy guess_x and guess_y values use the initial fitted value, typically short time, as a guess.\\n _, pictureFitParams2d, pictureFitErrors2d, v_params, v_errs, h_params, h_errs = ah.fitPic(\\n im, guessSigma_x=5, guessSigma_y=5, showFit=False, \\n guess_x=None if vari==0 else fitParams2D[initKeyv][imnum][1], guess_y=None if vari==0 else fitParams2D[initKeyv][imnum][2],\\n fitF=fitF2D)\\n fitParams2D[keyV].append(pictureFitParams2d)\\n fitErrs2D[keyV].append(pictureFitErrors2d)\\n hFitParams[keyV].append(h_params)\\n hFitErrs[keyV].append(h_errs)\\n vFitParams[keyV].append(v_params)\\n vFitErrs[keyV].append(v_errs)\\n # conversion from the num of pixels on the camera to microns at the focus of the tweezers\\n cf = 16e-6/64\\n mins, maxes = [[], []]\\n imgs_ = np.array(list(images.values()))\\n for imgInc in range(4):\\n if indvColorRanges:\\n mins.append(None)\\n maxes.append(None)\\n elif manualColorRange is None:\\n mins.append(min(imgs_[:,imgInc].flatten()))\\n maxes.append(max(imgs_[:,imgInc].flatten()))\\n else:\\n mins.append(manualColorRange[0])\\n maxes.append(manualColorRange[1])\\n numVariations = len(images)\\n if onlyThisPic is None:\\n fig, axs = plt.subplots(numVariations, 4, figsize=(20, pltVSize*numVariations))\\n if numVariations == 1:\\n axs = np.array([axs])\\n bgFig, bgAxs = plt.subplots(1, 2, figsize=(20, pltVSize))\\n else:\\n numRows = int(np.ceil((numVariations+3)/4))\\n fig, axs = plt.subplots(numRows, 4 if numVariations>1 else 3, figsize=(20, pltVSize*numRows))\\n avgPicAx = axs.flatten()[-3]\\n avgPicFig = fig\\n bgAxs = [axs.flatten()[-1], axs.flatten()[-2]]\\n bgFig = fig\\n if show2dFitsAndResiduals:\\n fig2d, axs2d = plt.subplots(*((2,numVariations) if numVariations>1 else (1,2)))\\n keyPlt = np.zeros(len(images))\\n (totalSignal, hfitCenter, hFitCenterErrs, hSigmas, hSigmaErrs, h_amp, hAmpErrs, vfitCenter, vFitCenterErrs, vSigmas, vSigmaErrs, v_amp, \\n vAmpErrs, hSigma2D, hSigma2dErr, vSigma2D, vSigma2dErr) = [np.zeros((len(images), 4)) for _ in range(17)]\\n \\n for vari, ((keyV,ims), hParamSet, hErr_set, vParamSet, vErr_set, paramSet2D, errSet2D) in enumerate(zip(\\n images.items(), *[dic.values() for dic in [hFitParams, hFitErrs, vFitParams, vFitErrs, fitParams2D, fitErrs2D]])):\\n for which in range(4):\\n if onlyThisPic is None:\\n (im, ax, title, min_, max_, hparams, hErrs, vparams, vErrs, param2d, err2d\\n ) = [obj[which] for obj in (ims, axs[vari], titles, mins, maxes, hParamSet, hErr_set, vParamSet, vErr_set, paramSet2D, errSet2D)] \\n else:\\n which = onlyThisPic\\n ax = axs.flatten()[vari]\\n (im, title, min_, max_, hparams, hErrs, vparams, vErrs, param2d, err2d\\n ) = [obj[which] for obj in (ims, titles, mins, maxes, hParamSet, hErr_set, vParamSet, vErr_set, paramSet2D, errSet2D)] \\n h_amp[vari][which], hfitCenter[vari][which], hSigmas[vari][which] = hparams[0], hparams[1], hparams[2]*cf*1e6\\n hAmpErrs[vari][which], hFitCenterErrs[vari][which], hSigmaErrs[vari][which] = hErrs[0], hErrs[1], hErrs[2]*cf*1e6\\n v_amp[vari][which], vfitCenter[vari][which], vSigmas[vari][which] = vparams[0], vparams[1], vparams[2]*cf*1e6\\n vAmpErrs[vari][which], vFitCenterErrs[vari][which], vSigmaErrs[vari][which] = vErrs[0], vErrs[1], vErrs[2]*cf*1e6\\n hSigma2D[vari][which], hSigma2dErr[vari][which], vSigma2D[vari][which], vSigma2dErr[vari][which] = [\\n val*cf*1e6 for val in [param2d[-3], err2d[-3], param2d[-2], err2d[-2]]]\\n \\n totalSignal[vari][which] = np.sum(im.flatten())\\n keyPlt[vari] = keyV\\n res = mp.fancyImshow(fig, ax, im, imageArgs={'cmap':dark_viridis_cmap, 'vmin':min_, 'vmax':max_}, \\n hFitParams=hparams, vFitParams=vparams, fitModule=fitModule, flipVAx = True, fitParams2D=param2d)\\n ax.set_title(keyV + ': ' + str(datalen[keyV]) + ';\\\\n' + title + ': ' + misc.errString(hSigmas[vari][which],hSigmaErrs[vari][which]) \\n + r'$\\\\mu m$ sigma, ' + misc.round_sig_str(totalSignal[vari][which],5), fontsize=12) \\n if show2dFitsAndResiduals:\\n X, Y = np.meshgrid(np.arange(len(im[0])), np.arange(len(im)))\\n data_fitted = fitF2D((X,Y), *param2d)\\n fitProper = data_fitted.reshape(im.shape[0],im.shape[1])\\n ax1 = axs2d[0] if numVariations == 1 else axs2d[0,vari]\\n ax2 = axs2d[1] if numVariations == 1 else axs2d[1,vari]\\n imr = ax1.imshow(fitProper, vmin=min_, vmax=max_)\\n mp.addAxColorbar(fig2d, ax1, imr)\\n ax1.contour(np.arange(len(im[0])), np.arange(len(im)), fitProper, 4, colors='w', alpha=0.2)\\n imr = ax2.imshow(fitProper-im)\\n mp.addAxColorbar(fig2d, ax2, imr)\\n ax2.contour(np.arange(len(im[0])), np.arange(len(im)), fitProper, 4, colors='w', alpha=0.2)\\n if onlyThisPic is not None:\\n break\\n \\n mp.fancyImshow(avgPicFig, avgPicAx, np.mean([img[onlyThisPic] for img in images.values()],axis=0), imageArgs={'cmap':dark_viridis_cmap},flipVAx = True)\\n avgPicAx.set_title('Average Over Variations')\\n ### Plotting background and photon counted background\\n mp.fancyImshow(bgFig, bgAxs[0], bgAvg, imageArgs={'cmap':dark_viridis_cmap},flipVAx = True) \\n bgAxs[0].set_title('Background image (' + str(len(picsForBg)/picsPerRep) + ')')\\n mp.fancyImshow(bgFig, bgAxs[1], bgPhotonCountImage, imageArgs={'cmap':dark_viridis_cmap},flipVAx = True) \\n bgAxs[1].set_title('Photon counted background image (' + str(len(picsForBg)/picsPerRep) + ')')\\n fig.subplots_adjust(left=0,right=1,bottom=0.1, hspace=0.2, **({'top': 0.7, 'wspace': 0.4} if (onlyThisPic is None) else {'top': 0.9, 'wspace': 0.3}))\\n \\n disp.display(fig)\\n temps, tempErrs, tempFitVs, = [],[],[]\\n if calcTemperature: \\n for sigmas, sigmaerrs in zip([hSigmas, vSigmas, hSigma2D, vSigma2D],[hSigmaErrs, vSigmaErrs, hSigma2dErr, vSigma2dErr]):\\n mbgSigmas = np.array([elt[2] for elt in sigmas])\\n mbgSigmaErrs = np.array([elt[2] for elt in sigmaerrs])\\n myGuess = [0.0, min((mbgSigmas)*1e-6), guessTemp]\\n temp, fitV, cov = ah.calcBallisticTemperature(keyPlt*1e-3, (mbgSigmas)*1e-6, guess = myGuess, sizeErrors = mbgSigmaErrs)\\n error = np.sqrt(np.diag(cov))\\n temps.append(temp)\\n tempErrs.append(error[2])\\n tempFitVs.append(fitV)\\n numAxisCol = int(plotSigmas) + int(plotCounts) + int(trackFitCenter)\\n if numAxisCol != 0:\\n fig2, axs = plt.subplots(1, numAxisCol, figsize = (15, 5)) \\n fig2.subplots_adjust(top=0.75, wspace = 0.4)\\n colors = ['b','k','c','purple']\\n if plotSigmas:\\n ax = (axs if numAxisCol == 1 else axs[0]) \\n stdStyle = dict(marker='o',linestyle='',capsize=3)\\n if onlyThisPic is not None:\\n ax.errorbar(keyPlt, hSigmas[:,onlyThisPic], hSigmaErrs[:,onlyThisPic], color=colors[0], label='h '+titles[onlyThisPic], **stdStyle);\\n ax.errorbar(keyPlt, hSigma2D[:,onlyThisPic], hSigma2dErr[:,onlyThisPic], color=colors[1], label='2dh '+titles[onlyThisPic], **stdStyle);\\n ax.errorbar(keyPlt, vSigmas[:,onlyThisPic], vSigmaErrs[:,onlyThisPic], color=colors[2], label='v '+titles[onlyThisPic], **stdStyle);\\n ax.errorbar(keyPlt, vSigma2D[:,onlyThisPic], vSigma2dErr[:,onlyThisPic], color=colors[3], label='2dv '+titles[onlyThisPic], **stdStyle);\\n else:\\n for whichPic in range(4):\\n ax.errorbar(keyPlt, hSigmas[:,whichPic], hSigmaErrs[:,whichPic], color='b', label='h '+titles[whichPic], **stdStyle);\\n ax.errorbar(keyPlt, vSigmas[:,whichPic], vSigmaErrs[:,whichPic], color='c', label='v '+titles[whichPic], **stdStyle);\\n ax.set_ylim(max(0,ax.get_ylim()[0]),min([ax.get_ylim()[1],5]))\\n ax.set_ylabel(r'Fit Sigma ($\\\\mu m$)')\\n \\n if calcTemperature:\\n # converting time to s, hSigmas in um \\n xPoints = np.linspace(min(keyPlt), max(keyPlt))*1e-3\\n for num, fitV in enumerate(tempFitVs):\\n #ax.plot(xPoints*1e3, LargeBeamMotExpansion.f(xPoints, *myGuess)*1e6, label = 'guess')\\n ax.plot(xPoints*1e3, LargeBeamMotExpansion.f(xPoints, *fitV)*1e6, color=colors[num])\\n ax.legend()\\n\\n if plotFitAmps: \\n ax = (axs if numAxisCol == 1 else axs[0])\\n ampAx = ax.twinx()\\n\\n if onlyThisPic is not None:\\n ampAx.errorbar(keyPlt, h_amp[:,onlyThisPic], hAmpErrs[:,onlyThisPic], label='h '+titles[onlyThisPic], color = 'orange', **stdStyle);\\n ampAx.errorbar(keyPlt, v_amp[:,onlyThisPic], vAmpErrs[:,onlyThisPic], label='v '+titles[onlyThisPic], color = 'r', **stdStyle);\\n else:\\n for whichPic in range(4):\\n ampAx.errorbar(keyPlt, h_amp[:,whichPic], hAmpErrs[:,whichPic], label='h '+titles[whichPic], color = 'orange', **stdStyle);\\n ampAx.errorbar(keyPlt, v_amp[:,whichPic], vAmpErrs[:,whichPic], label='v '+titles[whichPic], color = 'r', **stdStyle);\\n [tick.set_color('red') for tick in ampAx.yaxis.get_ticklines()]\\n [tick.set_color('red') for tick in ampAx.yaxis.get_ticklabels()]\\n ampAx.set_ylabel(r'Fit h_amps', color = 'r')\\n \\n hTotalPhotons, vTotalPhotons = None, None\\n if plotCounts:\\n # numAxCol = 1: ax = axs\\n # numAxCol = 2: plotSigmas + plotCounts -- ax = axs[1]\\n # numAxCol = 2: plotCounts + trackFitCenter -- ax = axs[0]\\n # numAxCol = 3: ax = axs[1]\\n if numAxisCol == 1:\\n ax = axs\\n elif numAxisCol == 2:\\n ax = axs[1 if plotSigmas else 0]\\n else:\\n ax = axs[1]\\n # Create axis to plot photon counts\\n ax.set_ylabel(r'Integrated signal')\\n photon_axis = ax.twinx()\\n # This is not currently doing any correct for e.g. the loading rate.\\n countToCameraPhotonEM = 0.018577 / (emGainSetting/200) # the float is is EM200. \\n countToScatteredPhotonEM = 0.018577 / 0.07 / (emGainSetting/200)\\n\\n if onlyThisPic is not None:\\n # calculate number of photons\\n hamp = h_amp[:,onlyThisPic]*len(expansionPics[0][0]) # Horizontal \\\"un\\\"normalization for number of columns begin averaged.\\n vamp = v_amp[:,onlyThisPic]*len(expansionPics[0]) \\n hsigpx = hSigmas[:,onlyThisPic]/(16/64) # Convert from um back to to pixels.\\n vsigpx = vSigmas[:,onlyThisPic]/(16/64)\\n htotalCountsPerPic = bump.area_under(hamp, hsigpx)\\n vtotalCountsPerPic = bump.area_under(vamp, vsigpx)\\n hTotalPhotons = countToScatteredPhotonEM*htotalCountsPerPic\\n vTotalPhotons = countToScatteredPhotonEM*vtotalCountsPerPic\\n ax.plot(keyPlt, totalSignal[:,onlyThisPic], marker='o', linestyle='', label=titles[onlyThisPic]);\\n photon_axis.plot(keyPlt, hTotalPhotons, marker='o', linestyle='', color = 'r', label='Horizontal')\\n photon_axis.plot(keyPlt, vTotalPhotons, marker='o', linestyle='', color = 'orange', label='Vertical')\\n else:\\n for whichPic in range(4):\\n # See above comments\\n amp = h_amp[:,whichPic]*len(expansionPics[0][0]) \\n sig = hSigmas[:,whichPic]/(16/64) \\n totalCountsPerPic = bump.area_under(amp, sig)\\n hTotalPhotons = countToScatteredPhotonEM*totalCountsPerPic\\n ax.plot(keyPlt, totalSignal[:,whichPic], marker='o', linestyle='', label=titles[whichPic]);\\n photon_axis.plot(keyPlt, hTotalPhotons, marker='o', linestyle='', color = ['red', 'orange', 'yellow', 'pink'][whichPic]) \\n ax.legend()\\n photon_axis.legend()\\n [tick.set_color('red') for tick in photon_axis.yaxis.get_ticklines()]\\n [tick.set_color('red') for tick in photon_axis.yaxis.get_ticklabels()]\\n photon_axis.set_ylabel(r'Fit-Based Avg Scattered Photon/Img', color = 'r')\\n if trackFitCenter:\\n #numaxcol = 1: ax = axs\\n #numaxcol = 2: trackfitcenter + plothSigmas: ax = axs[1]\\n #numaxcol = 2: trackfitcenter + plotCounts: ax = axs[1]\\n #numaxcol = 3: ax = axs[2]\\n ax = (axs if numAxisCol == 1 else axs[-1])\\n if onlyThisPic is not None:\\n #ax.errorbar(keyPlt, hfitCenter[:,onlyThisPic], hFitCenterErrs[:,onlyThisPic], marker='o', linestyle='', capsize=3, label=titles[onlyThisPic]);\\n ax.errorbar(keyPlt, vfitCenter[:,onlyThisPic], vFitCenterErrs[:,onlyThisPic], marker='o', linestyle='', capsize=3, label=titles[onlyThisPic]);\\n #def accel(t, x0, a):\\n # return x0 + 0.5*a*t**2\\n #accelFit, AccelCov = opt.curve_fit(accel, keyPlt*1e-3, hfitCenter[:,onlyThisPic], sigma = hFitCenterErrs[:,onlyThisPic])\\n #fitx = np.linspace(keyPlt[0], keyPlt[-1])*1e-3\\n #fity = accel(fitx, *accelFit)\\n #ax.plot(fitx*1e3, fity)\\n else:\\n for whichPic in range(4):\\n ax.errorbar(keyPlt, hfitCenter[:,whichPic], hFitCenterErrs[:,whichPic], marker='o', linestyle='', capsize=3, label=titles[whichPic]);\\n #accelErr = np.sqrt(np.diag(AccelCov))\\n fig2.legend()\\n ax.set_ylabel(r'Fit Centers (pix)')\\n ax.set_xlabel('time (ms)')\\n \\n if numAxisCol != 0:\\n disp.display(fig2) \\n \\n if not forceNoAnnotation:\\n for fid, isAnnotated in zip(fids, isAnnotatedList):\\n if not isAnnotated:\\n if type(fid) == int or type(fid) == type(''):\\n if newAnnotation or not exp.checkAnnotation(fid, force=False, quiet=True, useBase=useBase):\\n exp.annotate(fid, useBase=useBase)\\n if clearOutput:\\n disp.clear_output()\\n if calcTemperature: \\n for temp, err, label in zip(temps, tempErrs, ['Hor', 'Vert', 'Hor2D', 'Vert2D']): \\n print(label + ' temperature = ' + misc.errString(temp*1e6, err*1e6) + 'uk')\\n\\n for fid in fids:\\n if type(fid) == int:\\n expTitle, _, lev = exp.getAnnotation(fid)\\n expTitle = ''.join('#' for _ in range(lev)) + ' File ' + str(fid) + ': ' + expTitle\\n disp.display(disp.Markdown(expTitle))\\n with exp.ExpFile(fid) as file:\\n file.get_basic_info()\\n if trackFitCenter:\\n pass\\n #print('Acceleration in Mpix/s^2 = ' + misc.errString(accelFit[1], accelErr[1]))\\n if transferAnalysisOpts is not None and showTferAnalysisPlots:\\n colors, colors2 = misc.getColors(len(transferAnalysisOpts.initLocs()) + 2)#, cmStr=dataColor)\\n pltShape = (transferAnalysisOpts.initLocsIn[-1], transferAnalysisOpts.initLocsIn[-2])\\n # mp.plotThresholdHists([initThresholds[0][0],initThresholds[1][0]], colors, shape=pltShape)\\n mp.plotThresholdHists([initThresholds[0][0], initThresholds[0][0]], colors, shape=[1,2])\\n returnDictionary = {'images':images, 'fits':hFitParams, 'errs':hFitErrs, 'hSigmas':hSigmas, 'sigmaErrors':hSigmaErrs, 'dataKey':keyPlt, \\n 'hTotalPhotons':hTotalPhotons, 'tempCalc':temps, 'tempCalcErr':tempErrs, 'initThresholds':initThresholds[0], \\n '2DFit':fitParams2D, '2DErr':fitErrs2D, 'bgPics':picsForBg, 'dataLength':datalen}\\n if returnPics: \\n returnDictionary['pics'] = sortedStackedPics\\n return returnDictionary\",\n \"def test_one_center(self):\\n sv=system_vars_c().init_xyzlike([ [8, [0.0, 0.0, 0.0]]])\\n atom2rcut=np.array([5.0])\\n g = dft.gen_grid.Grids(sv)\\n g.level = 1 # precision as implemented in pyscf\\n g.radi_method=leggauss_ab\\n g.build(atom2rcut=atom2rcut)\\n\\n #print( max( np.linalg.norm(g.coords, axis=1) ) )\\n #print( g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0 )\\n self.assertAlmostEqual(max( np.linalg.norm(g.coords, axis=1) ), 4.9955942742763986)\\n self.assertAlmostEqual(g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0)\\n self.assertEqual(len(g.weights), 6248)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5788689","0.56861943","0.55636656","0.54741186","0.54616976","0.5379296","0.5328459","0.5325154","0.53217375","0.52759594","0.5238227","0.52287537","0.51961917","0.5183579","0.51768106","0.51755387","0.5134452","0.5132298","0.51291597","0.5091773","0.507863","0.5062716","0.50626713","0.50611377","0.5041864","0.50362515","0.50338167","0.5023299","0.5012111","0.500488","0.5003061","0.5001117","0.49978873","0.4984368","0.49780703","0.49765906","0.4967708","0.49579346","0.4955191","0.4945549","0.4935827","0.49299422","0.49242917","0.49084103","0.49023187","0.48920098","0.48881376","0.48855007","0.48842072","0.4882124","0.4882011","0.48790082","0.48783162","0.48690233","0.4865506","0.48614988","0.4861439","0.48585626","0.48479056","0.4843599","0.48422334","0.48413506","0.4836971","0.48276988","0.4826589","0.4825967","0.4820323","0.4816191","0.48134166","0.48047507","0.4798872","0.47865376","0.47818935","0.4781128","0.47693756","0.47636947","0.4761333","0.47607824","0.47602174","0.4754133","0.47537458","0.4753715","0.47501093","0.47496614","0.47490177","0.47479004","0.47474557","0.474232","0.47398394","0.4739626","0.47361323","0.47352242","0.47348428","0.47348428","0.47348428","0.47325492","0.47318292","0.47287998","0.47287625","0.47276285","0.47239158"],"string":"[\n \"0.5788689\",\n \"0.56861943\",\n \"0.55636656\",\n \"0.54741186\",\n \"0.54616976\",\n \"0.5379296\",\n \"0.5328459\",\n \"0.5325154\",\n \"0.53217375\",\n \"0.52759594\",\n \"0.5238227\",\n \"0.52287537\",\n \"0.51961917\",\n \"0.5183579\",\n \"0.51768106\",\n \"0.51755387\",\n \"0.5134452\",\n \"0.5132298\",\n \"0.51291597\",\n \"0.5091773\",\n \"0.507863\",\n \"0.5062716\",\n \"0.50626713\",\n \"0.50611377\",\n \"0.5041864\",\n \"0.50362515\",\n \"0.50338167\",\n \"0.5023299\",\n \"0.5012111\",\n \"0.500488\",\n \"0.5003061\",\n \"0.5001117\",\n \"0.49978873\",\n \"0.4984368\",\n \"0.49780703\",\n \"0.49765906\",\n \"0.4967708\",\n \"0.49579346\",\n \"0.4955191\",\n \"0.4945549\",\n \"0.4935827\",\n \"0.49299422\",\n \"0.49242917\",\n \"0.49084103\",\n \"0.49023187\",\n \"0.48920098\",\n \"0.48881376\",\n \"0.48855007\",\n \"0.48842072\",\n \"0.4882124\",\n \"0.4882011\",\n \"0.48790082\",\n \"0.48783162\",\n \"0.48690233\",\n \"0.4865506\",\n \"0.48614988\",\n \"0.4861439\",\n \"0.48585626\",\n \"0.48479056\",\n \"0.4843599\",\n \"0.48422334\",\n \"0.48413506\",\n \"0.4836971\",\n \"0.48276988\",\n \"0.4826589\",\n \"0.4825967\",\n \"0.4820323\",\n \"0.4816191\",\n \"0.48134166\",\n \"0.48047507\",\n \"0.4798872\",\n \"0.47865376\",\n \"0.47818935\",\n \"0.4781128\",\n \"0.47693756\",\n \"0.47636947\",\n \"0.4761333\",\n \"0.47607824\",\n \"0.47602174\",\n \"0.4754133\",\n \"0.47537458\",\n \"0.4753715\",\n \"0.47501093\",\n \"0.47496614\",\n \"0.47490177\",\n \"0.47479004\",\n \"0.47474557\",\n \"0.474232\",\n \"0.47398394\",\n \"0.4739626\",\n \"0.47361323\",\n \"0.47352242\",\n \"0.47348428\",\n \"0.47348428\",\n \"0.47348428\",\n \"0.47325492\",\n \"0.47318292\",\n \"0.47287998\",\n \"0.47287625\",\n \"0.47276285\",\n \"0.47239158\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":489,"cells":{"query":{"kind":"string","value":"Fail on ff.on, but still readout the arc."},"document":{"kind":"string","value":"def test_goto_field_boss_flat_on_fails(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n self.cmd.failOn = 'mcp ff.on'\n self._goto_field_boss(16, 71, 0, 1, cmdState, didFail=True, finish=True)"},"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 friewallOn():\n pass","def test_export_to_mff_no_device():\n pytest.importorskip(\"mffpy\", \"0.5.7\")\n evoked = read_evokeds_mff(egi_evoked_fname, condition=\"Category 1\")\n evoked.info[\"device_info\"] = None\n with pytest.raises(ValueError, match=\"No device type.\"):\n export_evokeds(\"output.mff\", evoked)","def test_none_to_on_transition_no_reading():\n m = monitor.Monitor()\n t = datetime(2010, 1, 1, 0, 0)\n m.set_outside_temperature(10, t)\n assert m.temperature_update(20, t) == None\n m.boiler_on(t)\n assert m.temperature_update(22, t + timedelta(seconds=10)) == None","async def test_set_fan_mode_bad_attr(opp):\n state = opp.states.get(ENTITY_CLIMATE)\n assert \"On High\" == state.attributes.get(ATTR_FAN_MODE)\n\n with pytest.raises(vol.Invalid):\n await common.async_set_fan_mode(opp, None, ENTITY_CLIMATE)\n await opp.async_block_till_done()\n\n state = opp.states.get(ENTITY_CLIMATE)\n assert \"On High\" == state.attributes.get(ATTR_FAN_MODE)","def rtsOn():\n pass","def off(self) -> None:\n ...","def rtsOff():\n pass","def off(self) -> None:","def off(self):","def ff_callback(self):\n self.rokucontrol.ff_callback()","def testEdgeMarkerGeneric0(self):\n outname = self.prefix+'.asap'\n self.res = sdcal(infile=self.rawfile,calmode='otf',markonly=True,outfile=outname,outform='ASAP')\n refdir = self._readref( self.reffiles[0] )\n self._checkfile( outname ) \n self._checkmarker( outname, refdir )","def test_no_alerts(fd, formatter, event):\n ao = AlertObserver(3, fd=fd, formatter=formatter, event=event)\n ao.start()\n event.run_until_wait() # no print\n event.stop()\n assert fd.getvalue() == ''","def fainted(self):\n self.pkmn.faint()\n messages = self.effect.attemptAfterTurn(self.pkmn)\n assert messages == [], \"Should receive no messages since nothing was performed\"","def arm(self):\n error(\"Attempted to access abstract trigger arming function.\")","def test_read_disconnected(connection, reader, schedule, flush, loop):\n schedule(connection.connect(), connection.disconnect())\n flush()\n value = loop.run_until_complete(connection.read())\n assert not value\n assert not reader.used","async def unexpected_ball_received(self):\n # We do nothing in that case","def testEdgeMarkerRaster1(self):\n outname = self.prefix+'.asap'\n self.res = sdcal(infile=self.rawfile,calmode='otfraster',noff=1,markonly=True,outfile=outname,outform='ASAP')\n refdir = self._readref( self.reffiles[1] )\n self._checkfile( outname ) \n self._checkmarker( outname, refdir )","def test_read_not_interested(self):\n try:\n self.reader.read(self.books[2], 0, 0)\n self.fail(\"Readed book not interested\")\n except AssertionError:\n pass","def off(self):\n print(f\"RF {self.name} off\")\n self.status(False)","def test_alert_low_doesnt_fire_twice(fd, formatter, event):\n ao = AlertObserver(3, fd=fd, formatter=formatter, event=event)\n ao.start()\n event.run_until_wait()\n for _ in range(360):\n ao.update(DummyLogRecord())\n event.run_until_wait() # 'alarm triggered'\n for _ in range(359):\n ao.update(DummyLogRecord())\n event.run_until_wait() # 'alarm recovered'\n for _ in range(359):\n ao.update(DummyLogRecord())\n event.run_until_wait() # no print\n event.stop()\n assert fd.getvalue() == 'alarm triggered\\nalarm recovered\\n'","def _barf_if_closed(self):\n if self.closed:\n raise ValueError(\"I/O operation on closed file\")","def testEdgeMarkerRaster0(self):\n outname = self.prefix+'.asap'\n self.res = sdcal(infile=self.rawfile,calmode='otfraster',markonly=True,outfile=outname,outform='ASAP')\n refdir = self._readref( self.reffiles[0] )\n self._checkfile( outname ) \n self._checkmarker( outname, refdir )","def __post_init__(self):\n if self.steering == Direction.FWD:\n raise ValueError(\"Steering can't be FORWARD.\")","def device_discovered():\n event.set()","def test_fooreader():\n from .context import readersender\n\n fr = readersender.readers.FooReader()\n\n fr.connect()\n fr.read()\n fr.disconnect()","def test_alert_low(fd, formatter, event):\n ao = AlertObserver(3, fd=fd, formatter=formatter, event=event)\n ao.start()\n event.run_until_wait()\n for _ in range(360):\n ao.update(DummyLogRecord())\n event.run_until_wait() # 'alarm triggered'\n for _ in range(359):\n ao.update(DummyLogRecord())\n event.run_until_wait() # 'alarm recovered'\n event.stop()\n assert fd.getvalue() == 'alarm triggered\\nalarm recovered\\n'","def testEdgeMarkerGeneric1(self):\n outname = self.prefix+'.asap'\n self.res = sdcal(infile=self.rawfile,calmode='otf',fraction='3%',markonly=True,outfile=outname,outform='ASAP')\n refdir = self._readref( self.reffiles[1] )\n self._checkfile( outname ) \n self._checkmarker( outname, refdir )","def notFainted(self):\n messages = self.effect.attemptAfterTurn(self.pkmn)\n assert messages == [AfterTurnEffect.message], \"Should receive messages from afterTurn function\"","def as_of_action(self):\n return OFActionOutput(port=self.port)","def off(self):\n self._current_stream = self._devnull","def on(self):\n print(f\"RF {self.name} on\")\n self.status(True)","def fftw_failed(f):\n return f","def test_read_EOF(demo_data):\n\n openeeg = openEDF(demo_data)\n start = max(openeeg.header.samples) + 1\n arr = openeeg.read(start, start+100)\n assert arr.size == 0\n\n openeeg.close()","def isReadError(self):\n return self.f5 is 'x'","def test_switchoff(self):\n mic = mi.MicrophoneToText()\n\n mic.switchoff()\n\n with self.assertRaises(OSError):\n mic.stream.is_active()\n self.assertFalse(mic.switch)\n self.assertFalse(mic.audio_source.is_recording)\n self.assertTrue(mic.result.closed)","def test_alert_high_doesnt_fire_twice(fd, formatter, event):\n ao = AlertObserver(3, fd=fd, formatter=formatter, event=event)\n ao.start()\n event.run_until_wait()\n for _ in range(360):\n ao.update(DummyLogRecord())\n event.run_until_wait() # 'alarm triggered'\n for _ in range(360):\n ao.update(DummyLogRecord())\n event.run_until_wait() # no print\n event.stop()\n assert fd.getvalue() == 'alarm triggered\\n'","def _force_read(self, gas_measurement_enabled):\n self._set_gas_measurement(gas_measurement_enabled)\n\n temp = self._read_register_1ubyte(self.BME680_CTRL_MEAS)\n temp |= OperationModes.ForcedMode\n self._write_register(self.BME680_CTRL_MEAS, temp)\n\n while(self._get_measuring_status()):\n time.sleep(0.001)\n\n if (gas_measurement_enabled):\n while (self._get_gas_measuring_status()):\n time.sleep(0.001)","def _off_received(self):\n self._call_subscribers(on_level=0x00)","def r3_on_off():\n \n r3_cmd_packet = b'\\x04\\x14\\x04\\x00\\x00\\xe4\\x0f'\n ser_relay.write(r3_cmd_packet)","def is_fcc_off(self):\n raise NotImplementedError","def seekable(self):\n ...","async def test_inverted_cover(hass: HomeAssistant, monkeypatch) -> None:\n config = {\n \"rflink\": {\"port\": \"/dev/ttyABC0\"},\n DOMAIN: {\n \"platform\": \"rflink\",\n \"devices\": {\n \"nonkaku_device_1\": {\n \"name\": \"nonkaku_type_standard\",\n \"type\": \"standard\",\n },\n \"nonkaku_device_2\": {\"name\": \"nonkaku_type_none\"},\n \"nonkaku_device_3\": {\n \"name\": \"nonkaku_type_inverted\",\n \"type\": \"inverted\",\n },\n \"newkaku_device_4\": {\n \"name\": \"newkaku_type_standard\",\n \"type\": \"standard\",\n },\n \"newkaku_device_5\": {\"name\": \"newkaku_type_none\"},\n \"newkaku_device_6\": {\n \"name\": \"newkaku_type_inverted\",\n \"type\": \"inverted\",\n },\n },\n },\n }\n\n # setup mocking rflink module\n event_callback, _, protocol, _ = await mock_rflink(\n hass, config, DOMAIN, monkeypatch\n )\n\n # test default state of cover loaded from config\n standard_cover = hass.states.get(f\"{DOMAIN}.nonkaku_type_standard\")\n assert standard_cover.state == STATE_CLOSED\n assert standard_cover.attributes[\"assumed_state\"]\n\n # mock incoming up command event for nonkaku_device_1\n event_callback({\"id\": \"nonkaku_device_1\", \"command\": \"up\"})\n await hass.async_block_till_done()\n\n standard_cover = hass.states.get(f\"{DOMAIN}.nonkaku_type_standard\")\n assert standard_cover.state == STATE_OPEN\n assert standard_cover.attributes.get(\"assumed_state\")\n\n # mock incoming up command event for nonkaku_device_2\n event_callback({\"id\": \"nonkaku_device_2\", \"command\": \"up\"})\n await hass.async_block_till_done()\n\n standard_cover = hass.states.get(f\"{DOMAIN}.nonkaku_type_none\")\n assert standard_cover.state == STATE_OPEN\n assert standard_cover.attributes.get(\"assumed_state\")\n\n # mock incoming up command event for nonkaku_device_3\n event_callback({\"id\": \"nonkaku_device_3\", \"command\": \"up\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.nonkaku_type_inverted\")\n assert inverted_cover.state == STATE_OPEN\n assert inverted_cover.attributes.get(\"assumed_state\")\n\n # mock incoming up command event for newkaku_device_4\n event_callback({\"id\": \"newkaku_device_4\", \"command\": \"up\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.newkaku_type_standard\")\n assert inverted_cover.state == STATE_OPEN\n assert inverted_cover.attributes.get(\"assumed_state\")\n\n # mock incoming up command event for newkaku_device_5\n event_callback({\"id\": \"newkaku_device_5\", \"command\": \"up\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.newkaku_type_none\")\n assert inverted_cover.state == STATE_OPEN\n assert inverted_cover.attributes.get(\"assumed_state\")\n\n # mock incoming up command event for newkaku_device_6\n event_callback({\"id\": \"newkaku_device_6\", \"command\": \"up\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.newkaku_type_inverted\")\n assert inverted_cover.state == STATE_OPEN\n assert inverted_cover.attributes.get(\"assumed_state\")\n\n # mock incoming down command event for nonkaku_device_1\n event_callback({\"id\": \"nonkaku_device_1\", \"command\": \"down\"})\n\n await hass.async_block_till_done()\n\n standard_cover = hass.states.get(f\"{DOMAIN}.nonkaku_type_standard\")\n assert standard_cover.state == STATE_CLOSED\n assert standard_cover.attributes.get(\"assumed_state\")\n\n # mock incoming down command event for nonkaku_device_2\n event_callback({\"id\": \"nonkaku_device_2\", \"command\": \"down\"})\n\n await hass.async_block_till_done()\n\n standard_cover = hass.states.get(f\"{DOMAIN}.nonkaku_type_none\")\n assert standard_cover.state == STATE_CLOSED\n assert standard_cover.attributes.get(\"assumed_state\")\n\n # mock incoming down command event for nonkaku_device_3\n event_callback({\"id\": \"nonkaku_device_3\", \"command\": \"down\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.nonkaku_type_inverted\")\n assert inverted_cover.state == STATE_CLOSED\n assert inverted_cover.attributes.get(\"assumed_state\")\n\n # mock incoming down command event for newkaku_device_4\n event_callback({\"id\": \"newkaku_device_4\", \"command\": \"down\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.newkaku_type_standard\")\n assert inverted_cover.state == STATE_CLOSED\n assert inverted_cover.attributes.get(\"assumed_state\")\n\n # mock incoming down command event for newkaku_device_5\n event_callback({\"id\": \"newkaku_device_5\", \"command\": \"down\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.newkaku_type_none\")\n assert inverted_cover.state == STATE_CLOSED\n assert inverted_cover.attributes.get(\"assumed_state\")\n\n # mock incoming down command event for newkaku_device_6\n event_callback({\"id\": \"newkaku_device_6\", \"command\": \"down\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.newkaku_type_inverted\")\n assert inverted_cover.state == STATE_CLOSED\n assert inverted_cover.attributes.get(\"assumed_state\")\n\n # We are only testing the 'inverted' devices, the 'standard' devices\n # are already covered by other test cases.\n\n # should respond to group command\n event_callback({\"id\": \"nonkaku_device_3\", \"command\": \"alloff\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.nonkaku_type_inverted\")\n assert inverted_cover.state == STATE_CLOSED\n\n # should respond to group command\n event_callback({\"id\": \"nonkaku_device_3\", \"command\": \"allon\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.nonkaku_type_inverted\")\n assert inverted_cover.state == STATE_OPEN\n\n # should respond to group command\n event_callback({\"id\": \"newkaku_device_4\", \"command\": \"alloff\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.newkaku_type_standard\")\n assert inverted_cover.state == STATE_CLOSED\n\n # should respond to group command\n event_callback({\"id\": \"newkaku_device_4\", \"command\": \"allon\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.newkaku_type_standard\")\n assert inverted_cover.state == STATE_OPEN\n\n # should respond to group command\n event_callback({\"id\": \"newkaku_device_5\", \"command\": \"alloff\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.newkaku_type_none\")\n assert inverted_cover.state == STATE_CLOSED\n\n # should respond to group command\n event_callback({\"id\": \"newkaku_device_5\", \"command\": \"allon\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.newkaku_type_none\")\n assert inverted_cover.state == STATE_OPEN\n\n # should respond to group command\n event_callback({\"id\": \"newkaku_device_6\", \"command\": \"alloff\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.newkaku_type_inverted\")\n assert inverted_cover.state == STATE_CLOSED\n\n # should respond to group command\n event_callback({\"id\": \"newkaku_device_6\", \"command\": \"allon\"})\n\n await hass.async_block_till_done()\n\n inverted_cover = hass.states.get(f\"{DOMAIN}.newkaku_type_inverted\")\n assert inverted_cover.state == STATE_OPEN\n\n # Sending the close command from HA should result\n # in an 'DOWN' command sent to a non-newkaku device\n # that has its type set to 'standard'.\n await hass.services.async_call(\n DOMAIN,\n SERVICE_CLOSE_COVER,\n {ATTR_ENTITY_ID: f\"{DOMAIN}.nonkaku_type_standard\"},\n )\n\n await hass.async_block_till_done()\n\n assert hass.states.get(f\"{DOMAIN}.nonkaku_type_standard\").state == STATE_CLOSED\n assert protocol.send_command_ack.call_args_list[0][0][0] == \"nonkaku_device_1\"\n assert protocol.send_command_ack.call_args_list[0][0][1] == \"DOWN\"\n\n # Sending the open command from HA should result\n # in an 'UP' command sent to a non-newkaku device\n # that has its type set to 'standard'.\n await hass.services.async_call(\n DOMAIN,\n SERVICE_OPEN_COVER,\n {ATTR_ENTITY_ID: f\"{DOMAIN}.nonkaku_type_standard\"},\n )\n\n await hass.async_block_till_done()\n\n assert hass.states.get(f\"{DOMAIN}.nonkaku_type_standard\").state == STATE_OPEN\n assert protocol.send_command_ack.call_args_list[1][0][0] == \"nonkaku_device_1\"\n assert protocol.send_command_ack.call_args_list[1][0][1] == \"UP\"\n\n # Sending the close command from HA should result\n # in an 'DOWN' command sent to a non-newkaku device\n # that has its type not specified.\n await hass.services.async_call(\n DOMAIN, SERVICE_CLOSE_COVER, {ATTR_ENTITY_ID: f\"{DOMAIN}.nonkaku_type_none\"}\n )\n\n await hass.async_block_till_done()\n\n assert hass.states.get(f\"{DOMAIN}.nonkaku_type_none\").state == STATE_CLOSED\n assert protocol.send_command_ack.call_args_list[2][0][0] == \"nonkaku_device_2\"\n assert protocol.send_command_ack.call_args_list[2][0][1] == \"DOWN\"\n\n # Sending the open command from HA should result\n # in an 'UP' command sent to a non-newkaku device\n # that has its type not specified.\n await hass.services.async_call(\n DOMAIN, SERVICE_OPEN_COVER, {ATTR_ENTITY_ID: f\"{DOMAIN}.nonkaku_type_none\"}\n )\n\n await hass.async_block_till_done()\n\n assert hass.states.get(f\"{DOMAIN}.nonkaku_type_none\").state == STATE_OPEN\n assert protocol.send_command_ack.call_args_list[3][0][0] == \"nonkaku_device_2\"\n assert protocol.send_command_ack.call_args_list[3][0][1] == \"UP\"\n\n # Sending the close command from HA should result\n # in an 'UP' command sent to a non-newkaku device\n # that has its type set to 'inverted'.\n await hass.services.async_call(\n DOMAIN,\n SERVICE_CLOSE_COVER,\n {ATTR_ENTITY_ID: f\"{DOMAIN}.nonkaku_type_inverted\"},\n )\n\n await hass.async_block_till_done()\n\n assert hass.states.get(f\"{DOMAIN}.nonkaku_type_inverted\").state == STATE_CLOSED\n assert protocol.send_command_ack.call_args_list[4][0][0] == \"nonkaku_device_3\"\n assert protocol.send_command_ack.call_args_list[4][0][1] == \"UP\"\n\n # Sending the open command from HA should result\n # in an 'DOWN' command sent to a non-newkaku device\n # that has its type set to 'inverted'.\n await hass.services.async_call(\n DOMAIN,\n SERVICE_OPEN_COVER,\n {ATTR_ENTITY_ID: f\"{DOMAIN}.nonkaku_type_inverted\"},\n )\n\n await hass.async_block_till_done()\n\n assert hass.states.get(f\"{DOMAIN}.nonkaku_type_inverted\").state == STATE_OPEN\n assert protocol.send_command_ack.call_args_list[5][0][0] == \"nonkaku_device_3\"\n assert protocol.send_command_ack.call_args_list[5][0][1] == \"DOWN\"\n\n # Sending the close command from HA should result\n # in an 'DOWN' command sent to a newkaku device\n # that has its type set to 'standard'.\n await hass.services.async_call(\n DOMAIN,\n SERVICE_CLOSE_COVER,\n {ATTR_ENTITY_ID: f\"{DOMAIN}.newkaku_type_standard\"},\n )\n\n await hass.async_block_till_done()\n\n assert hass.states.get(f\"{DOMAIN}.newkaku_type_standard\").state == STATE_CLOSED\n assert protocol.send_command_ack.call_args_list[6][0][0] == \"newkaku_device_4\"\n assert protocol.send_command_ack.call_args_list[6][0][1] == \"DOWN\"\n\n # Sending the open command from HA should result\n # in an 'UP' command sent to a newkaku device\n # that has its type set to 'standard'.\n await hass.services.async_call(\n DOMAIN,\n SERVICE_OPEN_COVER,\n {ATTR_ENTITY_ID: f\"{DOMAIN}.newkaku_type_standard\"},\n )\n\n await hass.async_block_till_done()\n\n assert hass.states.get(f\"{DOMAIN}.newkaku_type_standard\").state == STATE_OPEN\n assert protocol.send_command_ack.call_args_list[7][0][0] == \"newkaku_device_4\"\n assert protocol.send_command_ack.call_args_list[7][0][1] == \"UP\"\n\n # Sending the close command from HA should result\n # in an 'UP' command sent to a newkaku device\n # that has its type not specified.\n await hass.services.async_call(\n DOMAIN, SERVICE_CLOSE_COVER, {ATTR_ENTITY_ID: f\"{DOMAIN}.newkaku_type_none\"}\n )\n\n await hass.async_block_till_done()\n\n assert hass.states.get(f\"{DOMAIN}.newkaku_type_none\").state == STATE_CLOSED\n assert protocol.send_command_ack.call_args_list[8][0][0] == \"newkaku_device_5\"\n assert protocol.send_command_ack.call_args_list[8][0][1] == \"UP\"\n\n # Sending the open command from HA should result\n # in an 'DOWN' command sent to a newkaku device\n # that has its type not specified.\n await hass.services.async_call(\n DOMAIN, SERVICE_OPEN_COVER, {ATTR_ENTITY_ID: f\"{DOMAIN}.newkaku_type_none\"}\n )\n\n await hass.async_block_till_done()\n\n assert hass.states.get(f\"{DOMAIN}.newkaku_type_none\").state == STATE_OPEN\n assert protocol.send_command_ack.call_args_list[9][0][0] == \"newkaku_device_5\"\n assert protocol.send_command_ack.call_args_list[9][0][1] == \"DOWN\"\n\n # Sending the close command from HA should result\n # in an 'UP' command sent to a newkaku device\n # that has its type set to 'inverted'.\n await hass.services.async_call(\n DOMAIN,\n SERVICE_CLOSE_COVER,\n {ATTR_ENTITY_ID: f\"{DOMAIN}.newkaku_type_inverted\"},\n )\n\n await hass.async_block_till_done()\n\n assert hass.states.get(f\"{DOMAIN}.newkaku_type_inverted\").state == STATE_CLOSED\n assert protocol.send_command_ack.call_args_list[10][0][0] == \"newkaku_device_6\"\n assert protocol.send_command_ack.call_args_list[10][0][1] == \"UP\"\n\n # Sending the open command from HA should result\n # in an 'DOWN' command sent to a newkaku device\n # that has its type set to 'inverted'.\n await hass.services.async_call(\n DOMAIN,\n SERVICE_OPEN_COVER,\n {ATTR_ENTITY_ID: f\"{DOMAIN}.newkaku_type_inverted\"},\n )\n\n await hass.async_block_till_done()\n\n assert hass.states.get(f\"{DOMAIN}.newkaku_type_inverted\").state == STATE_OPEN\n assert protocol.send_command_ack.call_args_list[11][0][0] == \"newkaku_device_6\"\n assert protocol.send_command_ack.call_args_list[11][0][1] == \"DOWN\"","def on(self) -> None:","def go_infFD(self):\n\n response = self.send_lens_cmd(['05', '00', '00', '00'], fast_mode=True)\n self.wait_focus_move()","def off(self):\n raise NotImplementedError","async def test_fan_read_state(hass: HomeAssistant, utcnow) -> None:\n helper = await setup_test_component(hass, create_fan_service)\n\n state = await helper.async_update(\n ServicesTypes.FAN, {CharacteristicsTypes.ON: False}\n )\n assert state.state == \"off\"\n\n state = await helper.async_update(\n ServicesTypes.FAN, {CharacteristicsTypes.ON: True}\n )\n assert state.state == \"on\"","def is_recoverable(self):\n return self.__is_recoverable","def end_read():\n global ov_read\n ov_read = False\n GPIO.cleanup()","def test_fas():\n ddir = os.path.join(\"data\", \"testdata\")\n datadir = pkg_resources.resource_filename(\"gmprocess\", ddir)\n fas_file = os.path.join(datadir, \"fas_geometric_mean.pkl\")\n p1 = os.path.join(datadir, \"peer\", \"RSN763_LOMAP_GIL067.AT2\")\n p2 = os.path.join(datadir, \"peer\", \"RSN763_LOMAP_GIL337.AT2\")\n\n stream = StationStream([])\n for idx, fpath in enumerate([p1, p2]):\n with open(fpath, encoding=\"utf-8\") as file_obj:\n for _ in range(3):\n next(file_obj)\n meta = re.findall(r\"[.0-9]+\", next(file_obj))\n dt = float(meta[1])\n accels = np.array(\n [col for line in file_obj for col in line.split()], dtype=float\n )\n trace = StationTrace(\n data=accels,\n header={\n \"channel\": \"H\" + str(idx),\n \"delta\": dt,\n \"standard\": {\n \"corner_frequency\": np.nan,\n \"station_name\": \"\",\n \"source\": \"json\",\n \"instrument\": \"\",\n \"instrument_period\": np.nan,\n \"source_format\": \"json\",\n \"comments\": \"\",\n \"structure_type\": \"\",\n \"sensor_serial_number\": \"\",\n \"source_file\": \"\",\n \"process_level\": \"raw counts\",\n \"process_time\": \"\",\n \"horizontal_orientation\": np.nan,\n \"vertical_orientation\": np.nan,\n \"units\": \"cm/s/s\",\n \"units_type\": \"acc\",\n \"instrument_sensitivity\": np.nan,\n \"instrument_damping\": np.nan,\n },\n },\n )\n stream.append(trace)\n\n for tr in stream:\n response = {\"input_units\": \"counts\", \"output_units\": \"cm/s^2\"}\n tr.setProvenance(\"remove_response\", response)\n\n target_df = pd.read_pickle(fas_file)\n ind_vals = target_df.index.values\n per = np.unique([float(i[0].split(\")\")[0].split(\"(\")[1]) for i in ind_vals])\n freqs = 1 / per\n imts = [\"fas\" + str(p) for p in per]\n summary = StationSummary.from_stream(stream, [\"geometric_mean\"], imts, bandwidth=30)\n\n pgms = summary.pgms\n # pgms.to_pickle(fas_file)\n for idx, f in enumerate(freqs):\n fstr = f\"FAS({1 / f:.3f})\"\n fval1 = pgms.loc[fstr, \"GEOMETRIC_MEAN\"].Result\n fval2 = target_df.loc[fstr, \"GEOMETRIC_MEAN\"].Result\n np.testing.assert_allclose(fval1, fval2, rtol=1e-5, atol=1e-5)","def arc_set_complete(self, *args, **kwardgs):\n\n super(WeldTask, self).play()","def tell(self):\n ...","def test_recover(self):\n # Should work\n A = ConwayAgent(23, True)\n A.infect()\n A.recover()\n self.assertTrue(A.status() == 3)\n\n # Should do nothing\n A.reset()\n A.recover()\n self.assertTrue(A.status() == 1)\n\n # Should also do nothing\n A.infect()\n A.kill()\n A.recover()\n self.assertTrue(A.status() == 0)","def test_verify_state_of_a_device_when_disconnected_from_the_device():","def wantsReadEvent(self):\r\n if self.result != None:\r\n return self.result == 0\r\n return None","def on(self):\n status = self.dev.ctrl_transfer(0x40, 0x01, 0x0001, 0xa0, [])\n if status == 0:\n self.ev.set()\n return (status == 0)","def fAT(self):\n pass","def ready():\n\tsh('c')\n\td1out()\n\td2out()\n\td3out()\n\t#marAuxiliary.openMarShield()\t\t# N.b. if mar disconnected, will just do nothing","def test_writer_wrong():\n GCMT(write=2)\n assert not Writer.on","def error_out(self) -> bool:\n return self._action == 'error'","def stopReading(self):\n self.reading = False","def at_aflight(seq, flag):\n at(\"AFLIGHT\", seq, [flag])","def on(self):","async def test_turn_off(hass: HomeAssistant, utcnow) -> None:\n helper = await setup_test_component(hass, create_fan_service)\n\n await helper.async_update(ServicesTypes.FAN, {CharacteristicsTypes.ON: 1})\n\n await hass.services.async_call(\n \"fan\",\n \"turn_off\",\n {\"entity_id\": \"fan.testdevice\"},\n blocking=True,\n )\n helper.async_assert_service_values(\n ServicesTypes.FAN,\n {\n CharacteristicsTypes.ON: 0,\n },\n )","def probe(self):\n return False","def error(err):\n print(\"ERROR: \" + err)\n avrprog.end()\n while True:\n pass","def test_afni_nonvolume():\n im = ndar.Image('test_data/10_425-02_li1_146.png')\n nose.tools.assert_raises(AttributeError, lambda: im.afni)","def unknown_departure(self, node):\n pass","async def test_write_acn_error():\n f = asyncio.Future()\n f.set_result(None)\n pipe = Mock()\n pipe.write.return_value = f\n node_client = NodeClient(pipe, Mock())\n await node_client.write_acn_status_error(\"some message\")\n pipe.write.assert_called_once()","async def expected_ball_received(self):\n # We do nothing in that case","def test_wrong_ann_features():\n my_file_struct = FileStruct(os.path.join(\"fixtures\", \"chirp.mp3\"))\n my_file_struct.features_file = os.path.join(\"features\", \"no_file.json\")\n cqt = CQT(my_file_struct, FeatureTypes.ann_beatsync, sr=11025)\n with raises(FeatureTypeNotFound):\n cqt.features","def check_result(ec):\r\n # NOTE: This will break some oscilloscopes that are powered by USB.\r\n # Some of the newer scopes, can actually be powered by USB and will\r\n # return a useful value. That should be given back to the user.\r\n # I guess we can deal with these edge cases in the functions themselves\r\n if ec == 0:\r\n return\r\n\r\n else:\r\n ecName = error_num_to_name(ec)\r\n ecDesc = error_num_to_desc(ec)\r\n raise IOError('Error calling %s: %s (%s)' % (\r\n str(inspect.stack()[1][3]), ecName, ecDesc))","def onDone(self):\n pass","def safe_to_dance(self):\n #check for all fil/early-termination conditions\n for _ in range(4):\n if self.read_distance() < 300:\n print(\"not safe to dance!\")\n return False\n else:\n self.turn_by_deg(90)\n #after all checks have been done, we deduce its safe to dance\n print(\"Dance on!\")\n return True","def test_invalid_flag_record(self):\n log.info(\"START QUAL TEST INVALID FLAG RECORD\")\n\n # Made-up data with all flags except the first set to True.\n # First flag is not a zero or one.\n self.clear_sample_data()\n self.event_subscribers.clear_events()\n self.assert_initialize()\n self.create_sample_data('invalid_A0000003.DEC', \"A1000003.DEC\")\n\n # Verify an event was raised and we are in our retry state.\n self.verify_queue_empty()\n self.assert_event_received(ResourceAgentErrorEvent, 10)\n self.assert_state_change(ResourceAgentState.STREAMING, 10)\n\n log.info(\"END QUAL TEST INVALID FLAG RECORD\")","def ultrasonicChecker() -> None:\n ...","def test_read_one_signal_failure(self):\n cwd = os.path.dirname(os.path.abspath(__file__))\n dir1 = os.path.join(cwd, 'test_files/')\n dir2 = '/home/tomas/here-be-dragons/'\n signal1 = read_signal(dir1, 'here-be-dragons')\n signal2 = read_signal(dir2, 'test3')\n self.assertIsNone(signal1)\n self.assertIsNone(signal2)","def test_fp_elf(elf, expected):\n elf_filename = os.path.join(elf_dir, elf)\n epiphany = Epiphany()\n with open(elf_filename, 'rb') as elf:\n epiphany.init_state(elf, elf_filename, '', [], False, is_test=True)\n epiphany.max_insts = 10000\n epiphany.run()\n expected.fp_check(epiphany.state)","def event_m10_29_x39(flag1=105405, z15=10292020, z16=10292010, z17=100001, z18=100002, z21=10040000,\r\n z22=10320000, flag2=129010024):\r\n \"\"\"State 0,1: Is the destination door open?\"\"\"\r\n if GetEventFlag(flag2) != 0:\r\n pass\r\n else:\r\n Goto('L0')\r\n \"\"\"State 2: Intrusion MAP determination\"\"\"\r\n CompareEventFlag(0, z15, 1)\r\n if GetEventFlag(flag1) != 1:\r\n \"\"\"State 4: Wait for completion of reading Madura MAP\"\"\"\r\n IsMapReadAndBackreadStable(0, z21, 1)\r\n assert ConditionGroup(0)\r\n \"\"\"State 5: Open the Madura side door\"\"\"\r\n ChangeObjState(z15, 30)\r\n \"\"\"State 7: Made the Madura side door mesh mesh accessible\"\"\"\r\n DeleteNavimeshAttribute(z17, 2)\r\n else:\r\n \"\"\"State 3: Waiting for completion of reading of the Shadow Shadow Forest MAP\"\"\"\r\n IsMapReadAndBackreadStable(0, z22, 1)\r\n assert ConditionGroup(0)\r\n \"\"\"State 6: Open the door on the forest side of the hollow shadow\"\"\"\r\n ChangeObjState(z16, 30)\r\n \"\"\"State 8: Navimesh of the door on the forest side of the empty shadow is ready to enter\"\"\"\r\n DeleteNavimeshAttribute(z18, 2)\r\n \"\"\"State 9: Destination door opening complete\"\"\"\r\n return 0\r\n \"\"\"State 10: Destination door opening not completed\"\"\"\r\n Label('L0')\r\n return 1","def after(self):\n return self.marker_seen and not self.throwaway","def event_m20_11_3020():\n \"\"\"State 0,2: [Preset] Beautiful frog singing voice_flag_SubState\"\"\"\n assert event_m20_11_x110(z24=211000081, z25=802, z26=211020082)\n \"\"\"State 1: Finish\"\"\"\n EndMachine()","def test_read_foreign_device_table_ack(self):\n if _debug: TestAnnexJCodec._debug(\"test_read_foreign_device_table_ack\")\n\n # read returns an empty table\n pdu_bytes = xtob('81.07.0004')\n\n self.request(ReadForeignDeviceTableAck([]))\n self.indication(pduData=pdu_bytes)\n\n self.response(PDU(pdu_bytes))\n self.confirmation(ReadForeignDeviceTableAck, bvlciFDT=[])\n\n # read returns a table with one entry\n fdte = FDTEntry()\n fdte.fdAddress = Address(\"192.168.0.10\")\n fdte.fdTTL = 30\n fdte.fdRemain = 15\n pdu_bytes = xtob('81.07.000e' # bvlci\n 'c0.a8.00.0a.ba.c0' # address\n '001e.000f' # ttl and remaining\n )\n\n self.request(ReadForeignDeviceTableAck([fdte]))\n self.indication(pduData=pdu_bytes)\n\n self.response(PDU(pdu_bytes))\n self.confirmation(ReadForeignDeviceTableAck, bvlciFDT=[fdte])","def mark_done(cf):\n\n with open(cf) as f:\n hesh = hashlib.sha256(bytes(f.read(), 'utf-8')).hexdigest()\n with open('done_log', 'a') as f:\n f.write('{}\\t{}\\n'.format(cf, hesh))","def onError(self, connection:MQTTConnection, rc:int) -> bool:\n\t\treturn True","def r2_on_off():\n \n r2_cmd_packet = b'\\x04\\x14\\x02\\x00\\x00\\xe6\\x0f'\n ser_relay.write(r2_cmd_packet)","def on(self) -> None:\n ...","def off(self):\n status = self.dev.ctrl_transfer(0x40, 0x01, 0x0001, 0x20, [])\n if status == 0:\n self.ev.clear()\n return (status == 0)","def feed(self):\n # or intelligence discard\n pass","def test_is_affordable_off_chain(self):\n tx_message = TransactionMessage(\n performative=TransactionMessage.Performative.PROPOSE_FOR_SETTLEMENT,\n skill_callback_ids=[PublicId(\"author\", \"a_skill\", \"0.1.0\")],\n tx_id=self.tx_id,\n tx_sender_addr=self.tx_sender_addr,\n tx_counterparty_addr=self.tx_counterparty_addr,\n tx_amount_by_currency_id={\"FET\": -20},\n tx_sender_fee=0,\n tx_counterparty_fee=0,\n tx_quantities_by_good_id={\"good_id\": 10},\n ledger_id=\"off_chain\",\n info=self.info,\n tx_nonce=\"Transaction nonce\",\n )\n\n assert self.decision_maker._is_affordable(tx_message)","def _read_no_check(self):\n on_data_fut = _async.Future(self._loop)\n def on_data():\n on_data_fut.set_result(None)\n self._loop.add_reader(self._channel.fileno(), on_data)\n\n try:\n yield From(on_data_fut)\n finally:\n self._loop.remove_reader(self._channel.fileno())\n\n d = self._channel.recv(_MAX_READ_AMOUNT).decode()\n if d == '':\n logger.debug(\"{}: Read returned {!r}\".format(self, d))\n raise TransportNotConnected\n\n logger.debug(\"{}: Read {!r}\".format(self, d))\n if d.endswith(\"\\r\\n\"):\n d = d[:-2] + \"\\n\"\n d = d.encode('ascii')\n\n raise Return(d)","def test_fileDoesNotExist(self):\n fp = FilePath(self.mktemp())\n protocol = self.makeConnectedDccFileReceive(fp.path)\n\n self.allDataReceivedForProtocol(protocol, b\"I <3 Twisted\")\n\n self.assertEqual(fp.getContent(), b\"I <3 Twisted\")","def test_export_to_mff_incompatible_sfreq():\n pytest.importorskip(\"mffpy\", \"0.5.7\")\n evoked = read_evokeds(fname_evoked)\n with pytest.raises(ValueError, match=f'sfreq: {evoked[0].info[\"sfreq\"]}'):\n export_evokeds(\"output.mff\", evoked)","def test_fastaqual_output(self):\r\n self.assertRaises(IOError, convert_fastaqual, self.fasta_file_path,\r\n output_directory=self.read_only_output_dir)","def emergency_recover_states_from_failure():\n _emergency_state_check()\n _emergency_iobuf_extract()","def test_afni_fail():\n im = ndar.Image('test_data/bogus.mnc')\n nose.tools.assert_raises(AttributeError, lambda: im.afni)","def event_m20_11_x84(z44=20111330):\n \"\"\"State 0,1: Wait for branch destruction\"\"\"\n IsObjBroken(0, z44, 1)\n assert ConditionGroup(0)\n \"\"\"State 2: End state\"\"\"\n return 0","def test_goto_field_boss_ffs_open_fails(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n self.cmd.failOn = 'mcp ffs.open'\n self._goto_field_boss(21, 102, 1, 1, cmdState, didFail=True, finish=True)","def test_handle_flag_error(self):\n pass","def connectionTest(self):\n\n print(\"Turn on the Tiva\")\n g_byte = self.ser.read(1)\n o_byte = self.ser.read(1)\n\n if (g_byte.decode(\"ascii\") != \"G\") | (o_byte.decode(\"ascii\") != \"O\"):\n print(\"Unsuccessful Serial Connection to Tiva, Try Again\")\n else:\n print(\"Successful Serial Connection to Tiva\")","def test_read_before_connected(connection, reader, loop):\n value = loop.run_until_complete(connection.read())\n assert not value\n assert not reader.used","def eof(self):\n try:\n next_line = self.read_pkt_line()\n except HangupException:\n return True\n self.unread_pkt_line(next_line)\n return False"],"string":"[\n \"def friewallOn():\\n pass\",\n \"def test_export_to_mff_no_device():\\n pytest.importorskip(\\\"mffpy\\\", \\\"0.5.7\\\")\\n evoked = read_evokeds_mff(egi_evoked_fname, condition=\\\"Category 1\\\")\\n evoked.info[\\\"device_info\\\"] = None\\n with pytest.raises(ValueError, match=\\\"No device type.\\\"):\\n export_evokeds(\\\"output.mff\\\", evoked)\",\n \"def test_none_to_on_transition_no_reading():\\n m = monitor.Monitor()\\n t = datetime(2010, 1, 1, 0, 0)\\n m.set_outside_temperature(10, t)\\n assert m.temperature_update(20, t) == None\\n m.boiler_on(t)\\n assert m.temperature_update(22, t + timedelta(seconds=10)) == None\",\n \"async def test_set_fan_mode_bad_attr(opp):\\n state = opp.states.get(ENTITY_CLIMATE)\\n assert \\\"On High\\\" == state.attributes.get(ATTR_FAN_MODE)\\n\\n with pytest.raises(vol.Invalid):\\n await common.async_set_fan_mode(opp, None, ENTITY_CLIMATE)\\n await opp.async_block_till_done()\\n\\n state = opp.states.get(ENTITY_CLIMATE)\\n assert \\\"On High\\\" == state.attributes.get(ATTR_FAN_MODE)\",\n \"def rtsOn():\\n pass\",\n \"def off(self) -> None:\\n ...\",\n \"def rtsOff():\\n pass\",\n \"def off(self) -> None:\",\n \"def off(self):\",\n \"def ff_callback(self):\\n self.rokucontrol.ff_callback()\",\n \"def testEdgeMarkerGeneric0(self):\\n outname = self.prefix+'.asap'\\n self.res = sdcal(infile=self.rawfile,calmode='otf',markonly=True,outfile=outname,outform='ASAP')\\n refdir = self._readref( self.reffiles[0] )\\n self._checkfile( outname ) \\n self._checkmarker( outname, refdir )\",\n \"def test_no_alerts(fd, formatter, event):\\n ao = AlertObserver(3, fd=fd, formatter=formatter, event=event)\\n ao.start()\\n event.run_until_wait() # no print\\n event.stop()\\n assert fd.getvalue() == ''\",\n \"def fainted(self):\\n self.pkmn.faint()\\n messages = self.effect.attemptAfterTurn(self.pkmn)\\n assert messages == [], \\\"Should receive no messages since nothing was performed\\\"\",\n \"def arm(self):\\n error(\\\"Attempted to access abstract trigger arming function.\\\")\",\n \"def test_read_disconnected(connection, reader, schedule, flush, loop):\\n schedule(connection.connect(), connection.disconnect())\\n flush()\\n value = loop.run_until_complete(connection.read())\\n assert not value\\n assert not reader.used\",\n \"async def unexpected_ball_received(self):\\n # We do nothing in that case\",\n \"def testEdgeMarkerRaster1(self):\\n outname = self.prefix+'.asap'\\n self.res = sdcal(infile=self.rawfile,calmode='otfraster',noff=1,markonly=True,outfile=outname,outform='ASAP')\\n refdir = self._readref( self.reffiles[1] )\\n self._checkfile( outname ) \\n self._checkmarker( outname, refdir )\",\n \"def test_read_not_interested(self):\\n try:\\n self.reader.read(self.books[2], 0, 0)\\n self.fail(\\\"Readed book not interested\\\")\\n except AssertionError:\\n pass\",\n \"def off(self):\\n print(f\\\"RF {self.name} off\\\")\\n self.status(False)\",\n \"def test_alert_low_doesnt_fire_twice(fd, formatter, event):\\n ao = AlertObserver(3, fd=fd, formatter=formatter, event=event)\\n ao.start()\\n event.run_until_wait()\\n for _ in range(360):\\n ao.update(DummyLogRecord())\\n event.run_until_wait() # 'alarm triggered'\\n for _ in range(359):\\n ao.update(DummyLogRecord())\\n event.run_until_wait() # 'alarm recovered'\\n for _ in range(359):\\n ao.update(DummyLogRecord())\\n event.run_until_wait() # no print\\n event.stop()\\n assert fd.getvalue() == 'alarm triggered\\\\nalarm recovered\\\\n'\",\n \"def _barf_if_closed(self):\\n if self.closed:\\n raise ValueError(\\\"I/O operation on closed file\\\")\",\n \"def testEdgeMarkerRaster0(self):\\n outname = self.prefix+'.asap'\\n self.res = sdcal(infile=self.rawfile,calmode='otfraster',markonly=True,outfile=outname,outform='ASAP')\\n refdir = self._readref( self.reffiles[0] )\\n self._checkfile( outname ) \\n self._checkmarker( outname, refdir )\",\n \"def __post_init__(self):\\n if self.steering == Direction.FWD:\\n raise ValueError(\\\"Steering can't be FORWARD.\\\")\",\n \"def device_discovered():\\n event.set()\",\n \"def test_fooreader():\\n from .context import readersender\\n\\n fr = readersender.readers.FooReader()\\n\\n fr.connect()\\n fr.read()\\n fr.disconnect()\",\n \"def test_alert_low(fd, formatter, event):\\n ao = AlertObserver(3, fd=fd, formatter=formatter, event=event)\\n ao.start()\\n event.run_until_wait()\\n for _ in range(360):\\n ao.update(DummyLogRecord())\\n event.run_until_wait() # 'alarm triggered'\\n for _ in range(359):\\n ao.update(DummyLogRecord())\\n event.run_until_wait() # 'alarm recovered'\\n event.stop()\\n assert fd.getvalue() == 'alarm triggered\\\\nalarm recovered\\\\n'\",\n \"def testEdgeMarkerGeneric1(self):\\n outname = self.prefix+'.asap'\\n self.res = sdcal(infile=self.rawfile,calmode='otf',fraction='3%',markonly=True,outfile=outname,outform='ASAP')\\n refdir = self._readref( self.reffiles[1] )\\n self._checkfile( outname ) \\n self._checkmarker( outname, refdir )\",\n \"def notFainted(self):\\n messages = self.effect.attemptAfterTurn(self.pkmn)\\n assert messages == [AfterTurnEffect.message], \\\"Should receive messages from afterTurn function\\\"\",\n \"def as_of_action(self):\\n return OFActionOutput(port=self.port)\",\n \"def off(self):\\n self._current_stream = self._devnull\",\n \"def on(self):\\n print(f\\\"RF {self.name} on\\\")\\n self.status(True)\",\n \"def fftw_failed(f):\\n return f\",\n \"def test_read_EOF(demo_data):\\n\\n openeeg = openEDF(demo_data)\\n start = max(openeeg.header.samples) + 1\\n arr = openeeg.read(start, start+100)\\n assert arr.size == 0\\n\\n openeeg.close()\",\n \"def isReadError(self):\\n return self.f5 is 'x'\",\n \"def test_switchoff(self):\\n mic = mi.MicrophoneToText()\\n\\n mic.switchoff()\\n\\n with self.assertRaises(OSError):\\n mic.stream.is_active()\\n self.assertFalse(mic.switch)\\n self.assertFalse(mic.audio_source.is_recording)\\n self.assertTrue(mic.result.closed)\",\n \"def test_alert_high_doesnt_fire_twice(fd, formatter, event):\\n ao = AlertObserver(3, fd=fd, formatter=formatter, event=event)\\n ao.start()\\n event.run_until_wait()\\n for _ in range(360):\\n ao.update(DummyLogRecord())\\n event.run_until_wait() # 'alarm triggered'\\n for _ in range(360):\\n ao.update(DummyLogRecord())\\n event.run_until_wait() # no print\\n event.stop()\\n assert fd.getvalue() == 'alarm triggered\\\\n'\",\n \"def _force_read(self, gas_measurement_enabled):\\n self._set_gas_measurement(gas_measurement_enabled)\\n\\n temp = self._read_register_1ubyte(self.BME680_CTRL_MEAS)\\n temp |= OperationModes.ForcedMode\\n self._write_register(self.BME680_CTRL_MEAS, temp)\\n\\n while(self._get_measuring_status()):\\n time.sleep(0.001)\\n\\n if (gas_measurement_enabled):\\n while (self._get_gas_measuring_status()):\\n time.sleep(0.001)\",\n \"def _off_received(self):\\n self._call_subscribers(on_level=0x00)\",\n \"def r3_on_off():\\n \\n r3_cmd_packet = b'\\\\x04\\\\x14\\\\x04\\\\x00\\\\x00\\\\xe4\\\\x0f'\\n ser_relay.write(r3_cmd_packet)\",\n \"def is_fcc_off(self):\\n raise NotImplementedError\",\n \"def seekable(self):\\n ...\",\n \"async def test_inverted_cover(hass: HomeAssistant, monkeypatch) -> None:\\n config = {\\n \\\"rflink\\\": {\\\"port\\\": \\\"/dev/ttyABC0\\\"},\\n DOMAIN: {\\n \\\"platform\\\": \\\"rflink\\\",\\n \\\"devices\\\": {\\n \\\"nonkaku_device_1\\\": {\\n \\\"name\\\": \\\"nonkaku_type_standard\\\",\\n \\\"type\\\": \\\"standard\\\",\\n },\\n \\\"nonkaku_device_2\\\": {\\\"name\\\": \\\"nonkaku_type_none\\\"},\\n \\\"nonkaku_device_3\\\": {\\n \\\"name\\\": \\\"nonkaku_type_inverted\\\",\\n \\\"type\\\": \\\"inverted\\\",\\n },\\n \\\"newkaku_device_4\\\": {\\n \\\"name\\\": \\\"newkaku_type_standard\\\",\\n \\\"type\\\": \\\"standard\\\",\\n },\\n \\\"newkaku_device_5\\\": {\\\"name\\\": \\\"newkaku_type_none\\\"},\\n \\\"newkaku_device_6\\\": {\\n \\\"name\\\": \\\"newkaku_type_inverted\\\",\\n \\\"type\\\": \\\"inverted\\\",\\n },\\n },\\n },\\n }\\n\\n # setup mocking rflink module\\n event_callback, _, protocol, _ = await mock_rflink(\\n hass, config, DOMAIN, monkeypatch\\n )\\n\\n # test default state of cover loaded from config\\n standard_cover = hass.states.get(f\\\"{DOMAIN}.nonkaku_type_standard\\\")\\n assert standard_cover.state == STATE_CLOSED\\n assert standard_cover.attributes[\\\"assumed_state\\\"]\\n\\n # mock incoming up command event for nonkaku_device_1\\n event_callback({\\\"id\\\": \\\"nonkaku_device_1\\\", \\\"command\\\": \\\"up\\\"})\\n await hass.async_block_till_done()\\n\\n standard_cover = hass.states.get(f\\\"{DOMAIN}.nonkaku_type_standard\\\")\\n assert standard_cover.state == STATE_OPEN\\n assert standard_cover.attributes.get(\\\"assumed_state\\\")\\n\\n # mock incoming up command event for nonkaku_device_2\\n event_callback({\\\"id\\\": \\\"nonkaku_device_2\\\", \\\"command\\\": \\\"up\\\"})\\n await hass.async_block_till_done()\\n\\n standard_cover = hass.states.get(f\\\"{DOMAIN}.nonkaku_type_none\\\")\\n assert standard_cover.state == STATE_OPEN\\n assert standard_cover.attributes.get(\\\"assumed_state\\\")\\n\\n # mock incoming up command event for nonkaku_device_3\\n event_callback({\\\"id\\\": \\\"nonkaku_device_3\\\", \\\"command\\\": \\\"up\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.nonkaku_type_inverted\\\")\\n assert inverted_cover.state == STATE_OPEN\\n assert inverted_cover.attributes.get(\\\"assumed_state\\\")\\n\\n # mock incoming up command event for newkaku_device_4\\n event_callback({\\\"id\\\": \\\"newkaku_device_4\\\", \\\"command\\\": \\\"up\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.newkaku_type_standard\\\")\\n assert inverted_cover.state == STATE_OPEN\\n assert inverted_cover.attributes.get(\\\"assumed_state\\\")\\n\\n # mock incoming up command event for newkaku_device_5\\n event_callback({\\\"id\\\": \\\"newkaku_device_5\\\", \\\"command\\\": \\\"up\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.newkaku_type_none\\\")\\n assert inverted_cover.state == STATE_OPEN\\n assert inverted_cover.attributes.get(\\\"assumed_state\\\")\\n\\n # mock incoming up command event for newkaku_device_6\\n event_callback({\\\"id\\\": \\\"newkaku_device_6\\\", \\\"command\\\": \\\"up\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.newkaku_type_inverted\\\")\\n assert inverted_cover.state == STATE_OPEN\\n assert inverted_cover.attributes.get(\\\"assumed_state\\\")\\n\\n # mock incoming down command event for nonkaku_device_1\\n event_callback({\\\"id\\\": \\\"nonkaku_device_1\\\", \\\"command\\\": \\\"down\\\"})\\n\\n await hass.async_block_till_done()\\n\\n standard_cover = hass.states.get(f\\\"{DOMAIN}.nonkaku_type_standard\\\")\\n assert standard_cover.state == STATE_CLOSED\\n assert standard_cover.attributes.get(\\\"assumed_state\\\")\\n\\n # mock incoming down command event for nonkaku_device_2\\n event_callback({\\\"id\\\": \\\"nonkaku_device_2\\\", \\\"command\\\": \\\"down\\\"})\\n\\n await hass.async_block_till_done()\\n\\n standard_cover = hass.states.get(f\\\"{DOMAIN}.nonkaku_type_none\\\")\\n assert standard_cover.state == STATE_CLOSED\\n assert standard_cover.attributes.get(\\\"assumed_state\\\")\\n\\n # mock incoming down command event for nonkaku_device_3\\n event_callback({\\\"id\\\": \\\"nonkaku_device_3\\\", \\\"command\\\": \\\"down\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.nonkaku_type_inverted\\\")\\n assert inverted_cover.state == STATE_CLOSED\\n assert inverted_cover.attributes.get(\\\"assumed_state\\\")\\n\\n # mock incoming down command event for newkaku_device_4\\n event_callback({\\\"id\\\": \\\"newkaku_device_4\\\", \\\"command\\\": \\\"down\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.newkaku_type_standard\\\")\\n assert inverted_cover.state == STATE_CLOSED\\n assert inverted_cover.attributes.get(\\\"assumed_state\\\")\\n\\n # mock incoming down command event for newkaku_device_5\\n event_callback({\\\"id\\\": \\\"newkaku_device_5\\\", \\\"command\\\": \\\"down\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.newkaku_type_none\\\")\\n assert inverted_cover.state == STATE_CLOSED\\n assert inverted_cover.attributes.get(\\\"assumed_state\\\")\\n\\n # mock incoming down command event for newkaku_device_6\\n event_callback({\\\"id\\\": \\\"newkaku_device_6\\\", \\\"command\\\": \\\"down\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.newkaku_type_inverted\\\")\\n assert inverted_cover.state == STATE_CLOSED\\n assert inverted_cover.attributes.get(\\\"assumed_state\\\")\\n\\n # We are only testing the 'inverted' devices, the 'standard' devices\\n # are already covered by other test cases.\\n\\n # should respond to group command\\n event_callback({\\\"id\\\": \\\"nonkaku_device_3\\\", \\\"command\\\": \\\"alloff\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.nonkaku_type_inverted\\\")\\n assert inverted_cover.state == STATE_CLOSED\\n\\n # should respond to group command\\n event_callback({\\\"id\\\": \\\"nonkaku_device_3\\\", \\\"command\\\": \\\"allon\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.nonkaku_type_inverted\\\")\\n assert inverted_cover.state == STATE_OPEN\\n\\n # should respond to group command\\n event_callback({\\\"id\\\": \\\"newkaku_device_4\\\", \\\"command\\\": \\\"alloff\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.newkaku_type_standard\\\")\\n assert inverted_cover.state == STATE_CLOSED\\n\\n # should respond to group command\\n event_callback({\\\"id\\\": \\\"newkaku_device_4\\\", \\\"command\\\": \\\"allon\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.newkaku_type_standard\\\")\\n assert inverted_cover.state == STATE_OPEN\\n\\n # should respond to group command\\n event_callback({\\\"id\\\": \\\"newkaku_device_5\\\", \\\"command\\\": \\\"alloff\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.newkaku_type_none\\\")\\n assert inverted_cover.state == STATE_CLOSED\\n\\n # should respond to group command\\n event_callback({\\\"id\\\": \\\"newkaku_device_5\\\", \\\"command\\\": \\\"allon\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.newkaku_type_none\\\")\\n assert inverted_cover.state == STATE_OPEN\\n\\n # should respond to group command\\n event_callback({\\\"id\\\": \\\"newkaku_device_6\\\", \\\"command\\\": \\\"alloff\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.newkaku_type_inverted\\\")\\n assert inverted_cover.state == STATE_CLOSED\\n\\n # should respond to group command\\n event_callback({\\\"id\\\": \\\"newkaku_device_6\\\", \\\"command\\\": \\\"allon\\\"})\\n\\n await hass.async_block_till_done()\\n\\n inverted_cover = hass.states.get(f\\\"{DOMAIN}.newkaku_type_inverted\\\")\\n assert inverted_cover.state == STATE_OPEN\\n\\n # Sending the close command from HA should result\\n # in an 'DOWN' command sent to a non-newkaku device\\n # that has its type set to 'standard'.\\n await hass.services.async_call(\\n DOMAIN,\\n SERVICE_CLOSE_COVER,\\n {ATTR_ENTITY_ID: f\\\"{DOMAIN}.nonkaku_type_standard\\\"},\\n )\\n\\n await hass.async_block_till_done()\\n\\n assert hass.states.get(f\\\"{DOMAIN}.nonkaku_type_standard\\\").state == STATE_CLOSED\\n assert protocol.send_command_ack.call_args_list[0][0][0] == \\\"nonkaku_device_1\\\"\\n assert protocol.send_command_ack.call_args_list[0][0][1] == \\\"DOWN\\\"\\n\\n # Sending the open command from HA should result\\n # in an 'UP' command sent to a non-newkaku device\\n # that has its type set to 'standard'.\\n await hass.services.async_call(\\n DOMAIN,\\n SERVICE_OPEN_COVER,\\n {ATTR_ENTITY_ID: f\\\"{DOMAIN}.nonkaku_type_standard\\\"},\\n )\\n\\n await hass.async_block_till_done()\\n\\n assert hass.states.get(f\\\"{DOMAIN}.nonkaku_type_standard\\\").state == STATE_OPEN\\n assert protocol.send_command_ack.call_args_list[1][0][0] == \\\"nonkaku_device_1\\\"\\n assert protocol.send_command_ack.call_args_list[1][0][1] == \\\"UP\\\"\\n\\n # Sending the close command from HA should result\\n # in an 'DOWN' command sent to a non-newkaku device\\n # that has its type not specified.\\n await hass.services.async_call(\\n DOMAIN, SERVICE_CLOSE_COVER, {ATTR_ENTITY_ID: f\\\"{DOMAIN}.nonkaku_type_none\\\"}\\n )\\n\\n await hass.async_block_till_done()\\n\\n assert hass.states.get(f\\\"{DOMAIN}.nonkaku_type_none\\\").state == STATE_CLOSED\\n assert protocol.send_command_ack.call_args_list[2][0][0] == \\\"nonkaku_device_2\\\"\\n assert protocol.send_command_ack.call_args_list[2][0][1] == \\\"DOWN\\\"\\n\\n # Sending the open command from HA should result\\n # in an 'UP' command sent to a non-newkaku device\\n # that has its type not specified.\\n await hass.services.async_call(\\n DOMAIN, SERVICE_OPEN_COVER, {ATTR_ENTITY_ID: f\\\"{DOMAIN}.nonkaku_type_none\\\"}\\n )\\n\\n await hass.async_block_till_done()\\n\\n assert hass.states.get(f\\\"{DOMAIN}.nonkaku_type_none\\\").state == STATE_OPEN\\n assert protocol.send_command_ack.call_args_list[3][0][0] == \\\"nonkaku_device_2\\\"\\n assert protocol.send_command_ack.call_args_list[3][0][1] == \\\"UP\\\"\\n\\n # Sending the close command from HA should result\\n # in an 'UP' command sent to a non-newkaku device\\n # that has its type set to 'inverted'.\\n await hass.services.async_call(\\n DOMAIN,\\n SERVICE_CLOSE_COVER,\\n {ATTR_ENTITY_ID: f\\\"{DOMAIN}.nonkaku_type_inverted\\\"},\\n )\\n\\n await hass.async_block_till_done()\\n\\n assert hass.states.get(f\\\"{DOMAIN}.nonkaku_type_inverted\\\").state == STATE_CLOSED\\n assert protocol.send_command_ack.call_args_list[4][0][0] == \\\"nonkaku_device_3\\\"\\n assert protocol.send_command_ack.call_args_list[4][0][1] == \\\"UP\\\"\\n\\n # Sending the open command from HA should result\\n # in an 'DOWN' command sent to a non-newkaku device\\n # that has its type set to 'inverted'.\\n await hass.services.async_call(\\n DOMAIN,\\n SERVICE_OPEN_COVER,\\n {ATTR_ENTITY_ID: f\\\"{DOMAIN}.nonkaku_type_inverted\\\"},\\n )\\n\\n await hass.async_block_till_done()\\n\\n assert hass.states.get(f\\\"{DOMAIN}.nonkaku_type_inverted\\\").state == STATE_OPEN\\n assert protocol.send_command_ack.call_args_list[5][0][0] == \\\"nonkaku_device_3\\\"\\n assert protocol.send_command_ack.call_args_list[5][0][1] == \\\"DOWN\\\"\\n\\n # Sending the close command from HA should result\\n # in an 'DOWN' command sent to a newkaku device\\n # that has its type set to 'standard'.\\n await hass.services.async_call(\\n DOMAIN,\\n SERVICE_CLOSE_COVER,\\n {ATTR_ENTITY_ID: f\\\"{DOMAIN}.newkaku_type_standard\\\"},\\n )\\n\\n await hass.async_block_till_done()\\n\\n assert hass.states.get(f\\\"{DOMAIN}.newkaku_type_standard\\\").state == STATE_CLOSED\\n assert protocol.send_command_ack.call_args_list[6][0][0] == \\\"newkaku_device_4\\\"\\n assert protocol.send_command_ack.call_args_list[6][0][1] == \\\"DOWN\\\"\\n\\n # Sending the open command from HA should result\\n # in an 'UP' command sent to a newkaku device\\n # that has its type set to 'standard'.\\n await hass.services.async_call(\\n DOMAIN,\\n SERVICE_OPEN_COVER,\\n {ATTR_ENTITY_ID: f\\\"{DOMAIN}.newkaku_type_standard\\\"},\\n )\\n\\n await hass.async_block_till_done()\\n\\n assert hass.states.get(f\\\"{DOMAIN}.newkaku_type_standard\\\").state == STATE_OPEN\\n assert protocol.send_command_ack.call_args_list[7][0][0] == \\\"newkaku_device_4\\\"\\n assert protocol.send_command_ack.call_args_list[7][0][1] == \\\"UP\\\"\\n\\n # Sending the close command from HA should result\\n # in an 'UP' command sent to a newkaku device\\n # that has its type not specified.\\n await hass.services.async_call(\\n DOMAIN, SERVICE_CLOSE_COVER, {ATTR_ENTITY_ID: f\\\"{DOMAIN}.newkaku_type_none\\\"}\\n )\\n\\n await hass.async_block_till_done()\\n\\n assert hass.states.get(f\\\"{DOMAIN}.newkaku_type_none\\\").state == STATE_CLOSED\\n assert protocol.send_command_ack.call_args_list[8][0][0] == \\\"newkaku_device_5\\\"\\n assert protocol.send_command_ack.call_args_list[8][0][1] == \\\"UP\\\"\\n\\n # Sending the open command from HA should result\\n # in an 'DOWN' command sent to a newkaku device\\n # that has its type not specified.\\n await hass.services.async_call(\\n DOMAIN, SERVICE_OPEN_COVER, {ATTR_ENTITY_ID: f\\\"{DOMAIN}.newkaku_type_none\\\"}\\n )\\n\\n await hass.async_block_till_done()\\n\\n assert hass.states.get(f\\\"{DOMAIN}.newkaku_type_none\\\").state == STATE_OPEN\\n assert protocol.send_command_ack.call_args_list[9][0][0] == \\\"newkaku_device_5\\\"\\n assert protocol.send_command_ack.call_args_list[9][0][1] == \\\"DOWN\\\"\\n\\n # Sending the close command from HA should result\\n # in an 'UP' command sent to a newkaku device\\n # that has its type set to 'inverted'.\\n await hass.services.async_call(\\n DOMAIN,\\n SERVICE_CLOSE_COVER,\\n {ATTR_ENTITY_ID: f\\\"{DOMAIN}.newkaku_type_inverted\\\"},\\n )\\n\\n await hass.async_block_till_done()\\n\\n assert hass.states.get(f\\\"{DOMAIN}.newkaku_type_inverted\\\").state == STATE_CLOSED\\n assert protocol.send_command_ack.call_args_list[10][0][0] == \\\"newkaku_device_6\\\"\\n assert protocol.send_command_ack.call_args_list[10][0][1] == \\\"UP\\\"\\n\\n # Sending the open command from HA should result\\n # in an 'DOWN' command sent to a newkaku device\\n # that has its type set to 'inverted'.\\n await hass.services.async_call(\\n DOMAIN,\\n SERVICE_OPEN_COVER,\\n {ATTR_ENTITY_ID: f\\\"{DOMAIN}.newkaku_type_inverted\\\"},\\n )\\n\\n await hass.async_block_till_done()\\n\\n assert hass.states.get(f\\\"{DOMAIN}.newkaku_type_inverted\\\").state == STATE_OPEN\\n assert protocol.send_command_ack.call_args_list[11][0][0] == \\\"newkaku_device_6\\\"\\n assert protocol.send_command_ack.call_args_list[11][0][1] == \\\"DOWN\\\"\",\n \"def on(self) -> None:\",\n \"def go_infFD(self):\\n\\n response = self.send_lens_cmd(['05', '00', '00', '00'], fast_mode=True)\\n self.wait_focus_move()\",\n \"def off(self):\\n raise NotImplementedError\",\n \"async def test_fan_read_state(hass: HomeAssistant, utcnow) -> None:\\n helper = await setup_test_component(hass, create_fan_service)\\n\\n state = await helper.async_update(\\n ServicesTypes.FAN, {CharacteristicsTypes.ON: False}\\n )\\n assert state.state == \\\"off\\\"\\n\\n state = await helper.async_update(\\n ServicesTypes.FAN, {CharacteristicsTypes.ON: True}\\n )\\n assert state.state == \\\"on\\\"\",\n \"def is_recoverable(self):\\n return self.__is_recoverable\",\n \"def end_read():\\n global ov_read\\n ov_read = False\\n GPIO.cleanup()\",\n \"def test_fas():\\n ddir = os.path.join(\\\"data\\\", \\\"testdata\\\")\\n datadir = pkg_resources.resource_filename(\\\"gmprocess\\\", ddir)\\n fas_file = os.path.join(datadir, \\\"fas_geometric_mean.pkl\\\")\\n p1 = os.path.join(datadir, \\\"peer\\\", \\\"RSN763_LOMAP_GIL067.AT2\\\")\\n p2 = os.path.join(datadir, \\\"peer\\\", \\\"RSN763_LOMAP_GIL337.AT2\\\")\\n\\n stream = StationStream([])\\n for idx, fpath in enumerate([p1, p2]):\\n with open(fpath, encoding=\\\"utf-8\\\") as file_obj:\\n for _ in range(3):\\n next(file_obj)\\n meta = re.findall(r\\\"[.0-9]+\\\", next(file_obj))\\n dt = float(meta[1])\\n accels = np.array(\\n [col for line in file_obj for col in line.split()], dtype=float\\n )\\n trace = StationTrace(\\n data=accels,\\n header={\\n \\\"channel\\\": \\\"H\\\" + str(idx),\\n \\\"delta\\\": dt,\\n \\\"standard\\\": {\\n \\\"corner_frequency\\\": np.nan,\\n \\\"station_name\\\": \\\"\\\",\\n \\\"source\\\": \\\"json\\\",\\n \\\"instrument\\\": \\\"\\\",\\n \\\"instrument_period\\\": np.nan,\\n \\\"source_format\\\": \\\"json\\\",\\n \\\"comments\\\": \\\"\\\",\\n \\\"structure_type\\\": \\\"\\\",\\n \\\"sensor_serial_number\\\": \\\"\\\",\\n \\\"source_file\\\": \\\"\\\",\\n \\\"process_level\\\": \\\"raw counts\\\",\\n \\\"process_time\\\": \\\"\\\",\\n \\\"horizontal_orientation\\\": np.nan,\\n \\\"vertical_orientation\\\": np.nan,\\n \\\"units\\\": \\\"cm/s/s\\\",\\n \\\"units_type\\\": \\\"acc\\\",\\n \\\"instrument_sensitivity\\\": np.nan,\\n \\\"instrument_damping\\\": np.nan,\\n },\\n },\\n )\\n stream.append(trace)\\n\\n for tr in stream:\\n response = {\\\"input_units\\\": \\\"counts\\\", \\\"output_units\\\": \\\"cm/s^2\\\"}\\n tr.setProvenance(\\\"remove_response\\\", response)\\n\\n target_df = pd.read_pickle(fas_file)\\n ind_vals = target_df.index.values\\n per = np.unique([float(i[0].split(\\\")\\\")[0].split(\\\"(\\\")[1]) for i in ind_vals])\\n freqs = 1 / per\\n imts = [\\\"fas\\\" + str(p) for p in per]\\n summary = StationSummary.from_stream(stream, [\\\"geometric_mean\\\"], imts, bandwidth=30)\\n\\n pgms = summary.pgms\\n # pgms.to_pickle(fas_file)\\n for idx, f in enumerate(freqs):\\n fstr = f\\\"FAS({1 / f:.3f})\\\"\\n fval1 = pgms.loc[fstr, \\\"GEOMETRIC_MEAN\\\"].Result\\n fval2 = target_df.loc[fstr, \\\"GEOMETRIC_MEAN\\\"].Result\\n np.testing.assert_allclose(fval1, fval2, rtol=1e-5, atol=1e-5)\",\n \"def arc_set_complete(self, *args, **kwardgs):\\n\\n super(WeldTask, self).play()\",\n \"def tell(self):\\n ...\",\n \"def test_recover(self):\\n # Should work\\n A = ConwayAgent(23, True)\\n A.infect()\\n A.recover()\\n self.assertTrue(A.status() == 3)\\n\\n # Should do nothing\\n A.reset()\\n A.recover()\\n self.assertTrue(A.status() == 1)\\n\\n # Should also do nothing\\n A.infect()\\n A.kill()\\n A.recover()\\n self.assertTrue(A.status() == 0)\",\n \"def test_verify_state_of_a_device_when_disconnected_from_the_device():\",\n \"def wantsReadEvent(self):\\r\\n if self.result != None:\\r\\n return self.result == 0\\r\\n return None\",\n \"def on(self):\\n status = self.dev.ctrl_transfer(0x40, 0x01, 0x0001, 0xa0, [])\\n if status == 0:\\n self.ev.set()\\n return (status == 0)\",\n \"def fAT(self):\\n pass\",\n \"def ready():\\n\\tsh('c')\\n\\td1out()\\n\\td2out()\\n\\td3out()\\n\\t#marAuxiliary.openMarShield()\\t\\t# N.b. if mar disconnected, will just do nothing\",\n \"def test_writer_wrong():\\n GCMT(write=2)\\n assert not Writer.on\",\n \"def error_out(self) -> bool:\\n return self._action == 'error'\",\n \"def stopReading(self):\\n self.reading = False\",\n \"def at_aflight(seq, flag):\\n at(\\\"AFLIGHT\\\", seq, [flag])\",\n \"def on(self):\",\n \"async def test_turn_off(hass: HomeAssistant, utcnow) -> None:\\n helper = await setup_test_component(hass, create_fan_service)\\n\\n await helper.async_update(ServicesTypes.FAN, {CharacteristicsTypes.ON: 1})\\n\\n await hass.services.async_call(\\n \\\"fan\\\",\\n \\\"turn_off\\\",\\n {\\\"entity_id\\\": \\\"fan.testdevice\\\"},\\n blocking=True,\\n )\\n helper.async_assert_service_values(\\n ServicesTypes.FAN,\\n {\\n CharacteristicsTypes.ON: 0,\\n },\\n )\",\n \"def probe(self):\\n return False\",\n \"def error(err):\\n print(\\\"ERROR: \\\" + err)\\n avrprog.end()\\n while True:\\n pass\",\n \"def test_afni_nonvolume():\\n im = ndar.Image('test_data/10_425-02_li1_146.png')\\n nose.tools.assert_raises(AttributeError, lambda: im.afni)\",\n \"def unknown_departure(self, node):\\n pass\",\n \"async def test_write_acn_error():\\n f = asyncio.Future()\\n f.set_result(None)\\n pipe = Mock()\\n pipe.write.return_value = f\\n node_client = NodeClient(pipe, Mock())\\n await node_client.write_acn_status_error(\\\"some message\\\")\\n pipe.write.assert_called_once()\",\n \"async def expected_ball_received(self):\\n # We do nothing in that case\",\n \"def test_wrong_ann_features():\\n my_file_struct = FileStruct(os.path.join(\\\"fixtures\\\", \\\"chirp.mp3\\\"))\\n my_file_struct.features_file = os.path.join(\\\"features\\\", \\\"no_file.json\\\")\\n cqt = CQT(my_file_struct, FeatureTypes.ann_beatsync, sr=11025)\\n with raises(FeatureTypeNotFound):\\n cqt.features\",\n \"def check_result(ec):\\r\\n # NOTE: This will break some oscilloscopes that are powered by USB.\\r\\n # Some of the newer scopes, can actually be powered by USB and will\\r\\n # return a useful value. That should be given back to the user.\\r\\n # I guess we can deal with these edge cases in the functions themselves\\r\\n if ec == 0:\\r\\n return\\r\\n\\r\\n else:\\r\\n ecName = error_num_to_name(ec)\\r\\n ecDesc = error_num_to_desc(ec)\\r\\n raise IOError('Error calling %s: %s (%s)' % (\\r\\n str(inspect.stack()[1][3]), ecName, ecDesc))\",\n \"def onDone(self):\\n pass\",\n \"def safe_to_dance(self):\\n #check for all fil/early-termination conditions\\n for _ in range(4):\\n if self.read_distance() < 300:\\n print(\\\"not safe to dance!\\\")\\n return False\\n else:\\n self.turn_by_deg(90)\\n #after all checks have been done, we deduce its safe to dance\\n print(\\\"Dance on!\\\")\\n return True\",\n \"def test_invalid_flag_record(self):\\n log.info(\\\"START QUAL TEST INVALID FLAG RECORD\\\")\\n\\n # Made-up data with all flags except the first set to True.\\n # First flag is not a zero or one.\\n self.clear_sample_data()\\n self.event_subscribers.clear_events()\\n self.assert_initialize()\\n self.create_sample_data('invalid_A0000003.DEC', \\\"A1000003.DEC\\\")\\n\\n # Verify an event was raised and we are in our retry state.\\n self.verify_queue_empty()\\n self.assert_event_received(ResourceAgentErrorEvent, 10)\\n self.assert_state_change(ResourceAgentState.STREAMING, 10)\\n\\n log.info(\\\"END QUAL TEST INVALID FLAG RECORD\\\")\",\n \"def ultrasonicChecker() -> None:\\n ...\",\n \"def test_read_one_signal_failure(self):\\n cwd = os.path.dirname(os.path.abspath(__file__))\\n dir1 = os.path.join(cwd, 'test_files/')\\n dir2 = '/home/tomas/here-be-dragons/'\\n signal1 = read_signal(dir1, 'here-be-dragons')\\n signal2 = read_signal(dir2, 'test3')\\n self.assertIsNone(signal1)\\n self.assertIsNone(signal2)\",\n \"def test_fp_elf(elf, expected):\\n elf_filename = os.path.join(elf_dir, elf)\\n epiphany = Epiphany()\\n with open(elf_filename, 'rb') as elf:\\n epiphany.init_state(elf, elf_filename, '', [], False, is_test=True)\\n epiphany.max_insts = 10000\\n epiphany.run()\\n expected.fp_check(epiphany.state)\",\n \"def event_m10_29_x39(flag1=105405, z15=10292020, z16=10292010, z17=100001, z18=100002, z21=10040000,\\r\\n z22=10320000, flag2=129010024):\\r\\n \\\"\\\"\\\"State 0,1: Is the destination door open?\\\"\\\"\\\"\\r\\n if GetEventFlag(flag2) != 0:\\r\\n pass\\r\\n else:\\r\\n Goto('L0')\\r\\n \\\"\\\"\\\"State 2: Intrusion MAP determination\\\"\\\"\\\"\\r\\n CompareEventFlag(0, z15, 1)\\r\\n if GetEventFlag(flag1) != 1:\\r\\n \\\"\\\"\\\"State 4: Wait for completion of reading Madura MAP\\\"\\\"\\\"\\r\\n IsMapReadAndBackreadStable(0, z21, 1)\\r\\n assert ConditionGroup(0)\\r\\n \\\"\\\"\\\"State 5: Open the Madura side door\\\"\\\"\\\"\\r\\n ChangeObjState(z15, 30)\\r\\n \\\"\\\"\\\"State 7: Made the Madura side door mesh mesh accessible\\\"\\\"\\\"\\r\\n DeleteNavimeshAttribute(z17, 2)\\r\\n else:\\r\\n \\\"\\\"\\\"State 3: Waiting for completion of reading of the Shadow Shadow Forest MAP\\\"\\\"\\\"\\r\\n IsMapReadAndBackreadStable(0, z22, 1)\\r\\n assert ConditionGroup(0)\\r\\n \\\"\\\"\\\"State 6: Open the door on the forest side of the hollow shadow\\\"\\\"\\\"\\r\\n ChangeObjState(z16, 30)\\r\\n \\\"\\\"\\\"State 8: Navimesh of the door on the forest side of the empty shadow is ready to enter\\\"\\\"\\\"\\r\\n DeleteNavimeshAttribute(z18, 2)\\r\\n \\\"\\\"\\\"State 9: Destination door opening complete\\\"\\\"\\\"\\r\\n return 0\\r\\n \\\"\\\"\\\"State 10: Destination door opening not completed\\\"\\\"\\\"\\r\\n Label('L0')\\r\\n return 1\",\n \"def after(self):\\n return self.marker_seen and not self.throwaway\",\n \"def event_m20_11_3020():\\n \\\"\\\"\\\"State 0,2: [Preset] Beautiful frog singing voice_flag_SubState\\\"\\\"\\\"\\n assert event_m20_11_x110(z24=211000081, z25=802, z26=211020082)\\n \\\"\\\"\\\"State 1: Finish\\\"\\\"\\\"\\n EndMachine()\",\n \"def test_read_foreign_device_table_ack(self):\\n if _debug: TestAnnexJCodec._debug(\\\"test_read_foreign_device_table_ack\\\")\\n\\n # read returns an empty table\\n pdu_bytes = xtob('81.07.0004')\\n\\n self.request(ReadForeignDeviceTableAck([]))\\n self.indication(pduData=pdu_bytes)\\n\\n self.response(PDU(pdu_bytes))\\n self.confirmation(ReadForeignDeviceTableAck, bvlciFDT=[])\\n\\n # read returns a table with one entry\\n fdte = FDTEntry()\\n fdte.fdAddress = Address(\\\"192.168.0.10\\\")\\n fdte.fdTTL = 30\\n fdte.fdRemain = 15\\n pdu_bytes = xtob('81.07.000e' # bvlci\\n 'c0.a8.00.0a.ba.c0' # address\\n '001e.000f' # ttl and remaining\\n )\\n\\n self.request(ReadForeignDeviceTableAck([fdte]))\\n self.indication(pduData=pdu_bytes)\\n\\n self.response(PDU(pdu_bytes))\\n self.confirmation(ReadForeignDeviceTableAck, bvlciFDT=[fdte])\",\n \"def mark_done(cf):\\n\\n with open(cf) as f:\\n hesh = hashlib.sha256(bytes(f.read(), 'utf-8')).hexdigest()\\n with open('done_log', 'a') as f:\\n f.write('{}\\\\t{}\\\\n'.format(cf, hesh))\",\n \"def onError(self, connection:MQTTConnection, rc:int) -> bool:\\n\\t\\treturn True\",\n \"def r2_on_off():\\n \\n r2_cmd_packet = b'\\\\x04\\\\x14\\\\x02\\\\x00\\\\x00\\\\xe6\\\\x0f'\\n ser_relay.write(r2_cmd_packet)\",\n \"def on(self) -> None:\\n ...\",\n \"def off(self):\\n status = self.dev.ctrl_transfer(0x40, 0x01, 0x0001, 0x20, [])\\n if status == 0:\\n self.ev.clear()\\n return (status == 0)\",\n \"def feed(self):\\n # or intelligence discard\\n pass\",\n \"def test_is_affordable_off_chain(self):\\n tx_message = TransactionMessage(\\n performative=TransactionMessage.Performative.PROPOSE_FOR_SETTLEMENT,\\n skill_callback_ids=[PublicId(\\\"author\\\", \\\"a_skill\\\", \\\"0.1.0\\\")],\\n tx_id=self.tx_id,\\n tx_sender_addr=self.tx_sender_addr,\\n tx_counterparty_addr=self.tx_counterparty_addr,\\n tx_amount_by_currency_id={\\\"FET\\\": -20},\\n tx_sender_fee=0,\\n tx_counterparty_fee=0,\\n tx_quantities_by_good_id={\\\"good_id\\\": 10},\\n ledger_id=\\\"off_chain\\\",\\n info=self.info,\\n tx_nonce=\\\"Transaction nonce\\\",\\n )\\n\\n assert self.decision_maker._is_affordable(tx_message)\",\n \"def _read_no_check(self):\\n on_data_fut = _async.Future(self._loop)\\n def on_data():\\n on_data_fut.set_result(None)\\n self._loop.add_reader(self._channel.fileno(), on_data)\\n\\n try:\\n yield From(on_data_fut)\\n finally:\\n self._loop.remove_reader(self._channel.fileno())\\n\\n d = self._channel.recv(_MAX_READ_AMOUNT).decode()\\n if d == '':\\n logger.debug(\\\"{}: Read returned {!r}\\\".format(self, d))\\n raise TransportNotConnected\\n\\n logger.debug(\\\"{}: Read {!r}\\\".format(self, d))\\n if d.endswith(\\\"\\\\r\\\\n\\\"):\\n d = d[:-2] + \\\"\\\\n\\\"\\n d = d.encode('ascii')\\n\\n raise Return(d)\",\n \"def test_fileDoesNotExist(self):\\n fp = FilePath(self.mktemp())\\n protocol = self.makeConnectedDccFileReceive(fp.path)\\n\\n self.allDataReceivedForProtocol(protocol, b\\\"I <3 Twisted\\\")\\n\\n self.assertEqual(fp.getContent(), b\\\"I <3 Twisted\\\")\",\n \"def test_export_to_mff_incompatible_sfreq():\\n pytest.importorskip(\\\"mffpy\\\", \\\"0.5.7\\\")\\n evoked = read_evokeds(fname_evoked)\\n with pytest.raises(ValueError, match=f'sfreq: {evoked[0].info[\\\"sfreq\\\"]}'):\\n export_evokeds(\\\"output.mff\\\", evoked)\",\n \"def test_fastaqual_output(self):\\r\\n self.assertRaises(IOError, convert_fastaqual, self.fasta_file_path,\\r\\n output_directory=self.read_only_output_dir)\",\n \"def emergency_recover_states_from_failure():\\n _emergency_state_check()\\n _emergency_iobuf_extract()\",\n \"def test_afni_fail():\\n im = ndar.Image('test_data/bogus.mnc')\\n nose.tools.assert_raises(AttributeError, lambda: im.afni)\",\n \"def event_m20_11_x84(z44=20111330):\\n \\\"\\\"\\\"State 0,1: Wait for branch destruction\\\"\\\"\\\"\\n IsObjBroken(0, z44, 1)\\n assert ConditionGroup(0)\\n \\\"\\\"\\\"State 2: End state\\\"\\\"\\\"\\n return 0\",\n \"def test_goto_field_boss_ffs_open_fails(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n self.cmd.failOn = 'mcp ffs.open'\\n self._goto_field_boss(21, 102, 1, 1, cmdState, didFail=True, finish=True)\",\n \"def test_handle_flag_error(self):\\n pass\",\n \"def connectionTest(self):\\n\\n print(\\\"Turn on the Tiva\\\")\\n g_byte = self.ser.read(1)\\n o_byte = self.ser.read(1)\\n\\n if (g_byte.decode(\\\"ascii\\\") != \\\"G\\\") | (o_byte.decode(\\\"ascii\\\") != \\\"O\\\"):\\n print(\\\"Unsuccessful Serial Connection to Tiva, Try Again\\\")\\n else:\\n print(\\\"Successful Serial Connection to Tiva\\\")\",\n \"def test_read_before_connected(connection, reader, loop):\\n value = loop.run_until_complete(connection.read())\\n assert not value\\n assert not reader.used\",\n \"def eof(self):\\n try:\\n next_line = self.read_pkt_line()\\n except HangupException:\\n return True\\n self.unread_pkt_line(next_line)\\n return False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.53135496","0.530685","0.5285612","0.5125348","0.51056355","0.50907296","0.50692505","0.50690484","0.4983307","0.49766693","0.4912766","0.4895812","0.48652288","0.48498195","0.48497722","0.48134395","0.4810314","0.4796255","0.47883302","0.47843057","0.4778215","0.47579592","0.4754952","0.4753049","0.47379392","0.47262964","0.47199935","0.47079217","0.47061372","0.47047815","0.46931088","0.46908864","0.46880132","0.4687745","0.46690676","0.4654544","0.4644666","0.4640219","0.4640051","0.46346563","0.46288723","0.4624529","0.46156088","0.46131313","0.46039304","0.4602639","0.45965955","0.45952547","0.45856345","0.4580515","0.45774114","0.45696607","0.4568556","0.45683652","0.45454282","0.45399395","0.45249984","0.45239082","0.45231768","0.4520772","0.45183682","0.4503348","0.4490995","0.4488729","0.44723383","0.44720563","0.4468204","0.44625813","0.446122","0.44582427","0.44578052","0.4451904","0.44389504","0.4437572","0.44323114","0.44319713","0.4428154","0.44277015","0.44255772","0.44254854","0.4425484","0.4425338","0.4421694","0.44124645","0.44053817","0.4402132","0.43965948","0.43956834","0.4387314","0.43778116","0.4372253","0.43719193","0.43677345","0.4367365","0.43663144","0.43647474","0.43646795","0.43629315","0.43576276","0.43539232"],"string":"[\n \"0.53135496\",\n \"0.530685\",\n \"0.5285612\",\n \"0.5125348\",\n \"0.51056355\",\n \"0.50907296\",\n \"0.50692505\",\n \"0.50690484\",\n \"0.4983307\",\n \"0.49766693\",\n \"0.4912766\",\n \"0.4895812\",\n \"0.48652288\",\n \"0.48498195\",\n \"0.48497722\",\n \"0.48134395\",\n \"0.4810314\",\n \"0.4796255\",\n \"0.47883302\",\n \"0.47843057\",\n \"0.4778215\",\n \"0.47579592\",\n \"0.4754952\",\n \"0.4753049\",\n \"0.47379392\",\n \"0.47262964\",\n \"0.47199935\",\n \"0.47079217\",\n \"0.47061372\",\n \"0.47047815\",\n \"0.46931088\",\n \"0.46908864\",\n \"0.46880132\",\n \"0.4687745\",\n \"0.46690676\",\n \"0.4654544\",\n \"0.4644666\",\n \"0.4640219\",\n \"0.4640051\",\n \"0.46346563\",\n \"0.46288723\",\n \"0.4624529\",\n \"0.46156088\",\n \"0.46131313\",\n \"0.46039304\",\n \"0.4602639\",\n \"0.45965955\",\n \"0.45952547\",\n \"0.45856345\",\n \"0.4580515\",\n \"0.45774114\",\n \"0.45696607\",\n \"0.4568556\",\n \"0.45683652\",\n \"0.45454282\",\n \"0.45399395\",\n \"0.45249984\",\n \"0.45239082\",\n \"0.45231768\",\n \"0.4520772\",\n \"0.45183682\",\n \"0.4503348\",\n \"0.4490995\",\n \"0.4488729\",\n \"0.44723383\",\n \"0.44720563\",\n \"0.4468204\",\n \"0.44625813\",\n \"0.446122\",\n \"0.44582427\",\n \"0.44578052\",\n \"0.4451904\",\n \"0.44389504\",\n \"0.4437572\",\n \"0.44323114\",\n \"0.44319713\",\n \"0.4428154\",\n \"0.44277015\",\n \"0.44255772\",\n \"0.44254854\",\n \"0.4425484\",\n \"0.4425338\",\n \"0.4421694\",\n \"0.44124645\",\n \"0.44053817\",\n \"0.4402132\",\n \"0.43965948\",\n \"0.43956834\",\n \"0.4387314\",\n \"0.43778116\",\n \"0.4372253\",\n \"0.43719193\",\n \"0.43677345\",\n \"0.4367365\",\n \"0.43663144\",\n \"0.43647474\",\n \"0.43646795\",\n \"0.43629315\",\n \"0.43576276\",\n \"0.43539232\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.51799893"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":490,"cells":{"query":{"kind":"string","value":"Hartmann succeeds but the blue ring move is out of tolerance."},"document":{"kind":"string","value":"def test_goto_field_boss_hartmann_blue_fails(self):\n\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n sopTester.updateModel('hartmann', TestHelper.hartmannState['blue_fails'])\n\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n\n self._goto_field_boss(12, 37, 0, 0, cmdState, didFail=True, finish=True)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_W_end(self):\t\t\n self.assertAlmostEqual(attempt.W[-1], 9.494852380803035)","def steadyYet(newg, oldg, newe, olde, newh, oldh, newf, oldf, tolerance):\n steady_yet = True\n if oldg == 0 or (abs(newg-oldg)/oldg > tolerance or\n abs(newe-olde)/olde > tolerance or\n abs(newh-oldh)/oldh > tolerance or\n abs(newf-oldf)/oldf > tolerance):\n steady_yet = False\n return steady_yet","def test_Z_start(self):\t\t\n self.assertAlmostEqual(attempt.Z[0], 40)","def explicit_half_kick(self):\n rejected = False\n momentum = self.momentum.clone()\n old_momentum = momentum.clone()\n hamiltonian = self.get_hamiltonian()\n d_hamiltonian = torch.autograd.grad(hamiltonian, self.parameters, retain_graph=False)[0]\n momentum -= 0.5 * self.stepsize * d_hamiltonian\n if self._is_nanned(self.momentum):\n rejected = True\n self.momentum = old_momentum\n# if self.verbose:\n print('Nanned during explit momentum update {}'.format(iter))\n return momentum, rejected","def test_full_chelyabinsk(self, tolerance=0.1):\n conditions = [8.5, 19.2e3, 3300, 4e6, 18.3*np.pi/180]\n system = asteroid(*conditions)\n system.solve_ode()\n peak = [system.burst['height (km)'], system.burst['ke Lost (kt/km)']]\n peak = np.array(peak)\n\n obs_peak = np.array([29.5578, 81.505])\n diff = abs(peak - obs_peak)\n assert np.all(diff < obs_peak * tolerance), \\\n \"chelyabinsk simulation does not match imperical data\"","def _hill_diff(self, position):\n if position < 0:\n return 2 * position + 1\n else:\n return (1/math.sqrt(1 + 5 * position ** 2)\n - 5 * position ** 2 * (1 + 5 * position ** 2)**-1.5)","def test_phantom_roll(self):\n self.assertAlmostEqual(self.cheese.catphan_roll, self.expected_roll, delta=0.3)","def test_t(self):\n assert np.isclose(self.stepper.t, self.final_t)","def test_EvaluatorWallHarmonic_energy(make_state):\n state = make_state['state']\n springConstant = 5.0\n cutoff = 10.0\n harmonicWall = EvaluatorWallHarmonic(springConstant, cutoff)\n\n distancesFromWall = [1.57079632679, # pi/2\n 3.14159265359, # pi\n 5.0, # 5\n 6.28318530718, # 2 * pi\n 9.32737905309] # sqrt(87)\n\n def energy(distanceFromWall):\n if (distanceFromWall < cutoff):\n return 0.5 * springConstant * ((cutoff - distanceFromWall) ** 2.0)\n else:\n return 0.0\n\n # test for each value of distance from the wall\n tolerance = 1e-10\n\n for _, item in enumerate(distancesFromWall):\n calculatedEnergy = harmonicWall.energy(item)\n expectedEnergy = energy(item)\n formatCode = \"{:<30s} {:>18.14f}\"\n print(formatCode.format(\"calculatedEnergy: \", calculatedEnergy))\n print(formatCode.format(\"expectedEnergy: \", expectedEnergy))\n\n absoluteDifference = np.abs(calculatedEnergy - expectedEnergy)\n\n relativeError = absoluteDifference / (np.abs(expectedEnergy))\n print((formatCode+\"\\n\").format(\"percentError: \", relativeError * 100.0))\n\n assert(relativeError <= tolerance)","def test_single_caps(self):\n result_h = mmc.find_molar_mass('H')\n actual_h = 1.007940\n self.assertTrue(abs(percent_error(result_h, actual_h)) < self.ERR_THRESHOLD)","def _hill_diff_diff(self, position):\n if position < 0:\n return 2\n else:\n return position * ((75 * (position ** 2)/((1 + 5 * position**2)**2.5)) - 5/((1 + 5 * position ** 2)**2.5)) \\\n - 10 * position/((1 + 5 * position ** 2)**1.5)","def test_W_start(self):\t\t\n self.assertAlmostEqual(attempt.W[0], 12)","def test_AKs_correct_preflop_odds(self):\n self.assertEqual(self.hand.preFlopOdds10, 20.7)","def test_lorentz_broadening():\n v0 = 100\n I = 10\n w = 1.0\n\n assert lorentz(v0, v0, I, w) == approx(5)","def calc_tolerance(wt):\n return 1 - wt","def implicit_half_kick(self):\n stored_momentum = self.momentum.clone()\n rejected = False\n best_diff = torch.tensor(100.)\n for iter in range(self._max_fixed_point_iterations):\n old_momentum = self.momentum.clone()\n self.parameters = self.parameters.detach().requires_grad_(True)\n hamiltonian = self.get_hamiltonian()\n d_hamiltonian = torch.autograd.grad(hamiltonian,self.parameters,retain_graph = True)[0]\n self.momentum = stored_momentum - 0.5 * self.stepsize * d_hamiltonian\n if self._is_nanned(self.momentum):\n rejected = True\n self.momentum = old_momentum\n if self.verbose:\n print('Nanned during momentum update {}'.format(iter))\n break\n diff = torch.max((old_momentum - self.momentum) ** 2)\n if diff < self._fixed_point_threshold:\n break\n if diff<best_diff:\n best_diff = diff\n elif iter == self._max_fixed_point_iterations-1:\n rejected = True\n if self.verbose:\n print('Exceeded maximum iterations during momentum update')\n break\n# print('Warning: reached {} iterations in momentum update. Smallest iteration ({}) was selected'.format(self._max_fixed_point_iterations, best_diff.item()))\n momentum = self.momentum\n return momentum, rejected","def nearest_test_pulse(self):","def test_weierstrass(self):\n fun = get_problem('weierstrass', self.dimension, -100, 100)\n self.assertAlmostEqual(fun(self.array10), 0.0, delta=1e-4)","def test_schaffer_n4(self):\n fun = get_problem('schaffer4', lower=-100, upper=100)\n self.assertAlmostEqual(fun(self.array10[:2]), 0.97545, delta=1e-4)","def testMatchSwarpNearestExposure(self):\n self.compareToSwarp(\"nearest\", useWarpExposure=True, atol=60)","def test_EvaluatorWallHarmonic_force(make_state):\n state = make_state['state']\n springConstant = 5.0\n cutoff = 10.0\n harmonicWall = EvaluatorWallHarmonic(springConstant, cutoff)\n\n # distancesFromWall; make it so that a couple results not representable as an integer\n distancesFromWall = [1.57079632679, # pi/2\n 3.14159265359, # pi\n 5.0, # 5\n 6.28318530718, # 2 * pi\n 9.32737905309] # sqrt(87)\n\n # forceDirection must have a magnitude of 1.0;\n # -- in DASH, this is normalized on instantiation of FixWallHarmonic\n forceDirection = Vector(1.0, 0.0, 0.0)\n\n # put explicitly the form of the expected force\n def force(distanceFromWall, direction):\n if (distanceFromWall <= cutoff):\n return direction * springConstant * np.abs((cutoff - distanceFromWall))\n else:\n return Vector(0.0, 0.0, 0.0)\n\n\n # test for each value of distance from the wall\n tolerance = 1e-10\n\n for _, item in enumerate(distancesFromWall):\n calculatedForce = harmonicWall.force(item, forceDirection)\n expectedForce = force(item, forceDirection)\n formatCode = '{:<30s} {:>18.14f} {:>18.14f} {:>18.14f}'\n print(formatCode.format(\"calculatedForce: \", calculatedForce[0], calculatedForce[1], calculatedForce[2]))\n print(formatCode.format(\"expectedForce: \", expectedForce[0], expectedForce[1], expectedForce[2]))\n\n absoluteDifference = (calculatedForce - expectedForce).len()\n\n relativeError = absoluteDifference / (expectedForce.len())\n print(\"{:<30s} {:>18.14f}\\n\".format(\"percent error: \", relativeError * 100.0))\n\n assert(relativeError <= tolerance)","def testHeuristic(self):\n result = Sigmoid.heuristic(self, 12)\n self.assertEqual(0.28867513459481287, result)","def test_expanded_griewank_plus_rosenbrock(self):\n fun = get_problem('expanded_griewank_plus_rosenbrock', self.dimension, -100, 100)\n self.assertAlmostEqual(fun(self.array), 2.2997, delta=1e2)","def test_nearest_boundary_odd():\n assert _nearest_boundary(10, 19, 14, 0) == 0\n assert _nearest_boundary(10, 19, 14, 1) == 1","def constant_r_success(r_target, tol):\n def isdone(node_dict):\n \"\"\"return a delta heading value to best turn to heading\"\"\"\n # compute heading difference\n hdiff = heading_diff(r_target, node_dict['pn'].heading)\n # return if we are we close enough\n return abs(hdiff) < abs(tol)\n\n # return the function we just created\n return isdone","def test_ackley(self):\n fun = get_problem('ackley', self.dimension)\n self.assertAlmostEqual(fun(self.array), 0.0, places=10)","def test_hgbat(self):\n fun = get_problem('hgbat', self.dimension, -100, 100)\n self.assertAlmostEqual(fun(self.array10), 61.91502622129181, delta=60)","def test_highway_ramps(self):\n # import the experiment variable from the example\n exp = highway_ramps_example(render=False)\n\n # run the experiment for a few time steps to ensure it doesn't fail\n exp.run(1, 5)","def test_99_correct_preflop_odds(self):\n self.assertEqual(self.hand.preFlopOdds10, 15.6)","def wait(self):\n self.set_vals(spin=.2)\n nearest_deg = 0\n nearest_deg_dist = self.perim_dist + 1\n for i, x in enumerate(self.ranges):\n if (x != 0) and (x < nearest_deg_dist):\n nearest_deg = i\n nearest_deg_dist = x\n if nearest_deg_dist < self.perim_dist:\n nearest_deg = ((nearest_deg + 180) % 360) - 180\n self.center(degree=nearest_deg)\n self.current_state = \"follow\"","def test_ForwardEuler_against_hand_calculations():\n def f(u, t):\n return u\n u, t = ForwardEuler(f, U0=1, T=0.2, n=2)\n exact = np.array([1, 1.1, 1.21]) # hand calculations\n error = np.abs(exact - u).max()\n success = error < 1E-14\n assert success, '|exact - u| = %g != 0' % error","def hanging_man(self):\n self.data['hanging_man'] = (((self.data['High'] - self.data['Low']) > ((self.data['Open'] - self.data['Close'])*4)) & \\\n ((self.data['Close'] - self.data['Low']) / ((.001 + self.data['High'] - self.data['Low']) >= 0.75)) &\\\n ((self.data['Open'] - self.data['Low']) / ((.001 + self.data['High'] - self.data['Low']) >= .075)))","def test_ridge(self):\n fun = get_problem('ridge', dimension=self.dimension, lower=-64, upper=64)\n self.assertAlmostEqual(fun(self.array10), 371.0, delta=1e-4)","def test_comp_angle_wind_eq(self, test_dict):\n test_obj = test_dict[\"test_obj\"]\n result = test_obj.slot.comp_angle_wind_eq()\n\n a = result\n b = test_dict[\"Aw\"]\n msg = \"Return \" + str(a) + \" expected \" + str(b)\n self.assertAlmostEqual((a - b) / a, 0, delta=DELTA, msg=msg)","def test_57o_correct_preflop_odds(self):\n self.assertEqual(self.hand.preFlopOdds10, 7.9)","def heuristic_3_correction(h: float, root_h: float):\n # resultant =\n resultant = 1 - ((h / root_h) if h < root_h else 0)\n logger.debug(f'Corrected heuristic value 3: {resultant}')\n return resultant","def test_percent_dewpoint_from_relative_humidity():\n td = dewpoint_from_relative_humidity(10.6 * units.degC, 37 * units.percent)\n assert_almost_equal(td, 26. * units.degF, 0)","def _wait_for_pole_at_rest(self, thold_ang_vel: float = 0.1 / 180.0 * np.pi):\n cnt = 0\n while cnt < 1.5 / self._dt:\n # Get next measurement\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\n\n if np.abs(meas[2]) < thold_ang_vel and np.abs(meas[3]) < thold_ang_vel:\n cnt += 1\n else:\n cnt = 0","def test_EvaluatorWallHarmonic_energy_device(make_state):\n state = make_state['state']\n springConstant = 5.0\n cutoff = 10.0\n harmonicWall = EvaluatorWallHarmonic(springConstant, cutoff)\n\n distancesFromWall = [1.57079632679, # pi/2\n 3.14159265359, # pi\n 5.0, # 5\n 6.28318530718, # 2 * pi\n 9.32737905309] # sqrt(87)\n\n def energy(distanceFromWall):\n if (distanceFromWall < cutoff):\n return 0.5 * springConstant * ((cutoff - distanceFromWall) ** 2.0)\n else:\n return 0.0\n\n # test for each value of distance from the wall\n tolerance = 1e-10\n\n for _, item in enumerate(distancesFromWall):\n calculatedEnergy = harmonicWall.energy_device(item)\n expectedEnergy = energy(item)\n formatCode = \"{:<30s} {:>18.14f}\"\n print(formatCode.format(\"calculatedEnergy: \", calculatedEnergy))\n print(formatCode.format(\"expectedEnergy: \", expectedEnergy))\n\n absoluteDifference = np.abs(calculatedEnergy - expectedEnergy)\n\n relativeError = absoluteDifference / (np.abs(expectedEnergy))\n print((formatCode+\"\\n\").format(\"percentError: \", relativeError * 100.0))\n\n assert(relativeError <= tolerance)","def test_modified_schwefel(self):\n fun = get_problem('modified_schwefel', self.dimension, -100, 100)\n self.assertAlmostEqual(fun(self.array10), 6.9448853328785844, delta=350)","def test_comp_surface_wind(self, test_dict):\n test_obj = test_dict[\"test_obj\"]\n result = test_obj.slot.comp_surface_wind()\n\n a = result\n b = test_dict[\"SW_exp\"]\n msg = \"Return \" + str(a) + \" expected \" + str(b)\n self.assertAlmostEqual((a - b) / a, 0, delta=DELTA, msg=msg)","def test_G_H(self):\r\n chkmtx = (numpy.dot(golay.DEFAULT_G, golay.DEFAULT_H.T) % 2)\r\n self.assertTrue((chkmtx == 0).all())","def minimum_spanning_arborescence(sol):","def test_c(self):\n self.failIf(cgs.speed_of_light/mks.speed_of_light!=100)","def test_isentropic_pressure_p_increase_rh_out():\n lev = [85000., 90000., 95000., 100000.] * units.Pa\n tmp = np.ones((4, 5, 5))\n tmp[0, :] = 288.\n tmp[1, :] = 290.\n tmp[2, :] = 292.\n tmp[3, :] = 296.\n tmpk = tmp * units.kelvin\n rh = np.ones((4, 5, 5))\n rh[0, :] = 20.\n rh[1, :] = 40.\n rh[2, :] = 80.\n rh[3, :] = 100.\n relh = rh * units.percent\n isentlev = 296. * units.kelvin\n isentprs = isentropic_interpolation(isentlev, lev, tmpk, relh)\n truerh = 100. * units.percent\n assert_almost_equal(isentprs[1], truerh, 3)","def test_far_and_near(module_class: mantrap.modules.base.OptimizationModule.__class__,\n env_class: mantrap.environment.base.GraphBasedEnvironment.__class__):\n env = env_class(torch.tensor([-5, 100.0]), ego_type=mantrap.agents.IntegratorDTAgent, y_axis=(-100, 100))\n env.add_ado(position=torch.zeros(2))\n\n start_near, end_near = torch.tensor([-5, 0.1]), torch.tensor([5, 0.1])\n ego_path_near = mantrap.utility.maths.straight_line(start=start_near, end=end_near, steps=11)\n ego_trajectory_near = env.ego.expand_trajectory(ego_path_near, dt=env.dt)\n\n start_far, end_far = torch.tensor([-5, 100.0]), torch.tensor([5, 10.0])\n ego_path_far = mantrap.utility.maths.straight_line(start=start_far, end=end_far, steps=11)\n ego_trajectory_far = env.ego.expand_trajectory(ego_path_far, dt=env.dt)\n\n module = module_class(t_horizon=10, env=env)\n objective_near = module.objective(ego_trajectory_near, ado_ids=[], tag=\"test\")\n objective_far = module.objective(ego_trajectory_far, ado_ids=[], tag=\"test\")\n assert objective_near >= objective_far","def _ftolCheck(self):\n oldLoss = biggestRecentLoss(self.loss, self.lookback)\n newLoss = float(self.loss[-1])\n fracDiff = 2 * (oldLoss - newLoss)/(oldLoss + newLoss)\n \n if fracDiff < self.ftol:\n \n self.converged = True","def test_sense_distance(self):\n\n\t\tmeasurements = [29, 29, 28]\n\t\tself.driver.us_dist.side_effect = lambda x: measurements.pop()\n\t\texpected_measurement = int(ultrasonic_sensor_error(29))\n\n\t\tself.assertEqual(self.s.sense_distance(60), expected_measurement)\n\t\tself.mount.move.assert_called_once_with(x=60)","def test_benjamini_hochberg_step_down(self):\r\n # r values\r\n # q = c(0.64771481, 0.93517796, 0.7169902 , 0.18223457, 0.26918556,\r\n # 0.1450153 , 0.22448242, 0.74723508, 0.89061034, 0.74007906)\r\n # p.adjust(q, method='BH')\r\n # [1] 0.9340439 0.9351780 0.9340439 0.6729639 0.6729639 0.6729639 0.6729639\r\n # [8] 0.9340439 0.9351780 0.9340439\r\n pvals = array([0.64771481, 0.93517796, 0.7169902, 0.18223457,\r\n 0.26918556, 0.1450153, 0.22448242, 0.74723508, 0.89061034,\r\n 0.74007906])\r\n exp = array([0.9340439, 0.9351780, 0.9340439, 0.6729639, 0.6729639,\r\n 0.6729639, 0.6729639, 0.9340439, 0.9351780, 0.9340439])\r\n obs = benjamini_hochberg_step_down(pvals)\r\n self.assertFloatEqual(obs, exp)\r\n # example 2\r\n pvals = array([1.32305426, 1.9345059, 0.87129877, 1.89957702,\r\n 1.85712616, 0.68757988, 0.41248969, 0.20751712, 1.97658599,\r\n 1.06209437])\r\n exp = array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])\r\n obs = benjamini_hochberg_step_down(pvals)\r\n self.assertFloatEqual(obs, exp)","def test_michalewicz(self):\n fun = get_problem('michalewicz', dimension=2, lower=0, upper=np.pi)\n self.assertAlmostEqual(fun(np.asarray([2.20, 1.57])), -1.8013, delta=1e-3)","def test_williams_correction(self):\r\n n = 100\r\n a = 10\r\n G = 10.5783\r\n exp = 10.387855973813421\r\n self.assertFloatEqual(williams_correction(n, a, G), exp)\r\n # test with an example from Sokal and Rohlf pg 699\r\n n = 241\r\n a = 8\r\n G = 8.82396\r\n exp = 8.76938\r\n self.assertFloatEqual(williams_correction(n, a, G), exp)","def step():\n x_rand = sample()\n x_nearest = new_nearest_neighbour(x_rand)\n x_new = steer(x_nearest, x_rand)\n if obstacle_free(x_nearest, x_new):\n X_near = new_neighbourhood(x_new)\n x_min = x_nearest\n c_min = x_nearest.cost + x_nearest.dist_to(x_new)\n for x_near in X_near:\n if obstacle_free(x_near, x_new) and (x_near.cost + x_near.dist_to(x_new) < c_min):\n x_min = x_near\n c_min = (x_near.cost + x_near.dist_to(x_new) < c_min)\n x_new_node = add_node(x_new, x_min, True)\n for x_near in X_near:\n if obstacle_free(x_near, x_new) and (x_new_node.cost + x_near.dist_to(x_new) < x_near.cost):\n x_near.change_parent(x_new_node)\n # Here I check for goal paths and draw the circle\n updated = False\n if shared.root_path:\n updated = goal_path_resolve(shared.root_path[0])\n updated = updated or goal_path_resolve(shared.nodes[-1])\n if updated:\n diameter = shared.root_path_length\n center = ((shared.root_path[0].x + shared.root_path[-1].x) / 2,\n (shared.root_path[0].y + shared.root_path[-1].y) / 2)\n if shared.region:\n shared.region.remove_from_batch()\n shared.region = ellipse.Ellipse(center[0], center[1], diameter)\n shared.region.add_to_batch()","def checkRing(self, verbose = 0):\n angleSum = self.tfs.ANGLE.sum()\n if self.verbose: print (\"check\")\n print (\"---------------------------------- \\n Checking, if ring is closed: \\n\", \"angleSum = \", angleSum)\n twoPi = 2*pi\n \n if angleSum != twoPi:\n fudge = 2*pi - angleSum\n print (\" ** Ring not closed - offset of: \", fudge)","def testgradsorientation(self):\r\n # since z-coordinates of atomcoords are all 0 for dvb, z-values of grads should be all 0\r\n assert numpy.alltrue(numpy.abs(self.data.grads[:,:,2]) < 1e-14)","def testCorrectForTwoAtomCellWithoutPeriodicityNEEDED(self):\n\t\texpDist = 0.01*10\n\t\tself._checkExpMatchesActual(expDist)","def u_turn(self, direction, diameter_in):\n \n# pdb.set_trace()\n # Calculate radius of turn for the inside wheel.\n r_in = diameter_in / 2\n\n # Outside radius is 20 inches from inside radius.\n r_out = r_in + MuleBot.WHEEL_BASE_LENGTH\n \n # Outside travel distance\n travel = r_out * 3.14159\n travel_revolutions = travel / MuleBot.CIRCUM_IN\n \n r_ratio = r_out / r_in\n #r_ratio_half = r_ratio / 2\n\n speed_multiplier = MuleBot.MAX_RPM / r_ratio\n\n outside_rpm = r_ratio * speed_multiplier\n inside_rpm = speed_multiplier\n \n \n # \n # minutes at outside_rpm\n minutes = travel_revolutions / outside_rpm\n seconds = minutes * MuleBot.SECONDS_PER_MINUTE\n \n # Something isn't quite perfect.\n if direction == 'left':\n if diameter_in < 25:\n seconds -= 1\n else:\n seconds -= 2\n else:\n if diameter_in < 25:\n seconds += 1\n else:\n seconds += 2\n\n if direction == 'left':\n v_l = self.rpm_to_rps(inside_rpm)\n v_r = self.rpm_to_rps(outside_rpm)\n else:\n v_r = self.rpm_to_rps(inside_rpm)\n v_l = self.rpm_to_rps(outside_rpm)\n\n #print(\"2inside: rpm: \", inside_rpm)\n #print(\"2outside: rpm: \", outside_rpm)\n \n #print(\"2.1: v_l: \", v_l)\n #print(\"2.1: v_r: \", v_r)\n\n # Set wheel drive rates.\n self.set_wheel_drive_rates(v_l, v_r)\n\n # Sleep during the turn.\n time.sleep(seconds)\n\n # Stop\n self.stop()\n \n # Move forward 24 inches.\n self.forward(24)","def testSpeciesRichnessNear(self):\n self.assertAlmostEqual(1.0, self.tree1.get_number_individuals() / self.tree2.get_number_individuals(), 0)","def check_offset(self):\n\n for d in range(self.n_dmps):\n if abs(self.y0[d] - self.goal[d]) < 1e-4:\n self.goal[d] += 1e-4","def test_newton_rhapson_system(testFunctions, tol, printFlag): \n pass","def test_hermitian_expectation(self, device, tol):\n n_wires = 2\n dev = device(n_wires)\n dev_def = qml.device(\"default.qubit\", wires=n_wires)\n\n if dev.shots is not None:\n pytest.skip(\"Device is in non-analytical mode.\")\n\n if \"Hermitian\" not in dev.observables:\n pytest.skip(\"Device does not support the Hermitian observable.\")\n\n if dev.name == dev_def.name:\n pytest.skip(\"Device is default.qubit.\")\n\n theta = 0.432\n phi = 0.123\n A_ = np.array(\n [\n [-6, 2 + 1j, -3, -5 + 2j],\n [2 - 1j, 0, 2 - 1j, -5 + 4j],\n [-3, 2 + 1j, 0, -4 + 3j],\n [-5 - 2j, -5 - 4j, -4 - 3j, -6],\n ]\n )\n A_.requires_grad = False\n\n def circuit(theta, phi):\n qml.RX(theta, wires=[0])\n qml.RX(phi, wires=[1])\n qml.CNOT(wires=[0, 1])\n return qml.expval(qml.Hermitian(A_, wires=[0, 1]))\n\n qnode_def = qml.QNode(circuit, dev_def)\n qnode = qml.QNode(circuit, dev)\n\n grad_def = qml.grad(qnode_def, argnum=[0, 1])\n grad = qml.grad(qnode, argnum=[0, 1])\n\n assert np.allclose(qnode(theta, phi), qnode_def(theta, phi), atol=tol(dev.shots))\n assert np.allclose(grad(theta, phi), grad_def(theta, phi), atol=tol(dev.shots))","def test_jaro_winkler():\n assert textdistance.jaro_winkler(\"campell\", \"campbell\") == pytest.approx(0.9792, abs=0.01)\n assert textdistance.jaro_winkler(\"shakelford\", \"shakleford\") == pytest.approx(0.9848, abs=0.01)\n assert textdistance.jaro_winkler(\"dwayne\", \"duane\") == pytest.approx(0.84, abs=0.01)","def _check_redshift(self, red):\n if np.min(np.abs(red - self.zout)) > 0.01:\n return 0\n return 1","def test_fill_glass__with_overflow__returns_expected(number):\n glass = moet.create_glass(\"A\")\n overflow = glass.fill(number)\n assert overflow == number - 250\n assert glass.quantity == 250","def test_H_hat(self):\n\t\tposition = [0.0, 1.57079, 3.14159, 4.71238, 6.28318, 7.85398, 9.42477]\n\t\tpotential = [0.0, 6.0, 0.0, -6.0, 0.0, 6.0, 0.0]\n\t\tc = 1\n\t\tposition = tf.constant(position, shape = [1, len(position)], dtype = tf.float32)\n\t\tpotential = tf.constant(potential, shape = [1, len(potential)], dtype = tf.float32)\n\t\tbasis = schrodinger.create_basis(5)\n\t\tv = schrodinger.v0(position, potential, basis)\n\t\tcoeff = schrodinger.coefficient(position, basis)\n\t\tv0_hat = tf.linalg.solve(coeff, v)\n\t\tH = schrodinger.H_hat(c, len(basis), v0_hat)\n\t\tself.assertEqual(coeff.get_shape(), [len(basis), len(basis)])","def test_setMassFrac(self):\n target35 = 0.2\n self.fuel.setMassFrac(\"U235\", target35)\n self.assertAlmostEqual(self.fuel.getMassFrac(\"U235\"), target35)","def test_relaxation_end(self):\n tau = 50.0\n mrate = 40.0\n Mrate = 120.0\n\n tmax = 50.0\n dt = 0.1\n relaxation = 20.0\n\n self.rule.tau = tau\n self.rule.min_rate = mrate\n self.rule.max_rate = Mrate\n self.rule.compress_rates = False\n self.rule.relaxation = relaxation\n\n self.motor.error_fct = lambda _: np.ones(self.Nsrc)\n\n M = simulation.StateMonitor(self.rule, 'out')\n\n sim = simulation.Simulation(self.source, self.motor, self.rule, M, dt=dt)\n sim.run(tmax)\n\n mask = (M.t > tmax - relaxation/2)\n mavg = 0.5*(mrate + Mrate)\n\n self.assertAlmostEqual(np.mean(np.abs(M.out[:, mask] - mavg)), 0.0)","def test_Z_end(self):\t\t\n self.assertAlmostEqual(attempt.Z[-1], 41.47999849170943)","def test_stokes_drag():\n assert DM.stokes_drag(fluid_velocity=1.0, particle_velocity=0.0,\n diameter=1.0, rho=1.0, fluid_viscosity=1.0) == 18.0","def look_ahead_heuristic(game, player):\n if game.is_loser(player):\n return float('-inf')\n\n if game.is_winner(player):\n return float('inf')\n\n own_legal_moves = game.get_legal_moves(player)\n own_moves = len(own_legal_moves)\n for m in own_legal_moves:\n own_moves += len(game.__get_moves__(m))\n\n opp_legal_moves = game.get_legal_moves(game.get_opponent(player))\n opp_moves = len(opp_legal_moves)\n for m in opp_legal_moves:\n opp_moves += len(game.__get_moves__(m))\n\n return float(own_moves - opp_moves)","def use_manhatten_heur(self):\r\n\t\tdistance = 0\r\n\r\n\t\tfor row in range(self.n):\r\n\t\t\tfor col in range(self.n):\r\n\t\t\t\tintendedX, intendedY = BoardClass.goalTileLocations[self.board[row][col]]\r\n\t\t\t\tdistance += (abs(row - intendedX) + abs(col - intendedY))\r\n\r\n\t\tself.heuristic = distance","def test_hanoi(disks=10):\n t = Hanoi(disks, verbose=False)\n assert t.tower == {'a': list(range(disks, 0, -1)), 'b': [], 'c': []}\n t.solve_hanoi()\n assert t.tower == {'a': [], 'b': [], 'c': list(range(disks, 0, -1))}","def dichotomous_search(loss_function: rosenbrock, start: point, direction: list, epsilon=0.1) -> float:\n a, b = advance_retreat_method(loss_function, start, direction)\n\n # find the minimum\n e = epsilon / 3\n p, q = (a + b) / 2 - e, (a + b) / 2 + e\n while abs(a - b) > epsilon:\n f_p = loss_function.f(start + point(direction[0] * p, direction[1] * p))\n f_q = loss_function.f(start + point(direction[0] * q, direction[1] * q))\n if f_p < f_q:\n b = q\n else:\n a = p\n p, q = (a + b) / 2 - e, (a + b) / 2 + e\n\n return (a + b) / 2","def next_move(hunter_position, hunter_heading, target_measurement, max_distance, OTHER = None):\n # This function will be called after each time the target moves.\n\n # The OTHER variable is a place for you to store any historical information about\n # the progress of the hunt (or maybe some localization information). Your return format\n # must be as follows in order to be graded properly.\n\n # helper function to map all angles onto [-pi, pi]\n def angle_truncate(a):\n while a < 0.0:\n a += pi * 2\n return ((a + pi) % (pi * 2)) - pi\n\n #print \"true heading\"\n #print test_target.heading\n I = matrix([[1, 0, 0],\n [0, 1, 0],\n [0, 0, 1]]) #identity matrix\n\n R = matrix([[measurement_noise, 0], [0, measurement_noise]])\n\n H = matrix([[0, 1, 0],\n [0, 0, 1]]) #Jacobian of the measurement function\n\n u = matrix([[0],\n [0],\n [0]])\n\n F = []\n\n heading = 0 #WILD ASS GUESS\n\n if OTHER is not None:\n print \"-----------------\"\n current_measurement = target_measurement\n last_measurement = OTHER['last_measurement']\n OTHER['measurements'].append(target_measurement)\n #I know this is stupid but I just want to save the data... Memory management be damned\n\n heading = atan2(target_measurement[1] - last_measurement[1], target_measurement[0] - last_measurement[0])\n print \"calculated heading\"\n print heading\n X = OTHER['X']\n P = OTHER['P']\n\n if 'last_heading' not in OTHER:\n OTHER['last_heading'] = heading\n xy_estimate = [X.value[1][0], X.value[2][0]]\n OTHER['last_measurement'] = target_measurement\n else:\n print \"OTHER is:\", OTHER\n turning_angle = heading - OTHER['last_heading']\n print \"turning angle:\", turning_angle\n print \"turning angle actual:\", target.turning\n #last_heading = OTHER['last_heading']\n\n\n #do some guessing\n D = distance_between(target_measurement, last_measurement)\n print \"this is the D\"\n print D\n theta = (heading+turning_angle)%(2*pi)\n print \"theta:\", theta\n print \"theta - heading current:\", theta - target.heading\n\n #estimation step\n\n #is it \"last heading\" or \"theta\"????\n # X = matrix([[theta],\n # [X.value[1][0] + D * cos(theta)],\n # [X.value[2][0] + D * sin(theta)]])\n\n delta_x = D * cos(theta)\n delta_y = D * sin(theta)\n\n nextX = target_measurement[0] + delta_x\n nextY = target_measurement[1] + delta_y\n\n # nextX = X.value[1][0] + delta_x\n # nextY = X.value[2][0] + delta_y\n\n #print \"the distance to the next guessed point is:\", distance_between([nextX,nextY], measurement)\n\n X = matrix([[theta],\n [nextX],\n [nextY]])\n\n print \"I'm projecting X out to:\", X\n print \"Note, the current robot stats:\", target.heading, target.x, target.y\n\n F = matrix([[1, 0, 0],\n [-D*sin(theta), 1, 0],\n [D*cos(theta), 0, 1]])\n\n P = OTHER['P']\n #X = OTHER['X']\n\n\n H = matrix([[0, 1, 0],\n [0, 0, 1]])\n\n # #Prediction\n # X = (F * X) + u\n # P = F * P * F.transpose() # + Q\n\n P = F * P * F.transpose() # + Q\n\n #measurement update\n observations = matrix([[target_measurement[0]],\n [target_measurement[1]]]) #truth\n Z = H*X\n Y = observations - Z\n print \"this is Y\"\n print Y\n S = H * P * H.transpose() + R\n K = P * H.transpose() * S.inverse()\n X = X + (K*Y)\n\n P = (I - (K * H)) * P\n\n X.value[0][0] = angle_truncate(X.value[0][0])\n\n\n OTHER['X'] = X\n\n OTHER['P'] = P\n x_estimate = OTHER['X'].value[1][0]\n y_estimate = OTHER['X'].value[2][0]\n print \"Currently, the robot state is:\", target.heading, observations\n print \"This is what Kalman thinks X will be:\", OTHER['X']\n xy_estimate = [x_estimate, y_estimate]\n\n OTHER['last_heading'] = heading\n OTHER['last_measurement'] = target_measurement\n\n\n else:\n #x = theta, x, y\n X = matrix([[0.5],\n [2],\n [4]])\n #convariance matrix\n P = matrix([[1000, 0, 0],\n [0, 1000, 0],\n [0, 0, 1000]])\n OTHER = {'last_measurement': target_measurement, 'X': X, 'P': P, 'measurements': [target_measurement]}\n xy_estimate = [X.value[1][0], X.value[2][0]]\n\n # if not OTHER: # first time calling this function, set up my OTHER variables.\n # measurements = [target_measurement]\n # hunter_positions = [hunter_position]\n # hunter_headings = [hunter_heading]\n # OTHER = (measurements, hunter_positions, hunter_headings) # now I can keep track of history\n # else: # not the first time, update my history\n # OTHER[0].append(target_measurement)\n # OTHER[1].append(hunter_position)\n # OTHER[2].append(hunter_heading)\n # measurements, hunter_positions, hunter_headings = OTHER # now I can always refer to these variables\n\n #plugging in the Hunter to target the next anticipated area for the target\n\n if distance_between(hunter_position, xy_estimate) > max_distance: #if I can't get to the position in time\n # I want to go to a known point and keep going there.\n heading_to_target = get_heading(hunter_position, OTHER['measurements'][0]) #grab the first measurement\n heading_difference = heading_to_target - hunter_heading\n turning = heading_difference\n distance = max_distance # full speed ahead!\n print \"I'm moving to the point\"\n if distance_between(hunter_position, OTHER['measurements'][0]) <= max_distance/2:\n distance = 0 #stay put\n heading_to_target = get_heading(hunter_position, OTHER['measurements'][1]) #point at the next one\n heading_difference = heading_to_target - hunter_heading\n turning = heading_difference\n print \"I'm staying at the point in waiting\"\n else:\n heading_to_target = get_heading(hunter_position, xy_estimate)\n heading_difference = heading_to_target - hunter_heading\n turning = heading_difference # turn towards the target\n distance_to_point = distance_between(hunter_position, xy_estimate)\n distance = distance_to_point #I don't want to travel full speed LOL\n print \"ATTACK!\"\n\n return turning, distance, OTHER","def test_above_freezing_above(self):\n\n expected = True\n actual = temperature.above_freezing(5.2)\n self.assertEqual(expected, actual,\n \"The temperature is above freezing.\")","def testBearingWest(self):\n\n eps = 1.0e-12\n B = 270 # True bearing\n\n p1 = Point(0.0, 0.0)\n p3 = Point(0.0, 1.0)\n\n b = p3.bearing_to(p1)\n msg = 'Computed southward bearing %d. Expected %d' % (b, B)\n assert numpy.allclose(b, B, rtol=eps, atol=eps), msg","def test_depolarizing_error_2q_gate(self):\n p_depol = 0.3\n error = depolarizing_error(p_depol, 2, standard_gates=True)\n target_circs = [[{\"name\": \"id\", \"qubits\": [0]}],\n [{\"name\": \"x\", \"qubits\": [0]}],\n [{\"name\": \"y\", \"qubits\": [0]}],\n [{\"name\": \"z\", \"qubits\": [0]}],\n [{\"name\": \"x\", \"qubits\": [1]}],\n [{\"name\": \"y\", \"qubits\": [1]}],\n [{\"name\": \"z\", \"qubits\": [1]}],\n [{\"name\": \"x\", \"qubits\": [0]}, {\"name\": \"x\", \"qubits\": [1]}],\n [{\"name\": \"x\", \"qubits\": [0]}, {\"name\": \"y\", \"qubits\": [1]}],\n [{\"name\": \"x\", \"qubits\": [0]}, {\"name\": \"z\", \"qubits\": [1]}],\n [{\"name\": \"y\", \"qubits\": [0]}, {\"name\": \"x\", \"qubits\": [1]}],\n [{\"name\": \"y\", \"qubits\": [0]}, {\"name\": \"y\", \"qubits\": [1]}],\n [{\"name\": \"y\", \"qubits\": [0]}, {\"name\": \"z\", \"qubits\": [1]}],\n [{\"name\": \"z\", \"qubits\": [0]}, {\"name\": \"x\", \"qubits\": [1]}],\n [{\"name\": \"z\", \"qubits\": [0]}, {\"name\": \"y\", \"qubits\": [1]}],\n [{\"name\": \"z\", \"qubits\": [0]}, {\"name\": \"z\", \"qubits\": [1]}]]\n for j in range(16):\n circ, p = error.error_term(j)\n self.remove_if_found(circ, target_circs)\n if circ == [{\"name\": \"id\", \"qubits\": [0]}]:\n self.assertAlmostEqual(p, 1 - p_depol + p_depol / 16,\n msg=\"Incorrect identity probability\")\n else:\n self.assertAlmostEqual(p, p_depol / 16, msg=\"Incorrect Pauli probability\")\n self.assertEqual(target_circs, [], msg=\"Incorrect unitaries\")","def test_basic_newton_finder(self):\n forwards = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\n strikes = np.array([1.0, 2.0, 1.0, 0.5, 1.0, 1.0])\n expiries = np.array([1.0, 1.0, 1.0, 1.0, 0.5, 2.0])\n discounts = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\n init_vols = np.array([2.0, 0.5, 2.0, 0.5, 1.5, 1.5])\n option_signs = np.array([1.0, 1.0, -1.0, -1.0, 1.0, 1.0])\n volatilities = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\n prices = np.array([\n 0.38292492, 0.19061012, 0.38292492, 0.09530506, 0.27632639, 0.52049988\n ])\n results = implied_vol(\n forwards,\n strikes,\n expiries,\n discounts,\n prices,\n option_signs,\n initial_volatilities=init_vols,\n max_iterations=100)\n implied_vols, converged, failed = self.evaluate(results)\n num_volatilities = len(volatilities)\n self.assertAllEqual(np.ones(num_volatilities, dtype=np.bool), converged)\n self.assertAllEqual(np.zeros(num_volatilities, dtype=np.bool), failed)\n self.assertArrayNear(volatilities, implied_vols, 1e-7)","def test_EvaluatorWallHarmonic_force_device(make_state):\n state = make_state['state']\n springConstant = 5.0\n cutoff = 10.0\n harmonicWall = EvaluatorWallHarmonic(springConstant, cutoff)\n\n # distancesFromWall; make it so that a couple results not representable as an integer\n distancesFromWall = [1.57079632679, # pi/2\n 3.14159265359, # pi\n 5.0, # 5\n 6.28318530718, # 2 * pi\n 9.32737905309] # sqrt(87)\n\n # forceDirection must have a magnitude of 1.0;\n # -- in DASH, this is normalized on instantiation of FixWallHarmonic\n forceDirection = Vector(1.0, 0.0, 0.0)\n\n # put explicitly the form of the expected force\n def force(distanceFromWall, direction):\n if (distanceFromWall <= cutoff):\n return direction * springConstant * np.abs((cutoff - distanceFromWall))\n else:\n return Vector(0.0, 0.0, 0.0)\n\n\n # test for each value of distance from the wall\n tolerance = 1e-10\n\n for _, item in enumerate(distancesFromWall):\n calculatedForce = harmonicWall.force_device(item, forceDirection)\n expectedForce = force(item, forceDirection)\n formatCode = '{:<30s} {:>18.14f} {:>18.14f} {:>18.14f}'\n print(formatCode.format(\"calculatedForce: \", calculatedForce[0], calculatedForce[1], calculatedForce[2]))\n print(formatCode.format(\"expectedForce: \", expectedForce[0], expectedForce[1], expectedForce[2]))\n\n absoluteDifference = (calculatedForce - expectedForce).len()\n\n relativeError = absoluteDifference / (expectedForce.len())\n print(\"{:<30s} {:>18.14f}\\n\".format(\"percent error: \", relativeError * 100.0))\n\n assert(relativeError <= tolerance)","def test_calculate_circumsolar_shading():\n # Test for one value of 20% of the diameter being covered\n percentage_distance_covered = 20.\n percent_shading = calculate_circumsolar_shading(\n percentage_distance_covered, model='uniform_disk')\n\n # Compare to expected\n expected_disk_shading_perc = 14.2378489933\n atol = 0\n rtol = 1e-8\n np.testing.assert_allclose(expected_disk_shading_perc, percent_shading,\n atol=atol, rtol=rtol)","def check_heated_up(error):\n error = np.array(error)\n error = np.abs(error)\n if len(error) < 30 or sum(error[-30:-1]) > 15:\n return False\n else:\n return True","def test_pos_1024() -> None:\n assert sw.walk_to(1024).distance == 31","def test_scalar_dewpoint_from_relative_humidity():\n td = dewpoint_from_relative_humidity(10.6 * units.degC, 0.37)\n assert_almost_equal(td, 26. * units.degF, 0)","def test_moist_lapse_downwards():\n temp = moist_lapse(units.Quantity([600, 700], 'mbar'), units.Quantity(0, 'degC'))\n assert_almost_equal(temp, units.Quantity([0, 6.47748353], units.degC), 4)","def test_parity(float_tolerance, l):\n x = torch.randn(3)\n Y1 = (-1)**l * o3.spherical_harmonics(l, x, False)\n Y2 = o3.spherical_harmonics(l, -x, False)\n assert (Y1 - Y2).abs().max() < float_tolerance","def test_griewank(self):\n fun = get_problem('griewank', self.dimension)\n self.assertEqual(fun(self.array), 0.0)","def run(self):\n move_cmd = Twist()\n move_cmd.linear.x = 0\n move_cmd.angular.z = 0\n\n while not rospy.is_shutdown():\n # bump logic as previous psets\n if self.bump:\n self.bump = False\n # move backwards\n move_cmd.linear.x = LIN_SPEED * -1\n for i in range(5):\n self.cmd_vel.publish(move_cmd)\n self.rate.sleep()\n rospy.sleep(1)\n\n # turn randomly in a random direction\n move_cmd.linear.x = 0\n move_cmd.angular.z = ROT_SPEED * ((-1)**random.randint(1,2))\n\n if self.bump == 0:\n move_cmd.angular.z = ROT_SPEED * (-1)\n elif self.bump == 2:\n move_cmd.angular.z = ROT_SPEED\n\n for i in range(random.randint(5,15)):\n self.cmd_vel.publish(move_cmd)\n self.rate.sleep()\n rospy.sleep(1)\n\n move_cmd.angular.z = 0\n # if somethin in the screen is really close\n elif self.min_val < MIN_THRESHOLD:\n # make sure it's not the sock/leg warmer, and is actually an obstacle\n if self.obstacle_x <= self.x or self.obstacle_x >= self.x + self.w or abs(self.min_val - self.dist) > 0.1:\n move_cmd.linear.x = 0\n # turn away\n if self.obstacle_x > 320:\n move_cmd.angular.z = ROT_SPEED / 2\n else:\n move_cmd.angular.z = -ROT_SPEED / 2\n # self.min_val = 100\n for i in range(10):\n self.cmd_vel.publish(move_cmd)\n self.rate.sleep()\n self.last_move = rospy.Time.now()\n else:\n rospy.loginfo(\"Perimeter \" + str(self.perimeter_size))\n rospy.loginfo(\"Distance is \" + str(self.dist))\n\n # normalize angle error to rot speed\n ang_error_norm = -float(self.ang_error) / 100\n\n # set min and max rot speed\n if ang_error_norm < -ROT_SPEED:\n ang_error_norm = -ROT_SPEED\n elif ang_error_norm > ROT_SPEED:\n ang_error_norm = ROT_SPEED\n\n move_cmd.angular.z = ang_error_norm\n\n if RACE == False:\n # normalize dist error to lin speed\n self.dist_error = self.dist - 0.5\n dist_error_norm = float(self.dist_error) / 2\n\n if dist_error_norm < 0:\n # if NaN (self.dist gets set to -1)\n if dist_error_norm > -0.7:\n self.lost = 0\n # if too close\n else:\n self.lost += 1\n # if it's been more than 2 seconds\n if rospy.Time.now() > self.last_move + rospy.Duration(2):\n dist_error_norm = 0\n # if been lost for a while rotate and beep\n if self.lost > 20:\n move_cmd.angular.z = ROT_SPEED / 4\n self.beep.publish(4)\n else:\n # continue as previous\n dist_error_norm = self.last_speed\n else:\n # set max lin speed\n if dist_error_norm > LIN_SPEED:\n dist_error_norm = LIN_SPEED\n\n # reset lost stats\n self.lost = 0\n self.last_speed = dist_error_norm\n self.last_move = rospy.Time.now()\n\n move_cmd.linear.x = dist_error_norm\n else:\n move_cmd.linear.x = LIN_SPEED\n\n self.cmd_vel.publish(move_cmd)","def double_middle_drop(progress):\n eps1 = 0.75\n eps2 = 0.25\n if 1 - progress < eps1:\n if 1 - progress < eps2:\n return eps2 * 0.5\n return eps1 * 0.1\n return 1 - progress","def test_uneven_sw():\n B = 100\n t = 1\n H = 30\n E = 20000\n sections = ((2 * B, t, 0, E), (B, t, H - t, E))\n EI, top, bot = bm.EI(sections, E)\n assert 1.95 < abs(bot) / top < 1.96","def test_bs(self):\r\n res = BlackScholes(100, 0.10, 0.5, 1.00)\r\n self.assertEqual(round(res, 2), 23.93)","def test_newton_rhapson(testFunctions, tol, printFlag): \n pass","def test_tract_split_housing(self):\n # Validate first new tract from the split tract\n # Tract 35.01\n tract1 = self.geographies.find({ 'geoid': '15003003501' })\n self.assertEqual(tract1.count(), 1)\n tract1 = tract1[0]\n \n split_tract_house_2000 = 3370 \n tract1_house_pct = 0.383 \n tract1_house_2000 = int(tract1_house_pct * split_tract_house_2000)\n tract1_house_2010 = 1353 \n tract1_house_delta = tract1_house_2010 - tract1_house_2000\n tract1_house_pct_change = float(tract1_house_delta) / tract1_house_2000\n\n self.assertAlmostEqual(tract1['xwalk']['15003003500']['HUPCT00'], tract1_house_pct, places=4)\n self.assertAlmostEqual(tract1['data']['2000']['H1']['H001001'], tract1_house_2000)\n self.assertAlmostEqual(float(tract1['data']['2010']['H1']['H001001']), tract1_house_2010)\n self.assertAlmostEqual(float(tract1['data']['delta']['H1']['H001001']), tract1_house_delta)\n self.assertAlmostEqual(float(tract1['data']['pct_change']['H1']['H001001']), tract1_house_pct_change)\n\n # Validate second new part from the split tract\n # Tract 35.02\n tract2 = self.geographies.find({ 'geoid': '15003003502' })\n self.assertEqual(tract2.count(), 1)\n tract2 = tract2[0]\n\n tract2_house_pct = 0.617\n tract2_house_2000 = int(tract2_house_pct * split_tract_house_2000)\n tract2_house_2010 = 2180 \n tract2_house_delta = tract2_house_2010 - tract2_house_2000\n tract2_house_pct_change = float(tract2_house_delta) / tract2_house_2000 \n \n self.assertAlmostEqual(tract2['xwalk']['15003003500']['HUPCT00'], tract2_house_pct, places=4)\n self.assertAlmostEqual(tract2['data']['2000']['H1']['H001001'], tract2_house_2000)\n self.assertAlmostEqual(float(tract2['data']['2010']['H1']['H001001']), tract2_house_2010)\n self.assertAlmostEqual(float(tract2['data']['delta']['H1']['H001001']), tract2_house_delta)\n self.assertAlmostEqual(float(tract2['data']['pct_change']['H1']['H001001']), tract2_house_pct_change)","def toluene():\n coords = [\n [1.2264, 0.0427, 0.0670],\n [1.0031, -1.3293, 0.0600],\n [-0.2945, -1.8256, -0.0060],\n [-1.3704, -0.9461, -0.0646],\n [-1.1511, 0.4266, -0.0578],\n [0.1497, 0.9292, 0.0066],\n [0.3871, 2.3956, -0.0022],\n [2.2495, 0.4310, 0.1211],\n [1.8510, -2.0202, 0.1071],\n [-0.4688, -2.9062, -0.0109],\n [-2.3926, -1.3347, -0.1157],\n [-2.0006, 1.1172, -0.1021],\n [0.5024, 2.7582, -1.0330],\n [1.2994, 2.6647, 0.5466],\n [-0.4475, 2.9470, 0.4506],\n ]\n coords = [[float(j) / Bohr for j in i] for i in coords]\n\n symbols = [\n \"C\",\n \"C\",\n \"C\",\n \"C\",\n \"C\",\n \"C\",\n \"C\",\n \"H\",\n \"H\",\n \"H\",\n \"H\",\n \"H\",\n \"H\",\n \"H\",\n \"H\",\n ]\n\n atoms = []\n for i, _ in enumerate(coords):\n atoms.append(Atom(symbols[i], position=coords[i]))\n return Molecule(symbols=atoms)","def brents(f, x0, x1, max_iter=50, tolerance=1e-5):\n \n fx0 = f(x0)\n fx1 = f(x1)\n \n assert (fx0 * fx1) <= 0, \"Root not bracketed\" \n \n if abs(fx0) < abs(fx1):\n x0, x1 = x1, x0\n fx0, fx1 = fx1, fx0\n \n x2, fx2 = x0, fx0\n \n d = np.nan\n mflag = True\n steps_taken = 0\n \n while steps_taken < max_iter and abs(x1-x0) > tolerance:\n fx0 = f(x0)\n fx1 = f(x1)\n fx2 = f(x2)\n \n if fx0 != fx2 and fx1 != fx2:\n L0 = (x0 * fx1 * fx2) / ((fx0 - fx1) * (fx0 - fx2))\n L1 = (x1 * fx0 * fx2) / ((fx1 - fx0) * (fx1 - fx2))\n L2 = (x2 * fx1 * fx0) / ((fx2 - fx0) * (fx2 - fx1))\n new = L0 + L1 + L2\n \n else:\n new = x1 - ( (fx1 * (x1 - x0)) / (fx1 - fx0) )\n \n tt1 = (new < ((3 * x0 + x1) / 4) or new > x1)\n tt2 = (mflag == True and (abs(new - x1)) >= (abs(x1 - x2) / 2))\n tt3 = (mflag == False and (abs(new - x1)) >= (abs(x2 - d) / 2))\n tt4 = (mflag == True and (abs(x1 - x2)) < tolerance)\n tt5 = (mflag == False and (abs(x2 - d)) < tolerance)\n if (tt1 or\n tt2 or\n tt3 or\n tt4 or\n tt5):\n new = (x0 + x1) / 2\n mflag = True\n \n else:\n mflag = False\n \n fnew = f(new)\n d, x2 = x2, x1\n \n if (fx0 * fnew) < 0:\n x1 = new\n else:\n x0 = new\n \n if abs(fx0) < abs(fx1):\n x0, x1 = x1, x0\n \n steps_taken += 1\n \n return x1, steps_taken","def test_fix_fingers_w_thresh(self):\n\t\tdetails = self.watcher.analyze(layers=[17], fix_fingers='clip_xmax', finger_thresh=10.0)\n\t\tactual_alpha = details.alpha.to_numpy()[0]\n\t\tactual_raw_alpha = details.raw_alpha.to_numpy()[0]\n\t\tactual_num_fingers = details.num_fingers.to_numpy()[0]\n\n\t\texpected_alpha = 6.883742\n\t\texpected_raw_alpha = expected_alpha\n\t\texpected_num_fingers = 0\n\t\tself.assertAlmostEqual(actual_alpha,expected_alpha, delta=0.1 )\n\t\tself.assertAlmostEqual(actual_raw_alpha,expected_raw_alpha, delta=0.01 )\n\t\tself.assertEqual(actual_num_fingers,expected_num_fingers)","def test_GBL_tau_star():\n z = 1.0\n\n # Fully ionized H and He\n x_ionH = 1.0\n x_ionHe = 2.0\n\n cosmo = {}\n cosmo['omega_M_0'] = numpy.array([[0.3],[0.6],[1.0]])\n cosmo['omega_lambda_0'] = 1. - cosmo['omega_M_0']\n cosmo['h'] = 0.65\n cosmo['omega_b_0'] = 0.02 / cosmo['h']**2.\n cosmo['Y_He'] = 0.24\n cd.set_omega_k_0(cosmo)\n\n tau_inst, tau_star = cr.optical_depth_instant(z, \n x_ionH=x_ionH, \n x_ionHe=x_ionHe, \n return_tau_star=True,\n **cosmo)\n print(\"tau_star = %.7f\" % (tau_star))\n print(\"tau_star/(h Omega_b) = %.7f =? 0.061\" % \n (tau_star / (cosmo['h'] * cosmo['omega_b_0'])))\n\n ntest.assert_approx_equal(tau_star / (cosmo['h'] * cosmo['omega_b_0']),\n 0.061,\n 2)\n\n print(\"(1 - Y_He/2) = %.3f =? 0.88\" % (1. - (cosmo['Y_He']/2.)))\n ntest.assert_approx_equal((1. - (cosmo['Y_He']/2.)),\n 0.88,\n 7)\n\n H_0 = cc.H100_s * cosmo['h']\n\n # s^-1 * Mpc s^-1 * Mpc^2 / Mpc^3 msun^-1 s^-2 / Msun -> \n tau_star_explicit = ((1. - (cosmo['Y_He']/2.)) * \n ((3. * H_0 * cosmo['omega_b_0'] * cc.c_light_Mpc_s *\n cc.sigma_T_Mpc) / \n (8. * math.pi * cc.G_const_Mpc_Msun_s * \n (cc.m_p_g/cc.M_sun_g))))\n\n print(\"tau_star_explicit = %.7f =? tau_star\" % (tau_star_explicit))\n ntest.assert_approx_equal(tau_star, tau_star_explicit, 3)","def test_positive_definite2(dist, alpha, divergence):\n assert divergence(dist, dist, alpha, rvs=[0, 1]) == pytest.approx(0)\n assert hellinger_sum(dist, dist, alpha, rvs=[0, 1]) == pytest.approx(1)","def close(a,b):\n return abs(a-b) < epsilon","def test_moist_lapse_nan_ref_press():\n temp = moist_lapse(40 * units.hPa, -20 * units.degC, np.nan * units.hPa)\n assert_nan(temp, units.degC)","def Catch(X,Tolerance=0):\n if X < (.5-(Tolerance/2)):\n return(0)\n elif X > (.5+(Tolerance/2)):\n return(1)\n else:\n return(.5)","def heron(num: int):\n try:\n if num < 0:\n raise ZeroDivisionError\n else:\n guess = num\n tolerance = 0.00001\n while abs(guess * guess - num) > tolerance: # continue finding a more accurate guess if the guess is not\n # close enough to the true root, as defined by the tolerance\n guess = (guess + num / guess) / 2 # this formula is a step towards finding the square root of a number\n return float(round(guess, 2))\n except ZeroDivisionError:\n print(\"You have entered a negative integer, that is not valid.\")\n return -1","def epsilon_delta(self):"],"string":"[\n \"def test_W_end(self):\\t\\t\\n self.assertAlmostEqual(attempt.W[-1], 9.494852380803035)\",\n \"def steadyYet(newg, oldg, newe, olde, newh, oldh, newf, oldf, tolerance):\\n steady_yet = True\\n if oldg == 0 or (abs(newg-oldg)/oldg > tolerance or\\n abs(newe-olde)/olde > tolerance or\\n abs(newh-oldh)/oldh > tolerance or\\n abs(newf-oldf)/oldf > tolerance):\\n steady_yet = False\\n return steady_yet\",\n \"def test_Z_start(self):\\t\\t\\n self.assertAlmostEqual(attempt.Z[0], 40)\",\n \"def explicit_half_kick(self):\\n rejected = False\\n momentum = self.momentum.clone()\\n old_momentum = momentum.clone()\\n hamiltonian = self.get_hamiltonian()\\n d_hamiltonian = torch.autograd.grad(hamiltonian, self.parameters, retain_graph=False)[0]\\n momentum -= 0.5 * self.stepsize * d_hamiltonian\\n if self._is_nanned(self.momentum):\\n rejected = True\\n self.momentum = old_momentum\\n# if self.verbose:\\n print('Nanned during explit momentum update {}'.format(iter))\\n return momentum, rejected\",\n \"def test_full_chelyabinsk(self, tolerance=0.1):\\n conditions = [8.5, 19.2e3, 3300, 4e6, 18.3*np.pi/180]\\n system = asteroid(*conditions)\\n system.solve_ode()\\n peak = [system.burst['height (km)'], system.burst['ke Lost (kt/km)']]\\n peak = np.array(peak)\\n\\n obs_peak = np.array([29.5578, 81.505])\\n diff = abs(peak - obs_peak)\\n assert np.all(diff < obs_peak * tolerance), \\\\\\n \\\"chelyabinsk simulation does not match imperical data\\\"\",\n \"def _hill_diff(self, position):\\n if position < 0:\\n return 2 * position + 1\\n else:\\n return (1/math.sqrt(1 + 5 * position ** 2)\\n - 5 * position ** 2 * (1 + 5 * position ** 2)**-1.5)\",\n \"def test_phantom_roll(self):\\n self.assertAlmostEqual(self.cheese.catphan_roll, self.expected_roll, delta=0.3)\",\n \"def test_t(self):\\n assert np.isclose(self.stepper.t, self.final_t)\",\n \"def test_EvaluatorWallHarmonic_energy(make_state):\\n state = make_state['state']\\n springConstant = 5.0\\n cutoff = 10.0\\n harmonicWall = EvaluatorWallHarmonic(springConstant, cutoff)\\n\\n distancesFromWall = [1.57079632679, # pi/2\\n 3.14159265359, # pi\\n 5.0, # 5\\n 6.28318530718, # 2 * pi\\n 9.32737905309] # sqrt(87)\\n\\n def energy(distanceFromWall):\\n if (distanceFromWall < cutoff):\\n return 0.5 * springConstant * ((cutoff - distanceFromWall) ** 2.0)\\n else:\\n return 0.0\\n\\n # test for each value of distance from the wall\\n tolerance = 1e-10\\n\\n for _, item in enumerate(distancesFromWall):\\n calculatedEnergy = harmonicWall.energy(item)\\n expectedEnergy = energy(item)\\n formatCode = \\\"{:<30s} {:>18.14f}\\\"\\n print(formatCode.format(\\\"calculatedEnergy: \\\", calculatedEnergy))\\n print(formatCode.format(\\\"expectedEnergy: \\\", expectedEnergy))\\n\\n absoluteDifference = np.abs(calculatedEnergy - expectedEnergy)\\n\\n relativeError = absoluteDifference / (np.abs(expectedEnergy))\\n print((formatCode+\\\"\\\\n\\\").format(\\\"percentError: \\\", relativeError * 100.0))\\n\\n assert(relativeError <= tolerance)\",\n \"def test_single_caps(self):\\n result_h = mmc.find_molar_mass('H')\\n actual_h = 1.007940\\n self.assertTrue(abs(percent_error(result_h, actual_h)) < self.ERR_THRESHOLD)\",\n \"def _hill_diff_diff(self, position):\\n if position < 0:\\n return 2\\n else:\\n return position * ((75 * (position ** 2)/((1 + 5 * position**2)**2.5)) - 5/((1 + 5 * position ** 2)**2.5)) \\\\\\n - 10 * position/((1 + 5 * position ** 2)**1.5)\",\n \"def test_W_start(self):\\t\\t\\n self.assertAlmostEqual(attempt.W[0], 12)\",\n \"def test_AKs_correct_preflop_odds(self):\\n self.assertEqual(self.hand.preFlopOdds10, 20.7)\",\n \"def test_lorentz_broadening():\\n v0 = 100\\n I = 10\\n w = 1.0\\n\\n assert lorentz(v0, v0, I, w) == approx(5)\",\n \"def calc_tolerance(wt):\\n return 1 - wt\",\n \"def implicit_half_kick(self):\\n stored_momentum = self.momentum.clone()\\n rejected = False\\n best_diff = torch.tensor(100.)\\n for iter in range(self._max_fixed_point_iterations):\\n old_momentum = self.momentum.clone()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n hamiltonian = self.get_hamiltonian()\\n d_hamiltonian = torch.autograd.grad(hamiltonian,self.parameters,retain_graph = True)[0]\\n self.momentum = stored_momentum - 0.5 * self.stepsize * d_hamiltonian\\n if self._is_nanned(self.momentum):\\n rejected = True\\n self.momentum = old_momentum\\n if self.verbose:\\n print('Nanned during momentum update {}'.format(iter))\\n break\\n diff = torch.max((old_momentum - self.momentum) ** 2)\\n if diff < self._fixed_point_threshold:\\n break\\n if diff<best_diff:\\n best_diff = diff\\n elif iter == self._max_fixed_point_iterations-1:\\n rejected = True\\n if self.verbose:\\n print('Exceeded maximum iterations during momentum update')\\n break\\n# print('Warning: reached {} iterations in momentum update. Smallest iteration ({}) was selected'.format(self._max_fixed_point_iterations, best_diff.item()))\\n momentum = self.momentum\\n return momentum, rejected\",\n \"def nearest_test_pulse(self):\",\n \"def test_weierstrass(self):\\n fun = get_problem('weierstrass', self.dimension, -100, 100)\\n self.assertAlmostEqual(fun(self.array10), 0.0, delta=1e-4)\",\n \"def test_schaffer_n4(self):\\n fun = get_problem('schaffer4', lower=-100, upper=100)\\n self.assertAlmostEqual(fun(self.array10[:2]), 0.97545, delta=1e-4)\",\n \"def testMatchSwarpNearestExposure(self):\\n self.compareToSwarp(\\\"nearest\\\", useWarpExposure=True, atol=60)\",\n \"def test_EvaluatorWallHarmonic_force(make_state):\\n state = make_state['state']\\n springConstant = 5.0\\n cutoff = 10.0\\n harmonicWall = EvaluatorWallHarmonic(springConstant, cutoff)\\n\\n # distancesFromWall; make it so that a couple results not representable as an integer\\n distancesFromWall = [1.57079632679, # pi/2\\n 3.14159265359, # pi\\n 5.0, # 5\\n 6.28318530718, # 2 * pi\\n 9.32737905309] # sqrt(87)\\n\\n # forceDirection must have a magnitude of 1.0;\\n # -- in DASH, this is normalized on instantiation of FixWallHarmonic\\n forceDirection = Vector(1.0, 0.0, 0.0)\\n\\n # put explicitly the form of the expected force\\n def force(distanceFromWall, direction):\\n if (distanceFromWall <= cutoff):\\n return direction * springConstant * np.abs((cutoff - distanceFromWall))\\n else:\\n return Vector(0.0, 0.0, 0.0)\\n\\n\\n # test for each value of distance from the wall\\n tolerance = 1e-10\\n\\n for _, item in enumerate(distancesFromWall):\\n calculatedForce = harmonicWall.force(item, forceDirection)\\n expectedForce = force(item, forceDirection)\\n formatCode = '{:<30s} {:>18.14f} {:>18.14f} {:>18.14f}'\\n print(formatCode.format(\\\"calculatedForce: \\\", calculatedForce[0], calculatedForce[1], calculatedForce[2]))\\n print(formatCode.format(\\\"expectedForce: \\\", expectedForce[0], expectedForce[1], expectedForce[2]))\\n\\n absoluteDifference = (calculatedForce - expectedForce).len()\\n\\n relativeError = absoluteDifference / (expectedForce.len())\\n print(\\\"{:<30s} {:>18.14f}\\\\n\\\".format(\\\"percent error: \\\", relativeError * 100.0))\\n\\n assert(relativeError <= tolerance)\",\n \"def testHeuristic(self):\\n result = Sigmoid.heuristic(self, 12)\\n self.assertEqual(0.28867513459481287, result)\",\n \"def test_expanded_griewank_plus_rosenbrock(self):\\n fun = get_problem('expanded_griewank_plus_rosenbrock', self.dimension, -100, 100)\\n self.assertAlmostEqual(fun(self.array), 2.2997, delta=1e2)\",\n \"def test_nearest_boundary_odd():\\n assert _nearest_boundary(10, 19, 14, 0) == 0\\n assert _nearest_boundary(10, 19, 14, 1) == 1\",\n \"def constant_r_success(r_target, tol):\\n def isdone(node_dict):\\n \\\"\\\"\\\"return a delta heading value to best turn to heading\\\"\\\"\\\"\\n # compute heading difference\\n hdiff = heading_diff(r_target, node_dict['pn'].heading)\\n # return if we are we close enough\\n return abs(hdiff) < abs(tol)\\n\\n # return the function we just created\\n return isdone\",\n \"def test_ackley(self):\\n fun = get_problem('ackley', self.dimension)\\n self.assertAlmostEqual(fun(self.array), 0.0, places=10)\",\n \"def test_hgbat(self):\\n fun = get_problem('hgbat', self.dimension, -100, 100)\\n self.assertAlmostEqual(fun(self.array10), 61.91502622129181, delta=60)\",\n \"def test_highway_ramps(self):\\n # import the experiment variable from the example\\n exp = highway_ramps_example(render=False)\\n\\n # run the experiment for a few time steps to ensure it doesn't fail\\n exp.run(1, 5)\",\n \"def test_99_correct_preflop_odds(self):\\n self.assertEqual(self.hand.preFlopOdds10, 15.6)\",\n \"def wait(self):\\n self.set_vals(spin=.2)\\n nearest_deg = 0\\n nearest_deg_dist = self.perim_dist + 1\\n for i, x in enumerate(self.ranges):\\n if (x != 0) and (x < nearest_deg_dist):\\n nearest_deg = i\\n nearest_deg_dist = x\\n if nearest_deg_dist < self.perim_dist:\\n nearest_deg = ((nearest_deg + 180) % 360) - 180\\n self.center(degree=nearest_deg)\\n self.current_state = \\\"follow\\\"\",\n \"def test_ForwardEuler_against_hand_calculations():\\n def f(u, t):\\n return u\\n u, t = ForwardEuler(f, U0=1, T=0.2, n=2)\\n exact = np.array([1, 1.1, 1.21]) # hand calculations\\n error = np.abs(exact - u).max()\\n success = error < 1E-14\\n assert success, '|exact - u| = %g != 0' % error\",\n \"def hanging_man(self):\\n self.data['hanging_man'] = (((self.data['High'] - self.data['Low']) > ((self.data['Open'] - self.data['Close'])*4)) & \\\\\\n ((self.data['Close'] - self.data['Low']) / ((.001 + self.data['High'] - self.data['Low']) >= 0.75)) &\\\\\\n ((self.data['Open'] - self.data['Low']) / ((.001 + self.data['High'] - self.data['Low']) >= .075)))\",\n \"def test_ridge(self):\\n fun = get_problem('ridge', dimension=self.dimension, lower=-64, upper=64)\\n self.assertAlmostEqual(fun(self.array10), 371.0, delta=1e-4)\",\n \"def test_comp_angle_wind_eq(self, test_dict):\\n test_obj = test_dict[\\\"test_obj\\\"]\\n result = test_obj.slot.comp_angle_wind_eq()\\n\\n a = result\\n b = test_dict[\\\"Aw\\\"]\\n msg = \\\"Return \\\" + str(a) + \\\" expected \\\" + str(b)\\n self.assertAlmostEqual((a - b) / a, 0, delta=DELTA, msg=msg)\",\n \"def test_57o_correct_preflop_odds(self):\\n self.assertEqual(self.hand.preFlopOdds10, 7.9)\",\n \"def heuristic_3_correction(h: float, root_h: float):\\n # resultant =\\n resultant = 1 - ((h / root_h) if h < root_h else 0)\\n logger.debug(f'Corrected heuristic value 3: {resultant}')\\n return resultant\",\n \"def test_percent_dewpoint_from_relative_humidity():\\n td = dewpoint_from_relative_humidity(10.6 * units.degC, 37 * units.percent)\\n assert_almost_equal(td, 26. * units.degF, 0)\",\n \"def _wait_for_pole_at_rest(self, thold_ang_vel: float = 0.1 / 180.0 * np.pi):\\n cnt = 0\\n while cnt < 1.5 / self._dt:\\n # Get next measurement\\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\\n\\n if np.abs(meas[2]) < thold_ang_vel and np.abs(meas[3]) < thold_ang_vel:\\n cnt += 1\\n else:\\n cnt = 0\",\n \"def test_EvaluatorWallHarmonic_energy_device(make_state):\\n state = make_state['state']\\n springConstant = 5.0\\n cutoff = 10.0\\n harmonicWall = EvaluatorWallHarmonic(springConstant, cutoff)\\n\\n distancesFromWall = [1.57079632679, # pi/2\\n 3.14159265359, # pi\\n 5.0, # 5\\n 6.28318530718, # 2 * pi\\n 9.32737905309] # sqrt(87)\\n\\n def energy(distanceFromWall):\\n if (distanceFromWall < cutoff):\\n return 0.5 * springConstant * ((cutoff - distanceFromWall) ** 2.0)\\n else:\\n return 0.0\\n\\n # test for each value of distance from the wall\\n tolerance = 1e-10\\n\\n for _, item in enumerate(distancesFromWall):\\n calculatedEnergy = harmonicWall.energy_device(item)\\n expectedEnergy = energy(item)\\n formatCode = \\\"{:<30s} {:>18.14f}\\\"\\n print(formatCode.format(\\\"calculatedEnergy: \\\", calculatedEnergy))\\n print(formatCode.format(\\\"expectedEnergy: \\\", expectedEnergy))\\n\\n absoluteDifference = np.abs(calculatedEnergy - expectedEnergy)\\n\\n relativeError = absoluteDifference / (np.abs(expectedEnergy))\\n print((formatCode+\\\"\\\\n\\\").format(\\\"percentError: \\\", relativeError * 100.0))\\n\\n assert(relativeError <= tolerance)\",\n \"def test_modified_schwefel(self):\\n fun = get_problem('modified_schwefel', self.dimension, -100, 100)\\n self.assertAlmostEqual(fun(self.array10), 6.9448853328785844, delta=350)\",\n \"def test_comp_surface_wind(self, test_dict):\\n test_obj = test_dict[\\\"test_obj\\\"]\\n result = test_obj.slot.comp_surface_wind()\\n\\n a = result\\n b = test_dict[\\\"SW_exp\\\"]\\n msg = \\\"Return \\\" + str(a) + \\\" expected \\\" + str(b)\\n self.assertAlmostEqual((a - b) / a, 0, delta=DELTA, msg=msg)\",\n \"def test_G_H(self):\\r\\n chkmtx = (numpy.dot(golay.DEFAULT_G, golay.DEFAULT_H.T) % 2)\\r\\n self.assertTrue((chkmtx == 0).all())\",\n \"def minimum_spanning_arborescence(sol):\",\n \"def test_c(self):\\n self.failIf(cgs.speed_of_light/mks.speed_of_light!=100)\",\n \"def test_isentropic_pressure_p_increase_rh_out():\\n lev = [85000., 90000., 95000., 100000.] * units.Pa\\n tmp = np.ones((4, 5, 5))\\n tmp[0, :] = 288.\\n tmp[1, :] = 290.\\n tmp[2, :] = 292.\\n tmp[3, :] = 296.\\n tmpk = tmp * units.kelvin\\n rh = np.ones((4, 5, 5))\\n rh[0, :] = 20.\\n rh[1, :] = 40.\\n rh[2, :] = 80.\\n rh[3, :] = 100.\\n relh = rh * units.percent\\n isentlev = 296. * units.kelvin\\n isentprs = isentropic_interpolation(isentlev, lev, tmpk, relh)\\n truerh = 100. * units.percent\\n assert_almost_equal(isentprs[1], truerh, 3)\",\n \"def test_far_and_near(module_class: mantrap.modules.base.OptimizationModule.__class__,\\n env_class: mantrap.environment.base.GraphBasedEnvironment.__class__):\\n env = env_class(torch.tensor([-5, 100.0]), ego_type=mantrap.agents.IntegratorDTAgent, y_axis=(-100, 100))\\n env.add_ado(position=torch.zeros(2))\\n\\n start_near, end_near = torch.tensor([-5, 0.1]), torch.tensor([5, 0.1])\\n ego_path_near = mantrap.utility.maths.straight_line(start=start_near, end=end_near, steps=11)\\n ego_trajectory_near = env.ego.expand_trajectory(ego_path_near, dt=env.dt)\\n\\n start_far, end_far = torch.tensor([-5, 100.0]), torch.tensor([5, 10.0])\\n ego_path_far = mantrap.utility.maths.straight_line(start=start_far, end=end_far, steps=11)\\n ego_trajectory_far = env.ego.expand_trajectory(ego_path_far, dt=env.dt)\\n\\n module = module_class(t_horizon=10, env=env)\\n objective_near = module.objective(ego_trajectory_near, ado_ids=[], tag=\\\"test\\\")\\n objective_far = module.objective(ego_trajectory_far, ado_ids=[], tag=\\\"test\\\")\\n assert objective_near >= objective_far\",\n \"def _ftolCheck(self):\\n oldLoss = biggestRecentLoss(self.loss, self.lookback)\\n newLoss = float(self.loss[-1])\\n fracDiff = 2 * (oldLoss - newLoss)/(oldLoss + newLoss)\\n \\n if fracDiff < self.ftol:\\n \\n self.converged = True\",\n \"def test_sense_distance(self):\\n\\n\\t\\tmeasurements = [29, 29, 28]\\n\\t\\tself.driver.us_dist.side_effect = lambda x: measurements.pop()\\n\\t\\texpected_measurement = int(ultrasonic_sensor_error(29))\\n\\n\\t\\tself.assertEqual(self.s.sense_distance(60), expected_measurement)\\n\\t\\tself.mount.move.assert_called_once_with(x=60)\",\n \"def test_benjamini_hochberg_step_down(self):\\r\\n # r values\\r\\n # q = c(0.64771481, 0.93517796, 0.7169902 , 0.18223457, 0.26918556,\\r\\n # 0.1450153 , 0.22448242, 0.74723508, 0.89061034, 0.74007906)\\r\\n # p.adjust(q, method='BH')\\r\\n # [1] 0.9340439 0.9351780 0.9340439 0.6729639 0.6729639 0.6729639 0.6729639\\r\\n # [8] 0.9340439 0.9351780 0.9340439\\r\\n pvals = array([0.64771481, 0.93517796, 0.7169902, 0.18223457,\\r\\n 0.26918556, 0.1450153, 0.22448242, 0.74723508, 0.89061034,\\r\\n 0.74007906])\\r\\n exp = array([0.9340439, 0.9351780, 0.9340439, 0.6729639, 0.6729639,\\r\\n 0.6729639, 0.6729639, 0.9340439, 0.9351780, 0.9340439])\\r\\n obs = benjamini_hochberg_step_down(pvals)\\r\\n self.assertFloatEqual(obs, exp)\\r\\n # example 2\\r\\n pvals = array([1.32305426, 1.9345059, 0.87129877, 1.89957702,\\r\\n 1.85712616, 0.68757988, 0.41248969, 0.20751712, 1.97658599,\\r\\n 1.06209437])\\r\\n exp = array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])\\r\\n obs = benjamini_hochberg_step_down(pvals)\\r\\n self.assertFloatEqual(obs, exp)\",\n \"def test_michalewicz(self):\\n fun = get_problem('michalewicz', dimension=2, lower=0, upper=np.pi)\\n self.assertAlmostEqual(fun(np.asarray([2.20, 1.57])), -1.8013, delta=1e-3)\",\n \"def test_williams_correction(self):\\r\\n n = 100\\r\\n a = 10\\r\\n G = 10.5783\\r\\n exp = 10.387855973813421\\r\\n self.assertFloatEqual(williams_correction(n, a, G), exp)\\r\\n # test with an example from Sokal and Rohlf pg 699\\r\\n n = 241\\r\\n a = 8\\r\\n G = 8.82396\\r\\n exp = 8.76938\\r\\n self.assertFloatEqual(williams_correction(n, a, G), exp)\",\n \"def step():\\n x_rand = sample()\\n x_nearest = new_nearest_neighbour(x_rand)\\n x_new = steer(x_nearest, x_rand)\\n if obstacle_free(x_nearest, x_new):\\n X_near = new_neighbourhood(x_new)\\n x_min = x_nearest\\n c_min = x_nearest.cost + x_nearest.dist_to(x_new)\\n for x_near in X_near:\\n if obstacle_free(x_near, x_new) and (x_near.cost + x_near.dist_to(x_new) < c_min):\\n x_min = x_near\\n c_min = (x_near.cost + x_near.dist_to(x_new) < c_min)\\n x_new_node = add_node(x_new, x_min, True)\\n for x_near in X_near:\\n if obstacle_free(x_near, x_new) and (x_new_node.cost + x_near.dist_to(x_new) < x_near.cost):\\n x_near.change_parent(x_new_node)\\n # Here I check for goal paths and draw the circle\\n updated = False\\n if shared.root_path:\\n updated = goal_path_resolve(shared.root_path[0])\\n updated = updated or goal_path_resolve(shared.nodes[-1])\\n if updated:\\n diameter = shared.root_path_length\\n center = ((shared.root_path[0].x + shared.root_path[-1].x) / 2,\\n (shared.root_path[0].y + shared.root_path[-1].y) / 2)\\n if shared.region:\\n shared.region.remove_from_batch()\\n shared.region = ellipse.Ellipse(center[0], center[1], diameter)\\n shared.region.add_to_batch()\",\n \"def checkRing(self, verbose = 0):\\n angleSum = self.tfs.ANGLE.sum()\\n if self.verbose: print (\\\"check\\\")\\n print (\\\"---------------------------------- \\\\n Checking, if ring is closed: \\\\n\\\", \\\"angleSum = \\\", angleSum)\\n twoPi = 2*pi\\n \\n if angleSum != twoPi:\\n fudge = 2*pi - angleSum\\n print (\\\" ** Ring not closed - offset of: \\\", fudge)\",\n \"def testgradsorientation(self):\\r\\n # since z-coordinates of atomcoords are all 0 for dvb, z-values of grads should be all 0\\r\\n assert numpy.alltrue(numpy.abs(self.data.grads[:,:,2]) < 1e-14)\",\n \"def testCorrectForTwoAtomCellWithoutPeriodicityNEEDED(self):\\n\\t\\texpDist = 0.01*10\\n\\t\\tself._checkExpMatchesActual(expDist)\",\n \"def u_turn(self, direction, diameter_in):\\n \\n# pdb.set_trace()\\n # Calculate radius of turn for the inside wheel.\\n r_in = diameter_in / 2\\n\\n # Outside radius is 20 inches from inside radius.\\n r_out = r_in + MuleBot.WHEEL_BASE_LENGTH\\n \\n # Outside travel distance\\n travel = r_out * 3.14159\\n travel_revolutions = travel / MuleBot.CIRCUM_IN\\n \\n r_ratio = r_out / r_in\\n #r_ratio_half = r_ratio / 2\\n\\n speed_multiplier = MuleBot.MAX_RPM / r_ratio\\n\\n outside_rpm = r_ratio * speed_multiplier\\n inside_rpm = speed_multiplier\\n \\n \\n # \\n # minutes at outside_rpm\\n minutes = travel_revolutions / outside_rpm\\n seconds = minutes * MuleBot.SECONDS_PER_MINUTE\\n \\n # Something isn't quite perfect.\\n if direction == 'left':\\n if diameter_in < 25:\\n seconds -= 1\\n else:\\n seconds -= 2\\n else:\\n if diameter_in < 25:\\n seconds += 1\\n else:\\n seconds += 2\\n\\n if direction == 'left':\\n v_l = self.rpm_to_rps(inside_rpm)\\n v_r = self.rpm_to_rps(outside_rpm)\\n else:\\n v_r = self.rpm_to_rps(inside_rpm)\\n v_l = self.rpm_to_rps(outside_rpm)\\n\\n #print(\\\"2inside: rpm: \\\", inside_rpm)\\n #print(\\\"2outside: rpm: \\\", outside_rpm)\\n \\n #print(\\\"2.1: v_l: \\\", v_l)\\n #print(\\\"2.1: v_r: \\\", v_r)\\n\\n # Set wheel drive rates.\\n self.set_wheel_drive_rates(v_l, v_r)\\n\\n # Sleep during the turn.\\n time.sleep(seconds)\\n\\n # Stop\\n self.stop()\\n \\n # Move forward 24 inches.\\n self.forward(24)\",\n \"def testSpeciesRichnessNear(self):\\n self.assertAlmostEqual(1.0, self.tree1.get_number_individuals() / self.tree2.get_number_individuals(), 0)\",\n \"def check_offset(self):\\n\\n for d in range(self.n_dmps):\\n if abs(self.y0[d] - self.goal[d]) < 1e-4:\\n self.goal[d] += 1e-4\",\n \"def test_newton_rhapson_system(testFunctions, tol, printFlag): \\n pass\",\n \"def test_hermitian_expectation(self, device, tol):\\n n_wires = 2\\n dev = device(n_wires)\\n dev_def = qml.device(\\\"default.qubit\\\", wires=n_wires)\\n\\n if dev.shots is not None:\\n pytest.skip(\\\"Device is in non-analytical mode.\\\")\\n\\n if \\\"Hermitian\\\" not in dev.observables:\\n pytest.skip(\\\"Device does not support the Hermitian observable.\\\")\\n\\n if dev.name == dev_def.name:\\n pytest.skip(\\\"Device is default.qubit.\\\")\\n\\n theta = 0.432\\n phi = 0.123\\n A_ = np.array(\\n [\\n [-6, 2 + 1j, -3, -5 + 2j],\\n [2 - 1j, 0, 2 - 1j, -5 + 4j],\\n [-3, 2 + 1j, 0, -4 + 3j],\\n [-5 - 2j, -5 - 4j, -4 - 3j, -6],\\n ]\\n )\\n A_.requires_grad = False\\n\\n def circuit(theta, phi):\\n qml.RX(theta, wires=[0])\\n qml.RX(phi, wires=[1])\\n qml.CNOT(wires=[0, 1])\\n return qml.expval(qml.Hermitian(A_, wires=[0, 1]))\\n\\n qnode_def = qml.QNode(circuit, dev_def)\\n qnode = qml.QNode(circuit, dev)\\n\\n grad_def = qml.grad(qnode_def, argnum=[0, 1])\\n grad = qml.grad(qnode, argnum=[0, 1])\\n\\n assert np.allclose(qnode(theta, phi), qnode_def(theta, phi), atol=tol(dev.shots))\\n assert np.allclose(grad(theta, phi), grad_def(theta, phi), atol=tol(dev.shots))\",\n \"def test_jaro_winkler():\\n assert textdistance.jaro_winkler(\\\"campell\\\", \\\"campbell\\\") == pytest.approx(0.9792, abs=0.01)\\n assert textdistance.jaro_winkler(\\\"shakelford\\\", \\\"shakleford\\\") == pytest.approx(0.9848, abs=0.01)\\n assert textdistance.jaro_winkler(\\\"dwayne\\\", \\\"duane\\\") == pytest.approx(0.84, abs=0.01)\",\n \"def _check_redshift(self, red):\\n if np.min(np.abs(red - self.zout)) > 0.01:\\n return 0\\n return 1\",\n \"def test_fill_glass__with_overflow__returns_expected(number):\\n glass = moet.create_glass(\\\"A\\\")\\n overflow = glass.fill(number)\\n assert overflow == number - 250\\n assert glass.quantity == 250\",\n \"def test_H_hat(self):\\n\\t\\tposition = [0.0, 1.57079, 3.14159, 4.71238, 6.28318, 7.85398, 9.42477]\\n\\t\\tpotential = [0.0, 6.0, 0.0, -6.0, 0.0, 6.0, 0.0]\\n\\t\\tc = 1\\n\\t\\tposition = tf.constant(position, shape = [1, len(position)], dtype = tf.float32)\\n\\t\\tpotential = tf.constant(potential, shape = [1, len(potential)], dtype = tf.float32)\\n\\t\\tbasis = schrodinger.create_basis(5)\\n\\t\\tv = schrodinger.v0(position, potential, basis)\\n\\t\\tcoeff = schrodinger.coefficient(position, basis)\\n\\t\\tv0_hat = tf.linalg.solve(coeff, v)\\n\\t\\tH = schrodinger.H_hat(c, len(basis), v0_hat)\\n\\t\\tself.assertEqual(coeff.get_shape(), [len(basis), len(basis)])\",\n \"def test_setMassFrac(self):\\n target35 = 0.2\\n self.fuel.setMassFrac(\\\"U235\\\", target35)\\n self.assertAlmostEqual(self.fuel.getMassFrac(\\\"U235\\\"), target35)\",\n \"def test_relaxation_end(self):\\n tau = 50.0\\n mrate = 40.0\\n Mrate = 120.0\\n\\n tmax = 50.0\\n dt = 0.1\\n relaxation = 20.0\\n\\n self.rule.tau = tau\\n self.rule.min_rate = mrate\\n self.rule.max_rate = Mrate\\n self.rule.compress_rates = False\\n self.rule.relaxation = relaxation\\n\\n self.motor.error_fct = lambda _: np.ones(self.Nsrc)\\n\\n M = simulation.StateMonitor(self.rule, 'out')\\n\\n sim = simulation.Simulation(self.source, self.motor, self.rule, M, dt=dt)\\n sim.run(tmax)\\n\\n mask = (M.t > tmax - relaxation/2)\\n mavg = 0.5*(mrate + Mrate)\\n\\n self.assertAlmostEqual(np.mean(np.abs(M.out[:, mask] - mavg)), 0.0)\",\n \"def test_Z_end(self):\\t\\t\\n self.assertAlmostEqual(attempt.Z[-1], 41.47999849170943)\",\n \"def test_stokes_drag():\\n assert DM.stokes_drag(fluid_velocity=1.0, particle_velocity=0.0,\\n diameter=1.0, rho=1.0, fluid_viscosity=1.0) == 18.0\",\n \"def look_ahead_heuristic(game, player):\\n if game.is_loser(player):\\n return float('-inf')\\n\\n if game.is_winner(player):\\n return float('inf')\\n\\n own_legal_moves = game.get_legal_moves(player)\\n own_moves = len(own_legal_moves)\\n for m in own_legal_moves:\\n own_moves += len(game.__get_moves__(m))\\n\\n opp_legal_moves = game.get_legal_moves(game.get_opponent(player))\\n opp_moves = len(opp_legal_moves)\\n for m in opp_legal_moves:\\n opp_moves += len(game.__get_moves__(m))\\n\\n return float(own_moves - opp_moves)\",\n \"def use_manhatten_heur(self):\\r\\n\\t\\tdistance = 0\\r\\n\\r\\n\\t\\tfor row in range(self.n):\\r\\n\\t\\t\\tfor col in range(self.n):\\r\\n\\t\\t\\t\\tintendedX, intendedY = BoardClass.goalTileLocations[self.board[row][col]]\\r\\n\\t\\t\\t\\tdistance += (abs(row - intendedX) + abs(col - intendedY))\\r\\n\\r\\n\\t\\tself.heuristic = distance\",\n \"def test_hanoi(disks=10):\\n t = Hanoi(disks, verbose=False)\\n assert t.tower == {'a': list(range(disks, 0, -1)), 'b': [], 'c': []}\\n t.solve_hanoi()\\n assert t.tower == {'a': [], 'b': [], 'c': list(range(disks, 0, -1))}\",\n \"def dichotomous_search(loss_function: rosenbrock, start: point, direction: list, epsilon=0.1) -> float:\\n a, b = advance_retreat_method(loss_function, start, direction)\\n\\n # find the minimum\\n e = epsilon / 3\\n p, q = (a + b) / 2 - e, (a + b) / 2 + e\\n while abs(a - b) > epsilon:\\n f_p = loss_function.f(start + point(direction[0] * p, direction[1] * p))\\n f_q = loss_function.f(start + point(direction[0] * q, direction[1] * q))\\n if f_p < f_q:\\n b = q\\n else:\\n a = p\\n p, q = (a + b) / 2 - e, (a + b) / 2 + e\\n\\n return (a + b) / 2\",\n \"def next_move(hunter_position, hunter_heading, target_measurement, max_distance, OTHER = None):\\n # This function will be called after each time the target moves.\\n\\n # The OTHER variable is a place for you to store any historical information about\\n # the progress of the hunt (or maybe some localization information). Your return format\\n # must be as follows in order to be graded properly.\\n\\n # helper function to map all angles onto [-pi, pi]\\n def angle_truncate(a):\\n while a < 0.0:\\n a += pi * 2\\n return ((a + pi) % (pi * 2)) - pi\\n\\n #print \\\"true heading\\\"\\n #print test_target.heading\\n I = matrix([[1, 0, 0],\\n [0, 1, 0],\\n [0, 0, 1]]) #identity matrix\\n\\n R = matrix([[measurement_noise, 0], [0, measurement_noise]])\\n\\n H = matrix([[0, 1, 0],\\n [0, 0, 1]]) #Jacobian of the measurement function\\n\\n u = matrix([[0],\\n [0],\\n [0]])\\n\\n F = []\\n\\n heading = 0 #WILD ASS GUESS\\n\\n if OTHER is not None:\\n print \\\"-----------------\\\"\\n current_measurement = target_measurement\\n last_measurement = OTHER['last_measurement']\\n OTHER['measurements'].append(target_measurement)\\n #I know this is stupid but I just want to save the data... Memory management be damned\\n\\n heading = atan2(target_measurement[1] - last_measurement[1], target_measurement[0] - last_measurement[0])\\n print \\\"calculated heading\\\"\\n print heading\\n X = OTHER['X']\\n P = OTHER['P']\\n\\n if 'last_heading' not in OTHER:\\n OTHER['last_heading'] = heading\\n xy_estimate = [X.value[1][0], X.value[2][0]]\\n OTHER['last_measurement'] = target_measurement\\n else:\\n print \\\"OTHER is:\\\", OTHER\\n turning_angle = heading - OTHER['last_heading']\\n print \\\"turning angle:\\\", turning_angle\\n print \\\"turning angle actual:\\\", target.turning\\n #last_heading = OTHER['last_heading']\\n\\n\\n #do some guessing\\n D = distance_between(target_measurement, last_measurement)\\n print \\\"this is the D\\\"\\n print D\\n theta = (heading+turning_angle)%(2*pi)\\n print \\\"theta:\\\", theta\\n print \\\"theta - heading current:\\\", theta - target.heading\\n\\n #estimation step\\n\\n #is it \\\"last heading\\\" or \\\"theta\\\"????\\n # X = matrix([[theta],\\n # [X.value[1][0] + D * cos(theta)],\\n # [X.value[2][0] + D * sin(theta)]])\\n\\n delta_x = D * cos(theta)\\n delta_y = D * sin(theta)\\n\\n nextX = target_measurement[0] + delta_x\\n nextY = target_measurement[1] + delta_y\\n\\n # nextX = X.value[1][0] + delta_x\\n # nextY = X.value[2][0] + delta_y\\n\\n #print \\\"the distance to the next guessed point is:\\\", distance_between([nextX,nextY], measurement)\\n\\n X = matrix([[theta],\\n [nextX],\\n [nextY]])\\n\\n print \\\"I'm projecting X out to:\\\", X\\n print \\\"Note, the current robot stats:\\\", target.heading, target.x, target.y\\n\\n F = matrix([[1, 0, 0],\\n [-D*sin(theta), 1, 0],\\n [D*cos(theta), 0, 1]])\\n\\n P = OTHER['P']\\n #X = OTHER['X']\\n\\n\\n H = matrix([[0, 1, 0],\\n [0, 0, 1]])\\n\\n # #Prediction\\n # X = (F * X) + u\\n # P = F * P * F.transpose() # + Q\\n\\n P = F * P * F.transpose() # + Q\\n\\n #measurement update\\n observations = matrix([[target_measurement[0]],\\n [target_measurement[1]]]) #truth\\n Z = H*X\\n Y = observations - Z\\n print \\\"this is Y\\\"\\n print Y\\n S = H * P * H.transpose() + R\\n K = P * H.transpose() * S.inverse()\\n X = X + (K*Y)\\n\\n P = (I - (K * H)) * P\\n\\n X.value[0][0] = angle_truncate(X.value[0][0])\\n\\n\\n OTHER['X'] = X\\n\\n OTHER['P'] = P\\n x_estimate = OTHER['X'].value[1][0]\\n y_estimate = OTHER['X'].value[2][0]\\n print \\\"Currently, the robot state is:\\\", target.heading, observations\\n print \\\"This is what Kalman thinks X will be:\\\", OTHER['X']\\n xy_estimate = [x_estimate, y_estimate]\\n\\n OTHER['last_heading'] = heading\\n OTHER['last_measurement'] = target_measurement\\n\\n\\n else:\\n #x = theta, x, y\\n X = matrix([[0.5],\\n [2],\\n [4]])\\n #convariance matrix\\n P = matrix([[1000, 0, 0],\\n [0, 1000, 0],\\n [0, 0, 1000]])\\n OTHER = {'last_measurement': target_measurement, 'X': X, 'P': P, 'measurements': [target_measurement]}\\n xy_estimate = [X.value[1][0], X.value[2][0]]\\n\\n # if not OTHER: # first time calling this function, set up my OTHER variables.\\n # measurements = [target_measurement]\\n # hunter_positions = [hunter_position]\\n # hunter_headings = [hunter_heading]\\n # OTHER = (measurements, hunter_positions, hunter_headings) # now I can keep track of history\\n # else: # not the first time, update my history\\n # OTHER[0].append(target_measurement)\\n # OTHER[1].append(hunter_position)\\n # OTHER[2].append(hunter_heading)\\n # measurements, hunter_positions, hunter_headings = OTHER # now I can always refer to these variables\\n\\n #plugging in the Hunter to target the next anticipated area for the target\\n\\n if distance_between(hunter_position, xy_estimate) > max_distance: #if I can't get to the position in time\\n # I want to go to a known point and keep going there.\\n heading_to_target = get_heading(hunter_position, OTHER['measurements'][0]) #grab the first measurement\\n heading_difference = heading_to_target - hunter_heading\\n turning = heading_difference\\n distance = max_distance # full speed ahead!\\n print \\\"I'm moving to the point\\\"\\n if distance_between(hunter_position, OTHER['measurements'][0]) <= max_distance/2:\\n distance = 0 #stay put\\n heading_to_target = get_heading(hunter_position, OTHER['measurements'][1]) #point at the next one\\n heading_difference = heading_to_target - hunter_heading\\n turning = heading_difference\\n print \\\"I'm staying at the point in waiting\\\"\\n else:\\n heading_to_target = get_heading(hunter_position, xy_estimate)\\n heading_difference = heading_to_target - hunter_heading\\n turning = heading_difference # turn towards the target\\n distance_to_point = distance_between(hunter_position, xy_estimate)\\n distance = distance_to_point #I don't want to travel full speed LOL\\n print \\\"ATTACK!\\\"\\n\\n return turning, distance, OTHER\",\n \"def test_above_freezing_above(self):\\n\\n expected = True\\n actual = temperature.above_freezing(5.2)\\n self.assertEqual(expected, actual,\\n \\\"The temperature is above freezing.\\\")\",\n \"def testBearingWest(self):\\n\\n eps = 1.0e-12\\n B = 270 # True bearing\\n\\n p1 = Point(0.0, 0.0)\\n p3 = Point(0.0, 1.0)\\n\\n b = p3.bearing_to(p1)\\n msg = 'Computed southward bearing %d. Expected %d' % (b, B)\\n assert numpy.allclose(b, B, rtol=eps, atol=eps), msg\",\n \"def test_depolarizing_error_2q_gate(self):\\n p_depol = 0.3\\n error = depolarizing_error(p_depol, 2, standard_gates=True)\\n target_circs = [[{\\\"name\\\": \\\"id\\\", \\\"qubits\\\": [0]}],\\n [{\\\"name\\\": \\\"x\\\", \\\"qubits\\\": [0]}],\\n [{\\\"name\\\": \\\"y\\\", \\\"qubits\\\": [0]}],\\n [{\\\"name\\\": \\\"z\\\", \\\"qubits\\\": [0]}],\\n [{\\\"name\\\": \\\"x\\\", \\\"qubits\\\": [1]}],\\n [{\\\"name\\\": \\\"y\\\", \\\"qubits\\\": [1]}],\\n [{\\\"name\\\": \\\"z\\\", \\\"qubits\\\": [1]}],\\n [{\\\"name\\\": \\\"x\\\", \\\"qubits\\\": [0]}, {\\\"name\\\": \\\"x\\\", \\\"qubits\\\": [1]}],\\n [{\\\"name\\\": \\\"x\\\", \\\"qubits\\\": [0]}, {\\\"name\\\": \\\"y\\\", \\\"qubits\\\": [1]}],\\n [{\\\"name\\\": \\\"x\\\", \\\"qubits\\\": [0]}, {\\\"name\\\": \\\"z\\\", \\\"qubits\\\": [1]}],\\n [{\\\"name\\\": \\\"y\\\", \\\"qubits\\\": [0]}, {\\\"name\\\": \\\"x\\\", \\\"qubits\\\": [1]}],\\n [{\\\"name\\\": \\\"y\\\", \\\"qubits\\\": [0]}, {\\\"name\\\": \\\"y\\\", \\\"qubits\\\": [1]}],\\n [{\\\"name\\\": \\\"y\\\", \\\"qubits\\\": [0]}, {\\\"name\\\": \\\"z\\\", \\\"qubits\\\": [1]}],\\n [{\\\"name\\\": \\\"z\\\", \\\"qubits\\\": [0]}, {\\\"name\\\": \\\"x\\\", \\\"qubits\\\": [1]}],\\n [{\\\"name\\\": \\\"z\\\", \\\"qubits\\\": [0]}, {\\\"name\\\": \\\"y\\\", \\\"qubits\\\": [1]}],\\n [{\\\"name\\\": \\\"z\\\", \\\"qubits\\\": [0]}, {\\\"name\\\": \\\"z\\\", \\\"qubits\\\": [1]}]]\\n for j in range(16):\\n circ, p = error.error_term(j)\\n self.remove_if_found(circ, target_circs)\\n if circ == [{\\\"name\\\": \\\"id\\\", \\\"qubits\\\": [0]}]:\\n self.assertAlmostEqual(p, 1 - p_depol + p_depol / 16,\\n msg=\\\"Incorrect identity probability\\\")\\n else:\\n self.assertAlmostEqual(p, p_depol / 16, msg=\\\"Incorrect Pauli probability\\\")\\n self.assertEqual(target_circs, [], msg=\\\"Incorrect unitaries\\\")\",\n \"def test_basic_newton_finder(self):\\n forwards = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\\n strikes = np.array([1.0, 2.0, 1.0, 0.5, 1.0, 1.0])\\n expiries = np.array([1.0, 1.0, 1.0, 1.0, 0.5, 2.0])\\n discounts = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\\n init_vols = np.array([2.0, 0.5, 2.0, 0.5, 1.5, 1.5])\\n option_signs = np.array([1.0, 1.0, -1.0, -1.0, 1.0, 1.0])\\n volatilities = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\\n prices = np.array([\\n 0.38292492, 0.19061012, 0.38292492, 0.09530506, 0.27632639, 0.52049988\\n ])\\n results = implied_vol(\\n forwards,\\n strikes,\\n expiries,\\n discounts,\\n prices,\\n option_signs,\\n initial_volatilities=init_vols,\\n max_iterations=100)\\n implied_vols, converged, failed = self.evaluate(results)\\n num_volatilities = len(volatilities)\\n self.assertAllEqual(np.ones(num_volatilities, dtype=np.bool), converged)\\n self.assertAllEqual(np.zeros(num_volatilities, dtype=np.bool), failed)\\n self.assertArrayNear(volatilities, implied_vols, 1e-7)\",\n \"def test_EvaluatorWallHarmonic_force_device(make_state):\\n state = make_state['state']\\n springConstant = 5.0\\n cutoff = 10.0\\n harmonicWall = EvaluatorWallHarmonic(springConstant, cutoff)\\n\\n # distancesFromWall; make it so that a couple results not representable as an integer\\n distancesFromWall = [1.57079632679, # pi/2\\n 3.14159265359, # pi\\n 5.0, # 5\\n 6.28318530718, # 2 * pi\\n 9.32737905309] # sqrt(87)\\n\\n # forceDirection must have a magnitude of 1.0;\\n # -- in DASH, this is normalized on instantiation of FixWallHarmonic\\n forceDirection = Vector(1.0, 0.0, 0.0)\\n\\n # put explicitly the form of the expected force\\n def force(distanceFromWall, direction):\\n if (distanceFromWall <= cutoff):\\n return direction * springConstant * np.abs((cutoff - distanceFromWall))\\n else:\\n return Vector(0.0, 0.0, 0.0)\\n\\n\\n # test for each value of distance from the wall\\n tolerance = 1e-10\\n\\n for _, item in enumerate(distancesFromWall):\\n calculatedForce = harmonicWall.force_device(item, forceDirection)\\n expectedForce = force(item, forceDirection)\\n formatCode = '{:<30s} {:>18.14f} {:>18.14f} {:>18.14f}'\\n print(formatCode.format(\\\"calculatedForce: \\\", calculatedForce[0], calculatedForce[1], calculatedForce[2]))\\n print(formatCode.format(\\\"expectedForce: \\\", expectedForce[0], expectedForce[1], expectedForce[2]))\\n\\n absoluteDifference = (calculatedForce - expectedForce).len()\\n\\n relativeError = absoluteDifference / (expectedForce.len())\\n print(\\\"{:<30s} {:>18.14f}\\\\n\\\".format(\\\"percent error: \\\", relativeError * 100.0))\\n\\n assert(relativeError <= tolerance)\",\n \"def test_calculate_circumsolar_shading():\\n # Test for one value of 20% of the diameter being covered\\n percentage_distance_covered = 20.\\n percent_shading = calculate_circumsolar_shading(\\n percentage_distance_covered, model='uniform_disk')\\n\\n # Compare to expected\\n expected_disk_shading_perc = 14.2378489933\\n atol = 0\\n rtol = 1e-8\\n np.testing.assert_allclose(expected_disk_shading_perc, percent_shading,\\n atol=atol, rtol=rtol)\",\n \"def check_heated_up(error):\\n error = np.array(error)\\n error = np.abs(error)\\n if len(error) < 30 or sum(error[-30:-1]) > 15:\\n return False\\n else:\\n return True\",\n \"def test_pos_1024() -> None:\\n assert sw.walk_to(1024).distance == 31\",\n \"def test_scalar_dewpoint_from_relative_humidity():\\n td = dewpoint_from_relative_humidity(10.6 * units.degC, 0.37)\\n assert_almost_equal(td, 26. * units.degF, 0)\",\n \"def test_moist_lapse_downwards():\\n temp = moist_lapse(units.Quantity([600, 700], 'mbar'), units.Quantity(0, 'degC'))\\n assert_almost_equal(temp, units.Quantity([0, 6.47748353], units.degC), 4)\",\n \"def test_parity(float_tolerance, l):\\n x = torch.randn(3)\\n Y1 = (-1)**l * o3.spherical_harmonics(l, x, False)\\n Y2 = o3.spherical_harmonics(l, -x, False)\\n assert (Y1 - Y2).abs().max() < float_tolerance\",\n \"def test_griewank(self):\\n fun = get_problem('griewank', self.dimension)\\n self.assertEqual(fun(self.array), 0.0)\",\n \"def run(self):\\n move_cmd = Twist()\\n move_cmd.linear.x = 0\\n move_cmd.angular.z = 0\\n\\n while not rospy.is_shutdown():\\n # bump logic as previous psets\\n if self.bump:\\n self.bump = False\\n # move backwards\\n move_cmd.linear.x = LIN_SPEED * -1\\n for i in range(5):\\n self.cmd_vel.publish(move_cmd)\\n self.rate.sleep()\\n rospy.sleep(1)\\n\\n # turn randomly in a random direction\\n move_cmd.linear.x = 0\\n move_cmd.angular.z = ROT_SPEED * ((-1)**random.randint(1,2))\\n\\n if self.bump == 0:\\n move_cmd.angular.z = ROT_SPEED * (-1)\\n elif self.bump == 2:\\n move_cmd.angular.z = ROT_SPEED\\n\\n for i in range(random.randint(5,15)):\\n self.cmd_vel.publish(move_cmd)\\n self.rate.sleep()\\n rospy.sleep(1)\\n\\n move_cmd.angular.z = 0\\n # if somethin in the screen is really close\\n elif self.min_val < MIN_THRESHOLD:\\n # make sure it's not the sock/leg warmer, and is actually an obstacle\\n if self.obstacle_x <= self.x or self.obstacle_x >= self.x + self.w or abs(self.min_val - self.dist) > 0.1:\\n move_cmd.linear.x = 0\\n # turn away\\n if self.obstacle_x > 320:\\n move_cmd.angular.z = ROT_SPEED / 2\\n else:\\n move_cmd.angular.z = -ROT_SPEED / 2\\n # self.min_val = 100\\n for i in range(10):\\n self.cmd_vel.publish(move_cmd)\\n self.rate.sleep()\\n self.last_move = rospy.Time.now()\\n else:\\n rospy.loginfo(\\\"Perimeter \\\" + str(self.perimeter_size))\\n rospy.loginfo(\\\"Distance is \\\" + str(self.dist))\\n\\n # normalize angle error to rot speed\\n ang_error_norm = -float(self.ang_error) / 100\\n\\n # set min and max rot speed\\n if ang_error_norm < -ROT_SPEED:\\n ang_error_norm = -ROT_SPEED\\n elif ang_error_norm > ROT_SPEED:\\n ang_error_norm = ROT_SPEED\\n\\n move_cmd.angular.z = ang_error_norm\\n\\n if RACE == False:\\n # normalize dist error to lin speed\\n self.dist_error = self.dist - 0.5\\n dist_error_norm = float(self.dist_error) / 2\\n\\n if dist_error_norm < 0:\\n # if NaN (self.dist gets set to -1)\\n if dist_error_norm > -0.7:\\n self.lost = 0\\n # if too close\\n else:\\n self.lost += 1\\n # if it's been more than 2 seconds\\n if rospy.Time.now() > self.last_move + rospy.Duration(2):\\n dist_error_norm = 0\\n # if been lost for a while rotate and beep\\n if self.lost > 20:\\n move_cmd.angular.z = ROT_SPEED / 4\\n self.beep.publish(4)\\n else:\\n # continue as previous\\n dist_error_norm = self.last_speed\\n else:\\n # set max lin speed\\n if dist_error_norm > LIN_SPEED:\\n dist_error_norm = LIN_SPEED\\n\\n # reset lost stats\\n self.lost = 0\\n self.last_speed = dist_error_norm\\n self.last_move = rospy.Time.now()\\n\\n move_cmd.linear.x = dist_error_norm\\n else:\\n move_cmd.linear.x = LIN_SPEED\\n\\n self.cmd_vel.publish(move_cmd)\",\n \"def double_middle_drop(progress):\\n eps1 = 0.75\\n eps2 = 0.25\\n if 1 - progress < eps1:\\n if 1 - progress < eps2:\\n return eps2 * 0.5\\n return eps1 * 0.1\\n return 1 - progress\",\n \"def test_uneven_sw():\\n B = 100\\n t = 1\\n H = 30\\n E = 20000\\n sections = ((2 * B, t, 0, E), (B, t, H - t, E))\\n EI, top, bot = bm.EI(sections, E)\\n assert 1.95 < abs(bot) / top < 1.96\",\n \"def test_bs(self):\\r\\n res = BlackScholes(100, 0.10, 0.5, 1.00)\\r\\n self.assertEqual(round(res, 2), 23.93)\",\n \"def test_newton_rhapson(testFunctions, tol, printFlag): \\n pass\",\n \"def test_tract_split_housing(self):\\n # Validate first new tract from the split tract\\n # Tract 35.01\\n tract1 = self.geographies.find({ 'geoid': '15003003501' })\\n self.assertEqual(tract1.count(), 1)\\n tract1 = tract1[0]\\n \\n split_tract_house_2000 = 3370 \\n tract1_house_pct = 0.383 \\n tract1_house_2000 = int(tract1_house_pct * split_tract_house_2000)\\n tract1_house_2010 = 1353 \\n tract1_house_delta = tract1_house_2010 - tract1_house_2000\\n tract1_house_pct_change = float(tract1_house_delta) / tract1_house_2000\\n\\n self.assertAlmostEqual(tract1['xwalk']['15003003500']['HUPCT00'], tract1_house_pct, places=4)\\n self.assertAlmostEqual(tract1['data']['2000']['H1']['H001001'], tract1_house_2000)\\n self.assertAlmostEqual(float(tract1['data']['2010']['H1']['H001001']), tract1_house_2010)\\n self.assertAlmostEqual(float(tract1['data']['delta']['H1']['H001001']), tract1_house_delta)\\n self.assertAlmostEqual(float(tract1['data']['pct_change']['H1']['H001001']), tract1_house_pct_change)\\n\\n # Validate second new part from the split tract\\n # Tract 35.02\\n tract2 = self.geographies.find({ 'geoid': '15003003502' })\\n self.assertEqual(tract2.count(), 1)\\n tract2 = tract2[0]\\n\\n tract2_house_pct = 0.617\\n tract2_house_2000 = int(tract2_house_pct * split_tract_house_2000)\\n tract2_house_2010 = 2180 \\n tract2_house_delta = tract2_house_2010 - tract2_house_2000\\n tract2_house_pct_change = float(tract2_house_delta) / tract2_house_2000 \\n \\n self.assertAlmostEqual(tract2['xwalk']['15003003500']['HUPCT00'], tract2_house_pct, places=4)\\n self.assertAlmostEqual(tract2['data']['2000']['H1']['H001001'], tract2_house_2000)\\n self.assertAlmostEqual(float(tract2['data']['2010']['H1']['H001001']), tract2_house_2010)\\n self.assertAlmostEqual(float(tract2['data']['delta']['H1']['H001001']), tract2_house_delta)\\n self.assertAlmostEqual(float(tract2['data']['pct_change']['H1']['H001001']), tract2_house_pct_change)\",\n \"def toluene():\\n coords = [\\n [1.2264, 0.0427, 0.0670],\\n [1.0031, -1.3293, 0.0600],\\n [-0.2945, -1.8256, -0.0060],\\n [-1.3704, -0.9461, -0.0646],\\n [-1.1511, 0.4266, -0.0578],\\n [0.1497, 0.9292, 0.0066],\\n [0.3871, 2.3956, -0.0022],\\n [2.2495, 0.4310, 0.1211],\\n [1.8510, -2.0202, 0.1071],\\n [-0.4688, -2.9062, -0.0109],\\n [-2.3926, -1.3347, -0.1157],\\n [-2.0006, 1.1172, -0.1021],\\n [0.5024, 2.7582, -1.0330],\\n [1.2994, 2.6647, 0.5466],\\n [-0.4475, 2.9470, 0.4506],\\n ]\\n coords = [[float(j) / Bohr for j in i] for i in coords]\\n\\n symbols = [\\n \\\"C\\\",\\n \\\"C\\\",\\n \\\"C\\\",\\n \\\"C\\\",\\n \\\"C\\\",\\n \\\"C\\\",\\n \\\"C\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n ]\\n\\n atoms = []\\n for i, _ in enumerate(coords):\\n atoms.append(Atom(symbols[i], position=coords[i]))\\n return Molecule(symbols=atoms)\",\n \"def brents(f, x0, x1, max_iter=50, tolerance=1e-5):\\n \\n fx0 = f(x0)\\n fx1 = f(x1)\\n \\n assert (fx0 * fx1) <= 0, \\\"Root not bracketed\\\" \\n \\n if abs(fx0) < abs(fx1):\\n x0, x1 = x1, x0\\n fx0, fx1 = fx1, fx0\\n \\n x2, fx2 = x0, fx0\\n \\n d = np.nan\\n mflag = True\\n steps_taken = 0\\n \\n while steps_taken < max_iter and abs(x1-x0) > tolerance:\\n fx0 = f(x0)\\n fx1 = f(x1)\\n fx2 = f(x2)\\n \\n if fx0 != fx2 and fx1 != fx2:\\n L0 = (x0 * fx1 * fx2) / ((fx0 - fx1) * (fx0 - fx2))\\n L1 = (x1 * fx0 * fx2) / ((fx1 - fx0) * (fx1 - fx2))\\n L2 = (x2 * fx1 * fx0) / ((fx2 - fx0) * (fx2 - fx1))\\n new = L0 + L1 + L2\\n \\n else:\\n new = x1 - ( (fx1 * (x1 - x0)) / (fx1 - fx0) )\\n \\n tt1 = (new < ((3 * x0 + x1) / 4) or new > x1)\\n tt2 = (mflag == True and (abs(new - x1)) >= (abs(x1 - x2) / 2))\\n tt3 = (mflag == False and (abs(new - x1)) >= (abs(x2 - d) / 2))\\n tt4 = (mflag == True and (abs(x1 - x2)) < tolerance)\\n tt5 = (mflag == False and (abs(x2 - d)) < tolerance)\\n if (tt1 or\\n tt2 or\\n tt3 or\\n tt4 or\\n tt5):\\n new = (x0 + x1) / 2\\n mflag = True\\n \\n else:\\n mflag = False\\n \\n fnew = f(new)\\n d, x2 = x2, x1\\n \\n if (fx0 * fnew) < 0:\\n x1 = new\\n else:\\n x0 = new\\n \\n if abs(fx0) < abs(fx1):\\n x0, x1 = x1, x0\\n \\n steps_taken += 1\\n \\n return x1, steps_taken\",\n \"def test_fix_fingers_w_thresh(self):\\n\\t\\tdetails = self.watcher.analyze(layers=[17], fix_fingers='clip_xmax', finger_thresh=10.0)\\n\\t\\tactual_alpha = details.alpha.to_numpy()[0]\\n\\t\\tactual_raw_alpha = details.raw_alpha.to_numpy()[0]\\n\\t\\tactual_num_fingers = details.num_fingers.to_numpy()[0]\\n\\n\\t\\texpected_alpha = 6.883742\\n\\t\\texpected_raw_alpha = expected_alpha\\n\\t\\texpected_num_fingers = 0\\n\\t\\tself.assertAlmostEqual(actual_alpha,expected_alpha, delta=0.1 )\\n\\t\\tself.assertAlmostEqual(actual_raw_alpha,expected_raw_alpha, delta=0.01 )\\n\\t\\tself.assertEqual(actual_num_fingers,expected_num_fingers)\",\n \"def test_GBL_tau_star():\\n z = 1.0\\n\\n # Fully ionized H and He\\n x_ionH = 1.0\\n x_ionHe = 2.0\\n\\n cosmo = {}\\n cosmo['omega_M_0'] = numpy.array([[0.3],[0.6],[1.0]])\\n cosmo['omega_lambda_0'] = 1. - cosmo['omega_M_0']\\n cosmo['h'] = 0.65\\n cosmo['omega_b_0'] = 0.02 / cosmo['h']**2.\\n cosmo['Y_He'] = 0.24\\n cd.set_omega_k_0(cosmo)\\n\\n tau_inst, tau_star = cr.optical_depth_instant(z, \\n x_ionH=x_ionH, \\n x_ionHe=x_ionHe, \\n return_tau_star=True,\\n **cosmo)\\n print(\\\"tau_star = %.7f\\\" % (tau_star))\\n print(\\\"tau_star/(h Omega_b) = %.7f =? 0.061\\\" % \\n (tau_star / (cosmo['h'] * cosmo['omega_b_0'])))\\n\\n ntest.assert_approx_equal(tau_star / (cosmo['h'] * cosmo['omega_b_0']),\\n 0.061,\\n 2)\\n\\n print(\\\"(1 - Y_He/2) = %.3f =? 0.88\\\" % (1. - (cosmo['Y_He']/2.)))\\n ntest.assert_approx_equal((1. - (cosmo['Y_He']/2.)),\\n 0.88,\\n 7)\\n\\n H_0 = cc.H100_s * cosmo['h']\\n\\n # s^-1 * Mpc s^-1 * Mpc^2 / Mpc^3 msun^-1 s^-2 / Msun -> \\n tau_star_explicit = ((1. - (cosmo['Y_He']/2.)) * \\n ((3. * H_0 * cosmo['omega_b_0'] * cc.c_light_Mpc_s *\\n cc.sigma_T_Mpc) / \\n (8. * math.pi * cc.G_const_Mpc_Msun_s * \\n (cc.m_p_g/cc.M_sun_g))))\\n\\n print(\\\"tau_star_explicit = %.7f =? tau_star\\\" % (tau_star_explicit))\\n ntest.assert_approx_equal(tau_star, tau_star_explicit, 3)\",\n \"def test_positive_definite2(dist, alpha, divergence):\\n assert divergence(dist, dist, alpha, rvs=[0, 1]) == pytest.approx(0)\\n assert hellinger_sum(dist, dist, alpha, rvs=[0, 1]) == pytest.approx(1)\",\n \"def close(a,b):\\n return abs(a-b) < epsilon\",\n \"def test_moist_lapse_nan_ref_press():\\n temp = moist_lapse(40 * units.hPa, -20 * units.degC, np.nan * units.hPa)\\n assert_nan(temp, units.degC)\",\n \"def Catch(X,Tolerance=0):\\n if X < (.5-(Tolerance/2)):\\n return(0)\\n elif X > (.5+(Tolerance/2)):\\n return(1)\\n else:\\n return(.5)\",\n \"def heron(num: int):\\n try:\\n if num < 0:\\n raise ZeroDivisionError\\n else:\\n guess = num\\n tolerance = 0.00001\\n while abs(guess * guess - num) > tolerance: # continue finding a more accurate guess if the guess is not\\n # close enough to the true root, as defined by the tolerance\\n guess = (guess + num / guess) / 2 # this formula is a step towards finding the square root of a number\\n return float(round(guess, 2))\\n except ZeroDivisionError:\\n print(\\\"You have entered a negative integer, that is not valid.\\\")\\n return -1\",\n \"def epsilon_delta(self):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6039334","0.5930424","0.5919679","0.5912854","0.58305484","0.5801236","0.57621497","0.5761265","0.57383764","0.57260656","0.5721062","0.5718691","0.57167894","0.5701574","0.5683872","0.56769484","0.56751597","0.56513155","0.56409764","0.5639347","0.5600166","0.5595595","0.55947536","0.55648094","0.5562508","0.554382","0.553768","0.55016816","0.5493007","0.5487738","0.54811543","0.54670274","0.5465295","0.54636616","0.5462555","0.54621357","0.54403603","0.54338336","0.5430973","0.54275393","0.5416691","0.5403474","0.54013175","0.5393482","0.53908914","0.53684443","0.5367628","0.5366582","0.5362684","0.53603977","0.53571343","0.5355136","0.5353467","0.53439564","0.5338917","0.5334645","0.5330583","0.53297484","0.5327329","0.5319604","0.53176063","0.5304038","0.5300962","0.5297576","0.52794546","0.5278923","0.5278383","0.5269465","0.52635705","0.5260979","0.52565384","0.52501845","0.5246738","0.52463764","0.5246162","0.5240646","0.5240567","0.52356464","0.5235644","0.5234966","0.52333486","0.5231699","0.5230116","0.5227097","0.52270657","0.5223344","0.5217175","0.5213797","0.52130395","0.5202438","0.519991","0.51971173","0.51959497","0.51901466","0.5179456","0.51790196","0.51785815","0.5164492","0.5162965","0.5161438","0.51582825"],"string":"[\n \"0.6039334\",\n \"0.5930424\",\n \"0.5919679\",\n \"0.5912854\",\n \"0.58305484\",\n \"0.5801236\",\n \"0.57621497\",\n \"0.5761265\",\n \"0.57383764\",\n \"0.57260656\",\n \"0.5721062\",\n \"0.5718691\",\n \"0.57167894\",\n \"0.5701574\",\n \"0.5683872\",\n \"0.56769484\",\n \"0.56751597\",\n \"0.56513155\",\n \"0.56409764\",\n \"0.5639347\",\n \"0.5600166\",\n \"0.5595595\",\n \"0.55947536\",\n \"0.55648094\",\n \"0.5562508\",\n \"0.554382\",\n \"0.553768\",\n \"0.55016816\",\n \"0.5493007\",\n \"0.5487738\",\n \"0.54811543\",\n \"0.54670274\",\n \"0.5465295\",\n \"0.54636616\",\n \"0.5462555\",\n \"0.54621357\",\n \"0.54403603\",\n \"0.54338336\",\n \"0.5430973\",\n \"0.54275393\",\n \"0.5416691\",\n \"0.5403474\",\n \"0.54013175\",\n \"0.5393482\",\n \"0.53908914\",\n \"0.53684443\",\n \"0.5367628\",\n \"0.5366582\",\n \"0.5362684\",\n \"0.53603977\",\n \"0.53571343\",\n \"0.5355136\",\n \"0.5353467\",\n \"0.53439564\",\n \"0.5338917\",\n \"0.5334645\",\n \"0.5330583\",\n \"0.53297484\",\n \"0.5327329\",\n \"0.5319604\",\n \"0.53176063\",\n \"0.5304038\",\n \"0.5300962\",\n \"0.5297576\",\n \"0.52794546\",\n \"0.5278923\",\n \"0.5278383\",\n \"0.5269465\",\n \"0.52635705\",\n \"0.5260979\",\n \"0.52565384\",\n \"0.52501845\",\n \"0.5246738\",\n \"0.52463764\",\n \"0.5246162\",\n \"0.5240646\",\n \"0.5240567\",\n \"0.52356464\",\n \"0.5235644\",\n \"0.5234966\",\n \"0.52333486\",\n \"0.5231699\",\n \"0.5230116\",\n \"0.5227097\",\n \"0.52270657\",\n \"0.5223344\",\n \"0.5217175\",\n \"0.5213797\",\n \"0.52130395\",\n \"0.5202438\",\n \"0.519991\",\n \"0.51971173\",\n \"0.51959497\",\n \"0.51901466\",\n \"0.5179456\",\n \"0.51790196\",\n \"0.51785815\",\n \"0.5164492\",\n \"0.5162965\",\n \"0.5161438\",\n \"0.51582825\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":491,"cells":{"query":{"kind":"string","value":"Fail on ffs.open, but still readout flat."},"document":{"kind":"string","value":"def test_goto_field_boss_ffs_open_fails(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n self.cmd.failOn = 'mcp ffs.open'\n self._goto_field_boss(21, 102, 1, 1, cmdState, didFail=True, finish=True)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_fileobj_not_closed(self):\n\n f = open(self.data('test0.fits'), 'rb')\n data = fits.getdata(f)\n assert not f.closed\n\n f.seek(0)\n header = fits.getheader(f)\n assert not f.closed","def test_fileobj_not_closed(self):\n\n f = open(self.data(\"test0.fits\"), \"rb\")\n _ = fits.getdata(f)\n assert not f.closed\n\n f.seek(0)\n _ = fits.getheader(f)\n assert not f.closed\n\n f.close() # Close it now","def test_file_readas_missing_file(self):\n with (self.assertRaises(IOError)):\n FileReader(self.bogus_path).read_as(\"utf-8\")","def test_file_read_bin_missing_file(self):\n with (self.assertRaises(IOError)):\n FileReader(self.bogus_path).read_bin()","def test_read_raw_unsupported_multi(fname, tmp_path):\n fname = tmp_path / fname\n fname.write_text('')\n with pytest.raises(RuntimeError, match='Could not read.*using any'):\n read_raw(fname)","def test_file_read_utf8_missing_file(self):\n with (self.assertRaises(IOError)):\n FileReader(self.bogus_path).read_utf8()","def test_file_readlines_utf8_missing_file(self):\n with (self.assertRaises(IOError)):\n FileReader(self.bogus_path).readlines_utf8()","def test_read_raw_suggested(fname):\n with pytest.raises(ValueError, match='Try reading'):\n read_raw(fname)","def test_get_all_read_fail(self):\n file_handler = open(self.test_task_filename, 'w')\n file_handler.write('Mock corrupt data')\n file_handler.close()\n os.chmod(self.test_task_filename, 000)\n\n self.assertRaises(IOError, self.task_storage.get_all)","def test_is_not_delicious_file(self):\r\n bad_file = StringIO.StringIO()\r\n bad_file.write('failing tests please')\r\n bad_file.seek(0)\r\n\r\n self.assertTrue(\r\n not DelXMLImporter.can_handle(bad_file),\r\n \"DelXMLImporter cannot handle this file\")\r\n\r\n bad_file.close()","def test_is_not_delicious_file(self):\r\n bad_file = StringIO.StringIO()\r\n bad_file.write('failing tests please')\r\n bad_file.seek(0)\r\n\r\n self.assertTrue(\r\n not DelImporter.can_handle(bad_file),\r\n \"DelImporter cannot handle this file\")\r\n\r\n bad_file.close()","def test_file_read_missing_file(self):\n with (self.assertRaises(IOError)):\n FileReader(self.bogus_path).read()","def attempt_file_reset(f):\r\n if hasattr(f, 'seek'):\r\n f.seek(0)","def test_read_fail2(self):\n mod_fn = os.path.join(tests.TEST_DATA_PATH, 'segmentations', 'test_bad_data2.mod')\n with self.assertRaises(ValueError):\n modreader.get_data(mod_fn) # missing 'IEOF' end","def test_empty_stream(self):\r\n mock_file = MockFile([b\"\"])\r\n for _ in BinaryIOStream(mock_file):\r\n # This should never happen\r\n self.assertFalse(True)","def eofTestHelperStress(self, pfactory):\n # TODO: we should make sure this covers more of the code paths\n\n for i in xrange(0, len(self.data) + 1):\n trans = TTransport.TMemoryBuffer(self.data[0:i])\n prot = pfactory.getProtocol(trans)\n try:\n x = Xtruct()\n x.read(prot)\n x.read(prot)\n x.read(prot)\n except EOFError:\n continue\n self.fail(\"Should have gotten an EOFError\")","def test_fileio(tmp_path):\n async def aiotests():\n fio = fileio.FileIO(Path(tmp_path))\n\n with pytest.raises(PermissionError):\n fio.resolve_and_sanitize('../abba123')\n\n with pytest.raises(PermissionError):\n fio.resolve_and_sanitize('/abba123')\n\n with pytest.raises(FileNotFoundError):\n fio.resolve_and_sanitize('abba123', must_exist=True)\n\n with pytest.raises(FileNotFoundError):\n fio.open_and_seek('abba123', 0, for_write=False)\n\n with pytest.raises(PermissionError):\n fio.open_and_seek('../abba123', 0, for_write=False)\n\n with pytest.raises(aiohttp.web.HTTPForbidden):\n await fio.upload_chunk(chunker.FileChunk(path='../abba1234', pos=0, size=123, cmpratio=1, hash='abcdef1234'), None)\n\n with pytest.raises(aiohttp.web.HTTPInternalServerError):\n await fio.upload_chunk(chunker.FileChunk(path=False, pos=0, size=123, cmpratio=1, hash='abcdef1234'), None)\n\n assert await fio.copy_chunk_locally(\n chunker.FileChunk(path='abba1234', pos=0, size=123, cmpratio=1, hash='abcdef1234'),\n chunker.FileChunk(path='abba1234', pos=0, size=123, cmpratio=1, hash='abcdef1234')) is True\n\n with pytest.raises(ValueError):\n assert await fio.copy_chunk_locally(\n chunker.FileChunk(path='abba1234', pos=0, size=123, cmpratio=1, hash='abcdef1234'),\n chunker.FileChunk(path='asdfklna', pos=0, size=123, cmpratio=1, hash='ABABABABAB'))\n\n assert fio.try_precreate_large_sparse_file('sparsefiletest.bin', 1234) == fio.resolve_and_sanitize('sparsefiletest.bin').exists()\n await fio.remove_file_and_paths('sparsefiletest.bin')\n\n asyncio.run(aiotests())","def test_ioerror_buffer_position(self):\n bytes = pyamf.encode(u'foo', [1, 2, 3], encoding=pyamf.AMF3).getvalue()\n\n self.buf.write(bytes[:-1])\n self.buf.seek(0)\n\n self.decoder.readElement()\n self.assertEqual(self.buf.tell(), 5)\n\n self.assertRaises(IOError, self.decoder.readElement)\n self.assertEqual(self.buf.tell(), 5)","def test_issue_172_1():\n input_data = 8 * os.urandom(1024)\n with lz4.frame.open('testfile_small', 'wb') as fp:\n bytes_written = fp.write(input_data) # noqa: F841\n\n with lz4.frame.open('testfile_small', 'rb') as fp:\n data = fp.read(10)\n assert len(data) == 10","def test_open_by_unnamed_fobj(self):\n with open(ZIPPATH, 'rb') as zf:\n with io.FileIO(zf.fileno(), mode='r', closefd=False) as f:\n self._test_listing_content(f)","def test_read_EOF(demo_data):\n\n openeeg = openEDF(demo_data)\n start = max(openeeg.header.samples) + 1\n arr = openeeg.read(start, start+100)\n assert arr.size == 0\n\n openeeg.close()","def test_cantChangeFileMode(self):\n if runtime.platform.isWindows():\n name, directory = \"NUL\", \"\"\n expectedPath = \"NUL\"\n else:\n name, directory = \"null\", \"/dev\"\n expectedPath = \"/dev/null\"\n\n log = logfile.LogFile(name, directory, defaultMode=0o555)\n self.addCleanup(log.close)\n\n self.assertEqual(log.path, expectedPath)\n self.assertEqual(log.defaultMode, 0o555)","def test_empty_file(self):\n with open(os.path.join(test_dir, \"empty_file.txt\")) as f:\n for idx, line in enumerate(reverse_readline(f)):\n raise ValueError(\"an empty file is being read!\")","def test_file_readlines_missing_file(self):\n with (self.assertRaises(IOError)):\n FileReader(self.bogus_path).readlines()","def rewind(f):\n\tf.seek(0)","def test_garbage_stream(self):\r\n valid: bytes = b\"!AIVDM,1,1,,B,B43JRq00LhTWc5VejDI>wwWUoP06,0*29\"\r\n mock_file = MockFile([b\"Foo\", b\"Bar\", b\"1337\", valid])\r\n for msg in BinaryIOStream(mock_file):\r\n self.assertEqual(msg.raw, valid)","def test_cache_pollution(self):\n with self._test_checksum_setup(self.tempdir.name) as setupdata:\n filename, data, expected_checksum = setupdata\n\n # corrupt the file\n with open(os.path.join(self.tempdir.name, filename), \"r+b\") as fh:\n fh.seek(0)\n real_first_byte = fh.read(1).decode(\"latin-1\")\n fh.seek(0)\n fh.write(chr(ord(real_first_byte) ^ 0xff).encode(\"latin-1\"))\n\n with self.assertRaises(ChecksumValidationError):\n with self.caching_backend.read_contextmanager(filename, expected_checksum) as cm:\n self.assertEqual(cm.read(), data)\n\n # un-corrupt the file\n with open(os.path.join(self.tempdir.name, filename), \"r+b\") as fh:\n fh.seek(0)\n real_first_byte = fh.read(1).decode(\"latin-1\")\n fh.seek(0)\n fh.write(chr(ord(real_first_byte) ^ 0xff).encode(\"latin-1\"))\n\n with self.caching_backend.read_contextmanager(filename, expected_checksum) as cm:\n self.assertEqual(cm.read(), data)","def test_read_raw_unsupported_single(fname):\n with pytest.raises(ValueError, match='Unsupported file type'):\n read_raw(fname)","def test_failToOpenLocalFile(self):\n fp = FilePath(self.mktemp()).child(\"child-with-no-existing-parent\")\n\n self.assertRaises(IOError, self.makeConnectedDccFileReceive, fp.path)","def test_find_read_fail(self):\n file_handler = open(self.test_task_filename, 'w')\n file_handler.write('Mock corrupt data')\n file_handler.close()\n os.chmod(self.test_task_filename, 000)\n\n self.assertRaises(IOError, self.task_storage.find, self.my_task)","def test_file_read_gzip_missing_file(self):\n with (self.assertRaises(IOError)):\n FileReader(self.bogus_path).read_gzip()","def open_from(self, f: BinaryIO):\n raise NotImplementedError","def test_empty_file(self):\n\n temp = tempfile.NamedTemporaryFile()\n temp.flush()\n self.assertRaises(MalformedFileError, NBTFile, temp.name)","def rewind(f):\n f.seek(0)","def test_get_read_fail(self):\n file_handler = open(self.test_key_filename, 'w')\n file_handler.write('Mock corrupt data')\n file_handler.close()\n os.chmod(self.test_key_filename, 000)\n\n self.assertRaises(IOError, self.key_gen.get)","def read_fd_decode_safely(fd, size=4096):\n data = os.read(fd.fileno(), size)\n for _ in range(3):\n try:\n return data, data.decode(\"utf-8\")\n except UnicodeDecodeError as e:\n if e.reason != \"unexpected end of data\":\n raise\n data += os.read(fd.fileno(), 1)\n\n return data, data.decode(\"utf-8\")","def test_level2_fobj(filename, use_seek):\n f = get_test_data(filename)\n if not use_seek:\n class SeeklessReader:\n \"\"\"Simulate file-like object access without seek.\"\"\"\n\n def __init__(self, f):\n self._f = f\n\n def read(self, n=None):\n \"\"\"Read bytes.\"\"\"\n return self._f.read(n)\n\n f = SeeklessReader(f)\n Level2File(f)","def test_read_fail1(self):\n mod_fn = os.path.join(tests.TEST_DATA_PATH, 'segmentations', 'test_bad_data1.mod')\n with self.assertRaises(ValueError):\n modreader.get_data(mod_fn) # missing 'IMOD' start","def test_no_eof(self):","def test_file_unused(self):\n try:\n with get_temp_file() as (fd, name):\n pass\n except Exception as err:\n self.fail('Failed with exception \"{}\"'.format(err))\n else:\n file_exists = os.access(name, os.F_OK)\n self.assertFalse(file_exists)","def _barf_if_closed(self):\n if self.closed:\n raise ValueError(\"I/O operation on closed file\")","def _check_truncation(self):\n\n temp_pos = self._handle.tell()\n self._handle.seek(-28, 2)\n eof = self._handle.read()\n self._handle.seek(temp_pos)\n if eof == _bgzf_eof:\n return False\n else:\n warnings.BytesWarning('No EOF character found. File may be truncated')\n return True","def test_not_implemented():\n for not_implemented_ext in ['.mef', '.nwb']:\n data_path = _TempDir()\n raw_fname = op.join(data_path, 'test' + not_implemented_ext)\n with open(raw_fname, 'w', encoding='utf-8'):\n pass\n with pytest.raises(ValueError, match=('there is no IO support for '\n 'this file format yet')):\n _read_raw(raw_fname)","def __init__(self, fname, endian='<', checksum_size=None, debug_level=0):\n self.endian = endian\n self.f = open(expanduser(fname), 'rb')\n self.f.seek(0, 2)\n self.fsize = self.tell()\n self.f.seek(0, 0)\n self.close = self.f.close\n if checksum_size:\n pass\n #self.cs = checksum(self, 0, checksum_size)\n else:\n self.cs = checksum_size\n self.debug_level = debug_level","def test_read():\n f = open('test', mode='r')\n line = f.read()\n f.close()","def test_fastq_output(self):\r\n self.assertRaises(IOError, convert_fastq, self.fasta_file_path,\r\n self.qual_file_path, output_directory=self.read_only_output_dir)","def _verify_descriptors(self, msg):\n self.assertTrue(is_writable_file(msg.chlderr))\n self.assertTrue(is_writable_file(msg.chldout))\n self.assertTrue(is_writable_file(msg.chldnul))","def test_malformed(self):\n fdesc, fname = tempfile.mkstemp()\n tfile = os.fdopen(fdesc, 'w')\n tfile.write(self.file_str2)\n tfile.close()\n assert_raises(Exception, grades.writers.GradesFile, fname)\n os.unlink(fname)","def test_noPermission(self):\n log = logfile.LogFile(self.name, self.dir)\n self.addCleanup(log.close)\n log.write(\"abc\")\n\n # change permissions so rotation would fail\n os.chmod(self.dir, 0o555)\n\n # if this succeeds, chmod doesn't restrict us, so we can't\n # do the test\n try:\n f = open(os.path.join(self.dir, \"xxx\"), \"w\")\n except OSError:\n pass\n else:\n f.close()\n return\n\n log.rotate() # this should not fail\n\n log.write(\"def\")\n log.flush()\n\n f = log._file\n self.assertEqual(f.tell(), 6)\n f.seek(0, 0)\n self.assertEqual(f.read(), b\"abcdef\")","def _unblock_open_fifo_operation(self) -> None:\n if os.path.exists(self._fifo_out_path):\n open(self._fifo_out_path, 'wb', buffering=0)\n if os.path.exists(self._fifo_in_path):\n open(self._fifo_in_path, 'rb', buffering=0)","def test_fiberflat_rw(self):\n from ..fiberflat import FiberFlat\n from ..io.fiberflat import read_fiberflat, write_fiberflat\n nspec, nwave, ndiag = 10, 20, 3\n flat = np.random.uniform(size=(nspec, nwave))\n ivar = np.random.uniform(size=(nspec, nwave))\n mask = np.zeros(shape=(nspec, nwave), dtype=int)\n meanspec = np.random.uniform(size=(nwave,))\n wave = np.arange(nwave)\n\n ff = FiberFlat(wave, flat, ivar, mask, meanspec)\n\n write_fiberflat(self.testfile, ff)\n xff = read_fiberflat(self.testfile)\n\n self.assertTrue(np.all(ff.fiberflat.astype('f4').astype('f8') == xff.fiberflat))\n self.assertTrue(np.all(ff.ivar.astype('f4').astype('f8') == xff.ivar))\n self.assertTrue(np.all(ff.mask == xff.mask))\n self.assertTrue(np.all(ff.meanspec.astype('f4').astype('f8') == xff.meanspec))\n self.assertTrue(np.all(ff.wave.astype('f4').astype('f8') == xff.wave))\n\n self.assertTrue(xff.fiberflat.dtype.isnative)\n self.assertTrue(xff.ivar.dtype.isnative)\n self.assertTrue(xff.mask.dtype.isnative)\n self.assertTrue(xff.meanspec.dtype.isnative)\n self.assertTrue(xff.wave.dtype.isnative)","def test_fasta_file(self):\r\n self.assertRaises(IOError, convert_fastaqual_fastq,\r\n self.read_only_output_dir, self.qual_file_path)","def test_filter_sff_file(self):\r\n\r\n try:\r\n fh = open(self.tiny_test)\r\n except IOError:\r\n self.fail(\r\n \"Could not open test file %s. Skipping test\" %\r\n self.tiny_test)\r\n\r\n # With no filters all flowgram should be in out file\r\n flowgrams, header = lazy_parse_sff_handle(fh)\r\n filter_list = []\r\n fd, out_file_name = mkstemp(\r\n prefix=\"test_filter_sff_file\",\r\n suffix=\".sff.txt\")\r\n close(fd)\r\n out_fh = open(out_file_name, \"w\")\r\n l = filter_sff_file(flowgrams, header, filter_list, out_fh)\r\n remove(out_file_name)\r\n fh.close()\r\n self.assertEqual(l, 114)\r\n\r\n # With good filters some should survive\r\n fh = open(self.tiny_test)\r\n flowgrams, header = lazy_parse_sff_handle(fh)\r\n filter_list = [lambda f:within_length(f, 100, 300)]\r\n fd, out_file_name = mkstemp(\r\n prefix=\"test_filter_sff_file\",\r\n suffix=\".sff.txt\")\r\n close(fd)\r\n out_fh = open(out_file_name, \"w\")\r\n l = filter_sff_file(flowgrams, header, filter_list, out_fh)\r\n remove(out_file_name)\r\n fh.close()\r\n self.assertEqual(l, 112)\r\n\r\n # With strong filters nothing should be in\r\n fh = open(self.tiny_test)\r\n flowgrams, header = lazy_parse_sff_handle(fh)\r\n filter_list = [lambda f:within_length(f, 0, 0)]\r\n fd, out_file_name = mkstemp(\r\n prefix=\"test_filter_sff_file\",\r\n suffix=\".sff.txt\")\r\n close(fd)\r\n out_fh = open(out_file_name, \"w\")\r\n l = filter_sff_file(flowgrams, header, filter_list, out_fh)\r\n remove(out_file_name)\r\n self.assertEqual(l, 0)","def test_doubled_file():\n with contextlib.closing(get_test_data('Level2_KFTG_20150430_1419.ar2v')) as infile:\n data = infile.read()\n fobj = BytesIO(data + data)\n f = Level2File(fobj)\n assert len(f.sweeps) == 12","def read(fname):\n f = fabio.open(fname)\n data = f.data\n del f; # close file\n return data","def test_do_not_load_in_child_dir(self, tmp_path):\n nested_directory = tmp_path / os.path.join(\"a\", \"b\", \"c\")\n os.makedirs(nested_directory, exist_ok=True)\n\n # Create a FF in a nested directory\n ForceField(\"openff-1.0.0.offxml\").to_file(\n os.path.join(nested_directory, \"force-field.offxml\")\n )\n\n # Check that the file does not exist in the current working directory.\n assert not os.path.isfile(\"force-field.offxml\")\n\n with pytest.raises(\n OSError, match=\"Source 'force-field.offxml' could not be read.\"\n ):\n ForceField(\"force-field.offxml\")","def seekable(self):\n ...","def test_from_file_fail(self):\n with TemporaryDirectory() as tmp:\n fp = os.path.join(tmp, \"test.txt\")\n open(fp, 'a').close()\n assert os.path.exists(fp)\n with self.assertRaises(TypeError):\n BaseDataClass.from_file(fp)","def test_init_flowgram_file(self):\r\n fh, tmp_filename = init_flowgram_file(n=100, l=400)\r\n self.assert_(exists(tmp_filename))\r\n self.tmp_filename = tmp_filename\r\n fh.close()\r\n result_file_content = list(open(tmp_filename))\r\n\r\n self.assertEqual(result_file_content, [\"100 400\\n\"])","def test_as_file_false(self):\n with TemporaryDirectory() as tmp:\n # define path to file\n fp = os.path.join(tmp, \"asdf.txt\")\n\n # invoke atomic_write with param as_file set to False\n # this should return a temporary file path string\n with atomic_write(fp, as_file=False) as f:\n self.assertIsInstance(f, str)","def test_get_filled_attributes_from_file_non_existent_file(tmp_path):\n assert get_filled_attributes_from_file(tmp_path / \"does not exist\") == frozenset([])","def test_add_read_fail(self):\n file_handler = open(self.test_task_filename, 'w')\n file_handler.write('Mock corrupt data')\n file_handler.close()\n os.chmod(self.test_task_filename, 000)\n\n self.assertRaises(IOError, self.task_storage.add, self.my_task)","def test_noPermission(self):\n log = logfile.LogFile(self.name, self.dir)\n log.write(\"abc\")\n\n # change permissions so rotation would fail\n os.chmod(self.dir, 0555)\n\n # if this succeeds, chmod doesn't restrict us, so we can't\n # do the test\n try:\n f = open(os.path.join(self.dir,\"xxx\"), \"w\")\n except (OSError, IOError):\n pass\n else:\n f.close()\n return\n\n log.rotate() # this should not fail\n\n log.write(\"def\")\n log.flush()\n\n f = log._file\n self.assertEquals(f.tell(), 6)\n f.seek(0, 0)\n self.assertEquals(f.read(), \"abcdef\")\n log.close()","def test_read_not_interested(self):\n try:\n self.reader.read(self.books[2], 0, 0)\n self.fail(\"Readed book not interested\")\n except AssertionError:\n pass","def uninitializedRead(self, address: ghidra.program.model.address.Address, size: int, buf: List[int], bufOffset: int) -> bool:\n ...","def test_open_read(self, remote_mock_dir):\n\n file_path = posixpath.join(remote_mock_dir, \"test.txt\")\n with HdfsHook() as hook:\n with hook.open(file_path) as file_:\n content = file_.read()\n assert content == b\"Test file\\n\"","def test_nonfile(self):\n self.assertEqual(None,readfiles.read_file(\"tests.txt))","def safe_fd(fd):\n toclose = []\n try:\n while fd < 3:\n toclose.append(fd)\n fd = _os.dup(fd)\n finally:\n for dfd in toclose:\n try:\n _os.close(dfd)\n except OSError:\n pass\n return fd","def test_close_stream_first(self):\n z = ZipFile(self.f, 'r')\n stream = z.readstream(FILENAMES[0])\n z.close()\n try:\n stream.read()\n except:\n self.fail(\"Reading stream from closed archive failed!\")\n stream.close()\n # Now the archive should close.\n self.assertIsNone(z._a)\n self.assertTrue(stream.closed)\n self.assertIsNone(z._stream)","def test_bug1003(capfd):\n input_dir = get_input_path('bug1003')\n temp_dir = get_temp_dir_path('bug1003var')\n copytree(input_dir, temp_dir)\n ds_path = os.path.join(temp_dir, 'bug1003.designspace')\n runner(CMD + ['-o', 'd', f'_{ds_path}'])\n captured = capfd.readouterr()\n assert \"The input set requires compatibilization\" in captured.err","def test_read_components_from_rulefile_rulefile_not_specified2(tmp_path):\n with pytest.raises(SystemExit):\n _read_components_from_rulefile()","def test_open_fill(self):","def test_readbadformat(self):\n\n self.assertRaises(ParseError, self.hw, self.badfile)","def test_file_open_bug():\n \n value = Value('test', context, 'reentrant_test', clsmap['file'], data_dir='./cache')\n \n try:\n os.remove(value.namespacemanager.file)\n except OSError:\n pass\n \n value.set_value(\"x\")\n\n f = open(value.namespacemanager.file, 'w')\n f.write(\"BLAH BLAH BLAH\")\n f.close()\n \n # TODO: do we have an assertRaises() in nose to use here ?\n try:\n value.set_value(\"y\")\n assert False\n except:\n pass\n \n _synchronizers.clear()\n context.clear()\n value = Value('test', context, 'reentrant_test', clsmap['file'], data_dir='./cache')\n\n # TODO: do we have an assertRaises() in nose to use here ?\n try:\n value.set_value(\"z\")\n assert False\n except:\n pass","def test_read_EOF2(demo_data):\n\n openeeg = openEDF(demo_data)\n #read 200 samples starting from 100 samples before EOF\n start = max(openeeg.header.samples) - 100\n arr = openeeg.read(start, start + 200)\n assert arr.shape[-1] == 100\n\n openeeg.close()","def readinto(self, buf: bytes, /) -> Optional[int]:","def test_read_0_2_smirnoff(self):\n ForceField(\n get_data_file_path(\n \"test_forcefields/smirnoff99Frosst_reference_0_2_spec.offxml\"\n )\n )","def test_fileDoesNotExist(self):\n fp = FilePath(self.mktemp())\n protocol = self.makeConnectedDccFileReceive(fp.path)\n\n self.allDataReceivedForProtocol(protocol, b\"I <3 Twisted\")\n\n self.assertEqual(fp.getContent(), b\"I <3 Twisted\")","def testTransportReadAll(self):\n trans = TTransport.TMemoryBuffer(self.data)\n trans.readAll(1)\n\n try:\n trans.readAll(10000)\n except EOFError:\n return\n\n self.fail(\"Should have gotten EOFError\")","def close_datafile(fs):\r\n fs.close() # fs is the output from init_datafile\r","def test_qual_file(self):\r\n self.assertRaises(IOError, convert_fastaqual_fastq,\r\n self.fasta_file_path, self.read_only_output_dir)","def testBinaryProtocolAcceleratedEof(self):\n self.eofTestHelper(TBinaryProtocol.TBinaryProtocolAcceleratedFactory())\n self.eofTestHelperStress(TBinaryProtocol.TBinaryProtocolAcceleratedFactory())","def test_read_raw_supported(fname):\n read_raw(fname)\n read_raw(fname, verbose=False)\n raw = read_raw(fname, preload=True)\n assert \"data loaded\" in str(raw)","def test_fortran_reader_notbasic():\n\n tabstr = dedent(\n \"\"\"\n a b\n 1 1.23D4\n 2 5.67D-8\n \"\"\"\n )[1:-1]\n\n t1 = ascii.read(tabstr.split(\"\\n\"), fast_reader={\"exponent_style\": \"D\"})\n\n assert t1[\"b\"].dtype.kind == \"f\"\n\n tabrdb = dedent(\n \"\"\"\n a\\tb\n # A simple RDB table\n N\\tN\n 1\\t 1.23D4\n 2\\t 5.67-008\n \"\"\"\n )[1:-1]\n\n t2 = ascii.read(\n tabrdb.split(\"\\n\"), format=\"rdb\", fast_reader={\"exponent_style\": \"fortran\"}\n )\n\n assert t2[\"b\"].dtype.kind == \"f\"\n\n tabrst = dedent(\n \"\"\"\n = =======\n a b\n = =======\n 1 1.23E4\n 2 5.67E-8\n = =======\n \"\"\"\n )[1:-1]\n\n t3 = ascii.read(tabrst.split(\"\\n\"), format=\"rst\")\n\n assert t3[\"b\"].dtype.kind == \"f\"\n\n t4 = ascii.read(tabrst.split(\"\\n\"), guess=True)\n\n assert t4[\"b\"].dtype.kind == \"f\"\n\n # In the special case of fast_converter=True (the default),\n # incompatibility is ignored\n t5 = ascii.read(tabrst.split(\"\\n\"), format=\"rst\", fast_reader=True)\n\n assert t5[\"b\"].dtype.kind == \"f\"\n\n with pytest.raises(ParameterError):\n ascii.read(tabrst.split(\"\\n\"), format=\"rst\", guess=False, fast_reader=\"force\")\n\n with pytest.raises(ParameterError):\n ascii.read(\n tabrst.split(\"\\n\"),\n format=\"rst\",\n guess=False,\n fast_reader={\"use_fast_converter\": False},\n )\n\n tabrst = tabrst.replace(\"E\", \"D\")\n\n with pytest.raises(ParameterError):\n ascii.read(\n tabrst.split(\"\\n\"),\n format=\"rst\",\n guess=False,\n fast_reader={\"exponent_style\": \"D\"},\n )","def test_corrupt_dataofs(logger):\n packet = layers.packet.Packet(IP(src=\"127.0.0.1\", dst=\"127.0.0.1\")/TCP(sport=2222, dport=3333, seq=100, ack=100, flags=\"S\", dataofs=\"6L\"))\n original = copy.deepcopy(packet)\n tamper = actions.tamper.TamperAction(None, field=\"dataofs\", tamper_type=\"corrupt\")\n\n tamper.tamper(packet, logger)\n\n # Confirm tamper actually corrupted the checksum\n assert packet[TCP].dataofs != \"0\"\n new_value = packet[TCP].dataofs\n\n # Must run this check repeatedly - if a scapy fuzz-ed value is not properly\n # ._fix()-ed, it will return different values each time it's requested\n for _ in range(0, 5):\n assert packet[TCP].dataofs == new_value, \"Corrupted value is not stable\"\n\n # Confirm tamper didn't corrupt anything else in the TCP header\n assert confirm_unchanged(packet, original, TCP, [\"dataofs\"])\n\n # Confirm tamper didn't corrupt anything in the IP header\n assert confirm_unchanged(packet, original, IP, [])","def test_read_0_1_smirnoff(self):\n ForceField(\n get_data_file_path(\n \"test_forcefields/smirnoff99Frosst_reference_0_1_spec.offxml\"\n )\n )","def test_LogReaderReadsZeroLine(self):\n # We don't need any content, just a file path that can be opened.\n with open(self.path, \"w\"):\n pass\n\n reader = logfile.LogReader(self.path)\n self.addCleanup(reader.close)\n self.assertEqual([], reader.readLines(0))","def test_fastaqual_output(self):\r\n self.assertRaises(IOError, convert_fastaqual, self.fasta_file_path,\r\n output_directory=self.read_only_output_dir)","def test_unicode(self):\n name = unicode(os.path.basename(self.cbf_filename))\n obj = fabio.open(self.cbf_filename)\n obj.write(os.path.join(self.tempdir, name))\n other = fabio.open(os.path.join(self.tempdir, name))\n self.assertEqual(abs(obj.data - other.data).max(), 0, \"data are the same\")\n for key in obj.header:\n if key in[ \"filename\", \"X-Binary-Size-Padding\"]:\n continue\n self.assertTrue(key in other.header, \"Key %s is in header\" % key)\n self.assertEqual(obj.header[key], other.header[key], \"value are the same for key %s [%s|%s]\" % (key, obj.header[key], other.header[key]))","def safe_open(fname, mode, buffering=-1):\n # file descriptors\n try:\n return open(fname, mode, buffering=buffering)\n except PermissionError as ex:\n raise xt.XonshError(f\"xonsh: {fname}: permission denied\") from ex\n except FileNotFoundError as ex:\n raise xt.XonshError(f\"xonsh: {fname}: no such file or directory\") from ex\n except Exception as ex:\n raise xt.XonshError(f\"xonsh: {fname}: unable to open file\") from ex","def test_conversion_lowlevel(path):\n gff_file = gff.GFFFile.read(join(data_dir(\"sequence\"), path))\n ref_entries = [entry for entry in gff_file]\n\n gff_file = gff.GFFFile()\n for entry in ref_entries:\n gff_file.append(*entry)\n temp = TemporaryFile(\"w+\")\n gff_file.write(temp)\n\n temp.seek(0)\n gff_file = gff.GFFFile.read(temp)\n temp.close()\n test_entries = [field for field in gff_file]\n assert test_entries == ref_entries","def test_supply_file(self):\n f = open(self.junk_file, 'w')\n f.close()\n self.assertRaises(argparse.ArgumentTypeError, generic.check_path, self.junk_file)","def test_read_0_1_smirff(self):\n ForceField(\n get_data_file_path(\n \"test_forcefields/smirff99Frosst_reference_0_1_spec.offxml\"\n )\n )","def testGetDataStream(self):\n path_spec = path_spec_factory.Factory.NewPathSpec(\n definitions.TYPE_INDICATOR_HFS,\n identifier=self._IDENTIFIER_ANOTHER_FILE,\n location='/a_directory/another_file',\n parent=self._raw_path_spec)\n file_entry = self._file_system.GetFileEntryByPathSpec(path_spec)\n self.assertIsNotNone(file_entry)\n\n data_stream = file_entry.GetDataStream('')\n self.assertIsNotNone(data_stream)\n\n path_spec = path_spec_factory.Factory.NewPathSpec(\n definitions.TYPE_INDICATOR_HFS, identifier=25,\n location='/a_directory/a_resourcefork', parent=self._raw_path_spec)\n file_entry = self._file_system.GetFileEntryByPathSpec(path_spec)\n self.assertIsNotNone(file_entry)\n\n data_stream = file_entry.GetDataStream('rsrc')\n self.assertIsNotNone(data_stream)","def verify_fileobj(fileobj, writable=False):\n\n try:\n data = fileobj.read(0)\n except Exception:\n if not hasattr(fileobj, \"read\"):\n raise ValueError(\"%r not a valid file object\" % fileobj)\n raise ValueError(\"Can't read from file object %r\" % fileobj)\n\n if not isinstance(data, bytes):\n raise ValueError(\n \"file object %r not opened in binary mode\" % fileobj)\n\n if writable:\n try:\n fileobj.write(b\"\")\n except Exception:\n if not hasattr(fileobj, \"write\"):\n raise ValueError(\"%r not a valid file object\" % fileobj)\n raise ValueError(\"Can't write to file object %r\" % fileobj)","def read(self, size=-1):\n ...","def test_prep_sffs_in_dir_no_trim(self):\r\n output_dir = mkdtemp()\r\n gz_output_dir = mkdtemp()\r\n\r\n try:\r\n check_sffinfo()\r\n perform_test = True\r\n except:\r\n perform_test = False\r\n\r\n if perform_test:\r\n prep_sffs_in_dir(self.sff_dir, output_dir, make_flowgram=False,\r\n convert_to_flx=False, use_sfftools=True,\r\n no_trim=True)\r\n\r\n fna_fp = os.path.join(output_dir, 'test.fna')\r\n\r\n self.assertEqual(open(fna_fp).read(), fna_notrim_txt)\r\n\r\n qual_fp = os.path.join(output_dir, 'test.qual')\r\n self.assertEqual(open(qual_fp).read(), qual_notrim_txt)\r\n\r\n self.assertRaises(TypeError, \"gzipped SFF\", prep_sffs_in_dir,\r\n self.gz_sff_dir, gz_output_dir, make_flowgram=False,\r\n convert_to_flx=False, use_sfftools=True,\r\n no_trim=True)\r\n\r\n shutil.rmtree(output_dir)\r\n shutil.rmtree(gz_output_dir)","def test_good_input():\n\n out_file = 'unclustered.fa'\n if os.path.isfile(out_file):\n os.remove(out_file)\n\n try:\n rv, out = getstatusoutput(f'{prg} -c {cdhit} -p {proteins}')\n assert rv == 0\n assert out == ('Wrote 309 of 220,520 unclustered '\n 'proteins to \"unclustered.fa\"')\n\n assert os.path.isfile(out_file)\n\n seqs = list(SeqIO.parse(out_file, 'fasta'))\n\n assert len(seqs) == 309\n finally:\n if os.path.isfile(out_file):\n os.remove(out_file)","def test_fileinuse (self):\t\t\n\t\t# open a file:\n\t\ttestfilepath = os.path.join (self.testfolder, \"fileinuse.txt\")\n\t\tf = open(testfilepath,\"a\") #opens file with name of \"test.txt\"\n\t\tf.write(\"This file is now opened and i'm writting on it \\n\")\n\t\tself.assertEqual (MD.fileinuse(testfilepath), True) # Checks a file that it is beign written.\n\t\tself.assertEqual (MD.folderinuse(self.testfolder), True) # Checks if any file inside the folder is beign used.\n\t\tf.close()\n\t\tself.assertEqual (MD.fileinuse(testfilepath), False) # Cheks a file that it is closed.\n\t\tself.assertEqual (MD.folderinuse(self.testfolder), False)","def read_and_unpack(self, fmt):\n try:\n return unpack(\n self.byte_order + fmt,\n self.read(calcsize(self.byte_order + fmt)))\n except Exception as e:\n if e.args[0].startswith('unpack requires a buffer of'):\n raise EOFError(e)\n else:\n raise"],"string":"[\n \"def test_fileobj_not_closed(self):\\n\\n f = open(self.data('test0.fits'), 'rb')\\n data = fits.getdata(f)\\n assert not f.closed\\n\\n f.seek(0)\\n header = fits.getheader(f)\\n assert not f.closed\",\n \"def test_fileobj_not_closed(self):\\n\\n f = open(self.data(\\\"test0.fits\\\"), \\\"rb\\\")\\n _ = fits.getdata(f)\\n assert not f.closed\\n\\n f.seek(0)\\n _ = fits.getheader(f)\\n assert not f.closed\\n\\n f.close() # Close it now\",\n \"def test_file_readas_missing_file(self):\\n with (self.assertRaises(IOError)):\\n FileReader(self.bogus_path).read_as(\\\"utf-8\\\")\",\n \"def test_file_read_bin_missing_file(self):\\n with (self.assertRaises(IOError)):\\n FileReader(self.bogus_path).read_bin()\",\n \"def test_read_raw_unsupported_multi(fname, tmp_path):\\n fname = tmp_path / fname\\n fname.write_text('')\\n with pytest.raises(RuntimeError, match='Could not read.*using any'):\\n read_raw(fname)\",\n \"def test_file_read_utf8_missing_file(self):\\n with (self.assertRaises(IOError)):\\n FileReader(self.bogus_path).read_utf8()\",\n \"def test_file_readlines_utf8_missing_file(self):\\n with (self.assertRaises(IOError)):\\n FileReader(self.bogus_path).readlines_utf8()\",\n \"def test_read_raw_suggested(fname):\\n with pytest.raises(ValueError, match='Try reading'):\\n read_raw(fname)\",\n \"def test_get_all_read_fail(self):\\n file_handler = open(self.test_task_filename, 'w')\\n file_handler.write('Mock corrupt data')\\n file_handler.close()\\n os.chmod(self.test_task_filename, 000)\\n\\n self.assertRaises(IOError, self.task_storage.get_all)\",\n \"def test_is_not_delicious_file(self):\\r\\n bad_file = StringIO.StringIO()\\r\\n bad_file.write('failing tests please')\\r\\n bad_file.seek(0)\\r\\n\\r\\n self.assertTrue(\\r\\n not DelXMLImporter.can_handle(bad_file),\\r\\n \\\"DelXMLImporter cannot handle this file\\\")\\r\\n\\r\\n bad_file.close()\",\n \"def test_is_not_delicious_file(self):\\r\\n bad_file = StringIO.StringIO()\\r\\n bad_file.write('failing tests please')\\r\\n bad_file.seek(0)\\r\\n\\r\\n self.assertTrue(\\r\\n not DelImporter.can_handle(bad_file),\\r\\n \\\"DelImporter cannot handle this file\\\")\\r\\n\\r\\n bad_file.close()\",\n \"def test_file_read_missing_file(self):\\n with (self.assertRaises(IOError)):\\n FileReader(self.bogus_path).read()\",\n \"def attempt_file_reset(f):\\r\\n if hasattr(f, 'seek'):\\r\\n f.seek(0)\",\n \"def test_read_fail2(self):\\n mod_fn = os.path.join(tests.TEST_DATA_PATH, 'segmentations', 'test_bad_data2.mod')\\n with self.assertRaises(ValueError):\\n modreader.get_data(mod_fn) # missing 'IEOF' end\",\n \"def test_empty_stream(self):\\r\\n mock_file = MockFile([b\\\"\\\"])\\r\\n for _ in BinaryIOStream(mock_file):\\r\\n # This should never happen\\r\\n self.assertFalse(True)\",\n \"def eofTestHelperStress(self, pfactory):\\n # TODO: we should make sure this covers more of the code paths\\n\\n for i in xrange(0, len(self.data) + 1):\\n trans = TTransport.TMemoryBuffer(self.data[0:i])\\n prot = pfactory.getProtocol(trans)\\n try:\\n x = Xtruct()\\n x.read(prot)\\n x.read(prot)\\n x.read(prot)\\n except EOFError:\\n continue\\n self.fail(\\\"Should have gotten an EOFError\\\")\",\n \"def test_fileio(tmp_path):\\n async def aiotests():\\n fio = fileio.FileIO(Path(tmp_path))\\n\\n with pytest.raises(PermissionError):\\n fio.resolve_and_sanitize('../abba123')\\n\\n with pytest.raises(PermissionError):\\n fio.resolve_and_sanitize('/abba123')\\n\\n with pytest.raises(FileNotFoundError):\\n fio.resolve_and_sanitize('abba123', must_exist=True)\\n\\n with pytest.raises(FileNotFoundError):\\n fio.open_and_seek('abba123', 0, for_write=False)\\n\\n with pytest.raises(PermissionError):\\n fio.open_and_seek('../abba123', 0, for_write=False)\\n\\n with pytest.raises(aiohttp.web.HTTPForbidden):\\n await fio.upload_chunk(chunker.FileChunk(path='../abba1234', pos=0, size=123, cmpratio=1, hash='abcdef1234'), None)\\n\\n with pytest.raises(aiohttp.web.HTTPInternalServerError):\\n await fio.upload_chunk(chunker.FileChunk(path=False, pos=0, size=123, cmpratio=1, hash='abcdef1234'), None)\\n\\n assert await fio.copy_chunk_locally(\\n chunker.FileChunk(path='abba1234', pos=0, size=123, cmpratio=1, hash='abcdef1234'),\\n chunker.FileChunk(path='abba1234', pos=0, size=123, cmpratio=1, hash='abcdef1234')) is True\\n\\n with pytest.raises(ValueError):\\n assert await fio.copy_chunk_locally(\\n chunker.FileChunk(path='abba1234', pos=0, size=123, cmpratio=1, hash='abcdef1234'),\\n chunker.FileChunk(path='asdfklna', pos=0, size=123, cmpratio=1, hash='ABABABABAB'))\\n\\n assert fio.try_precreate_large_sparse_file('sparsefiletest.bin', 1234) == fio.resolve_and_sanitize('sparsefiletest.bin').exists()\\n await fio.remove_file_and_paths('sparsefiletest.bin')\\n\\n asyncio.run(aiotests())\",\n \"def test_ioerror_buffer_position(self):\\n bytes = pyamf.encode(u'foo', [1, 2, 3], encoding=pyamf.AMF3).getvalue()\\n\\n self.buf.write(bytes[:-1])\\n self.buf.seek(0)\\n\\n self.decoder.readElement()\\n self.assertEqual(self.buf.tell(), 5)\\n\\n self.assertRaises(IOError, self.decoder.readElement)\\n self.assertEqual(self.buf.tell(), 5)\",\n \"def test_issue_172_1():\\n input_data = 8 * os.urandom(1024)\\n with lz4.frame.open('testfile_small', 'wb') as fp:\\n bytes_written = fp.write(input_data) # noqa: F841\\n\\n with lz4.frame.open('testfile_small', 'rb') as fp:\\n data = fp.read(10)\\n assert len(data) == 10\",\n \"def test_open_by_unnamed_fobj(self):\\n with open(ZIPPATH, 'rb') as zf:\\n with io.FileIO(zf.fileno(), mode='r', closefd=False) as f:\\n self._test_listing_content(f)\",\n \"def test_read_EOF(demo_data):\\n\\n openeeg = openEDF(demo_data)\\n start = max(openeeg.header.samples) + 1\\n arr = openeeg.read(start, start+100)\\n assert arr.size == 0\\n\\n openeeg.close()\",\n \"def test_cantChangeFileMode(self):\\n if runtime.platform.isWindows():\\n name, directory = \\\"NUL\\\", \\\"\\\"\\n expectedPath = \\\"NUL\\\"\\n else:\\n name, directory = \\\"null\\\", \\\"/dev\\\"\\n expectedPath = \\\"/dev/null\\\"\\n\\n log = logfile.LogFile(name, directory, defaultMode=0o555)\\n self.addCleanup(log.close)\\n\\n self.assertEqual(log.path, expectedPath)\\n self.assertEqual(log.defaultMode, 0o555)\",\n \"def test_empty_file(self):\\n with open(os.path.join(test_dir, \\\"empty_file.txt\\\")) as f:\\n for idx, line in enumerate(reverse_readline(f)):\\n raise ValueError(\\\"an empty file is being read!\\\")\",\n \"def test_file_readlines_missing_file(self):\\n with (self.assertRaises(IOError)):\\n FileReader(self.bogus_path).readlines()\",\n \"def rewind(f):\\n\\tf.seek(0)\",\n \"def test_garbage_stream(self):\\r\\n valid: bytes = b\\\"!AIVDM,1,1,,B,B43JRq00LhTWc5VejDI>wwWUoP06,0*29\\\"\\r\\n mock_file = MockFile([b\\\"Foo\\\", b\\\"Bar\\\", b\\\"1337\\\", valid])\\r\\n for msg in BinaryIOStream(mock_file):\\r\\n self.assertEqual(msg.raw, valid)\",\n \"def test_cache_pollution(self):\\n with self._test_checksum_setup(self.tempdir.name) as setupdata:\\n filename, data, expected_checksum = setupdata\\n\\n # corrupt the file\\n with open(os.path.join(self.tempdir.name, filename), \\\"r+b\\\") as fh:\\n fh.seek(0)\\n real_first_byte = fh.read(1).decode(\\\"latin-1\\\")\\n fh.seek(0)\\n fh.write(chr(ord(real_first_byte) ^ 0xff).encode(\\\"latin-1\\\"))\\n\\n with self.assertRaises(ChecksumValidationError):\\n with self.caching_backend.read_contextmanager(filename, expected_checksum) as cm:\\n self.assertEqual(cm.read(), data)\\n\\n # un-corrupt the file\\n with open(os.path.join(self.tempdir.name, filename), \\\"r+b\\\") as fh:\\n fh.seek(0)\\n real_first_byte = fh.read(1).decode(\\\"latin-1\\\")\\n fh.seek(0)\\n fh.write(chr(ord(real_first_byte) ^ 0xff).encode(\\\"latin-1\\\"))\\n\\n with self.caching_backend.read_contextmanager(filename, expected_checksum) as cm:\\n self.assertEqual(cm.read(), data)\",\n \"def test_read_raw_unsupported_single(fname):\\n with pytest.raises(ValueError, match='Unsupported file type'):\\n read_raw(fname)\",\n \"def test_failToOpenLocalFile(self):\\n fp = FilePath(self.mktemp()).child(\\\"child-with-no-existing-parent\\\")\\n\\n self.assertRaises(IOError, self.makeConnectedDccFileReceive, fp.path)\",\n \"def test_find_read_fail(self):\\n file_handler = open(self.test_task_filename, 'w')\\n file_handler.write('Mock corrupt data')\\n file_handler.close()\\n os.chmod(self.test_task_filename, 000)\\n\\n self.assertRaises(IOError, self.task_storage.find, self.my_task)\",\n \"def test_file_read_gzip_missing_file(self):\\n with (self.assertRaises(IOError)):\\n FileReader(self.bogus_path).read_gzip()\",\n \"def open_from(self, f: BinaryIO):\\n raise NotImplementedError\",\n \"def test_empty_file(self):\\n\\n temp = tempfile.NamedTemporaryFile()\\n temp.flush()\\n self.assertRaises(MalformedFileError, NBTFile, temp.name)\",\n \"def rewind(f):\\n f.seek(0)\",\n \"def test_get_read_fail(self):\\n file_handler = open(self.test_key_filename, 'w')\\n file_handler.write('Mock corrupt data')\\n file_handler.close()\\n os.chmod(self.test_key_filename, 000)\\n\\n self.assertRaises(IOError, self.key_gen.get)\",\n \"def read_fd_decode_safely(fd, size=4096):\\n data = os.read(fd.fileno(), size)\\n for _ in range(3):\\n try:\\n return data, data.decode(\\\"utf-8\\\")\\n except UnicodeDecodeError as e:\\n if e.reason != \\\"unexpected end of data\\\":\\n raise\\n data += os.read(fd.fileno(), 1)\\n\\n return data, data.decode(\\\"utf-8\\\")\",\n \"def test_level2_fobj(filename, use_seek):\\n f = get_test_data(filename)\\n if not use_seek:\\n class SeeklessReader:\\n \\\"\\\"\\\"Simulate file-like object access without seek.\\\"\\\"\\\"\\n\\n def __init__(self, f):\\n self._f = f\\n\\n def read(self, n=None):\\n \\\"\\\"\\\"Read bytes.\\\"\\\"\\\"\\n return self._f.read(n)\\n\\n f = SeeklessReader(f)\\n Level2File(f)\",\n \"def test_read_fail1(self):\\n mod_fn = os.path.join(tests.TEST_DATA_PATH, 'segmentations', 'test_bad_data1.mod')\\n with self.assertRaises(ValueError):\\n modreader.get_data(mod_fn) # missing 'IMOD' start\",\n \"def test_no_eof(self):\",\n \"def test_file_unused(self):\\n try:\\n with get_temp_file() as (fd, name):\\n pass\\n except Exception as err:\\n self.fail('Failed with exception \\\"{}\\\"'.format(err))\\n else:\\n file_exists = os.access(name, os.F_OK)\\n self.assertFalse(file_exists)\",\n \"def _barf_if_closed(self):\\n if self.closed:\\n raise ValueError(\\\"I/O operation on closed file\\\")\",\n \"def _check_truncation(self):\\n\\n temp_pos = self._handle.tell()\\n self._handle.seek(-28, 2)\\n eof = self._handle.read()\\n self._handle.seek(temp_pos)\\n if eof == _bgzf_eof:\\n return False\\n else:\\n warnings.BytesWarning('No EOF character found. File may be truncated')\\n return True\",\n \"def test_not_implemented():\\n for not_implemented_ext in ['.mef', '.nwb']:\\n data_path = _TempDir()\\n raw_fname = op.join(data_path, 'test' + not_implemented_ext)\\n with open(raw_fname, 'w', encoding='utf-8'):\\n pass\\n with pytest.raises(ValueError, match=('there is no IO support for '\\n 'this file format yet')):\\n _read_raw(raw_fname)\",\n \"def __init__(self, fname, endian='<', checksum_size=None, debug_level=0):\\n self.endian = endian\\n self.f = open(expanduser(fname), 'rb')\\n self.f.seek(0, 2)\\n self.fsize = self.tell()\\n self.f.seek(0, 0)\\n self.close = self.f.close\\n if checksum_size:\\n pass\\n #self.cs = checksum(self, 0, checksum_size)\\n else:\\n self.cs = checksum_size\\n self.debug_level = debug_level\",\n \"def test_read():\\n f = open('test', mode='r')\\n line = f.read()\\n f.close()\",\n \"def test_fastq_output(self):\\r\\n self.assertRaises(IOError, convert_fastq, self.fasta_file_path,\\r\\n self.qual_file_path, output_directory=self.read_only_output_dir)\",\n \"def _verify_descriptors(self, msg):\\n self.assertTrue(is_writable_file(msg.chlderr))\\n self.assertTrue(is_writable_file(msg.chldout))\\n self.assertTrue(is_writable_file(msg.chldnul))\",\n \"def test_malformed(self):\\n fdesc, fname = tempfile.mkstemp()\\n tfile = os.fdopen(fdesc, 'w')\\n tfile.write(self.file_str2)\\n tfile.close()\\n assert_raises(Exception, grades.writers.GradesFile, fname)\\n os.unlink(fname)\",\n \"def test_noPermission(self):\\n log = logfile.LogFile(self.name, self.dir)\\n self.addCleanup(log.close)\\n log.write(\\\"abc\\\")\\n\\n # change permissions so rotation would fail\\n os.chmod(self.dir, 0o555)\\n\\n # if this succeeds, chmod doesn't restrict us, so we can't\\n # do the test\\n try:\\n f = open(os.path.join(self.dir, \\\"xxx\\\"), \\\"w\\\")\\n except OSError:\\n pass\\n else:\\n f.close()\\n return\\n\\n log.rotate() # this should not fail\\n\\n log.write(\\\"def\\\")\\n log.flush()\\n\\n f = log._file\\n self.assertEqual(f.tell(), 6)\\n f.seek(0, 0)\\n self.assertEqual(f.read(), b\\\"abcdef\\\")\",\n \"def _unblock_open_fifo_operation(self) -> None:\\n if os.path.exists(self._fifo_out_path):\\n open(self._fifo_out_path, 'wb', buffering=0)\\n if os.path.exists(self._fifo_in_path):\\n open(self._fifo_in_path, 'rb', buffering=0)\",\n \"def test_fiberflat_rw(self):\\n from ..fiberflat import FiberFlat\\n from ..io.fiberflat import read_fiberflat, write_fiberflat\\n nspec, nwave, ndiag = 10, 20, 3\\n flat = np.random.uniform(size=(nspec, nwave))\\n ivar = np.random.uniform(size=(nspec, nwave))\\n mask = np.zeros(shape=(nspec, nwave), dtype=int)\\n meanspec = np.random.uniform(size=(nwave,))\\n wave = np.arange(nwave)\\n\\n ff = FiberFlat(wave, flat, ivar, mask, meanspec)\\n\\n write_fiberflat(self.testfile, ff)\\n xff = read_fiberflat(self.testfile)\\n\\n self.assertTrue(np.all(ff.fiberflat.astype('f4').astype('f8') == xff.fiberflat))\\n self.assertTrue(np.all(ff.ivar.astype('f4').astype('f8') == xff.ivar))\\n self.assertTrue(np.all(ff.mask == xff.mask))\\n self.assertTrue(np.all(ff.meanspec.astype('f4').astype('f8') == xff.meanspec))\\n self.assertTrue(np.all(ff.wave.astype('f4').astype('f8') == xff.wave))\\n\\n self.assertTrue(xff.fiberflat.dtype.isnative)\\n self.assertTrue(xff.ivar.dtype.isnative)\\n self.assertTrue(xff.mask.dtype.isnative)\\n self.assertTrue(xff.meanspec.dtype.isnative)\\n self.assertTrue(xff.wave.dtype.isnative)\",\n \"def test_fasta_file(self):\\r\\n self.assertRaises(IOError, convert_fastaqual_fastq,\\r\\n self.read_only_output_dir, self.qual_file_path)\",\n \"def test_filter_sff_file(self):\\r\\n\\r\\n try:\\r\\n fh = open(self.tiny_test)\\r\\n except IOError:\\r\\n self.fail(\\r\\n \\\"Could not open test file %s. Skipping test\\\" %\\r\\n self.tiny_test)\\r\\n\\r\\n # With no filters all flowgram should be in out file\\r\\n flowgrams, header = lazy_parse_sff_handle(fh)\\r\\n filter_list = []\\r\\n fd, out_file_name = mkstemp(\\r\\n prefix=\\\"test_filter_sff_file\\\",\\r\\n suffix=\\\".sff.txt\\\")\\r\\n close(fd)\\r\\n out_fh = open(out_file_name, \\\"w\\\")\\r\\n l = filter_sff_file(flowgrams, header, filter_list, out_fh)\\r\\n remove(out_file_name)\\r\\n fh.close()\\r\\n self.assertEqual(l, 114)\\r\\n\\r\\n # With good filters some should survive\\r\\n fh = open(self.tiny_test)\\r\\n flowgrams, header = lazy_parse_sff_handle(fh)\\r\\n filter_list = [lambda f:within_length(f, 100, 300)]\\r\\n fd, out_file_name = mkstemp(\\r\\n prefix=\\\"test_filter_sff_file\\\",\\r\\n suffix=\\\".sff.txt\\\")\\r\\n close(fd)\\r\\n out_fh = open(out_file_name, \\\"w\\\")\\r\\n l = filter_sff_file(flowgrams, header, filter_list, out_fh)\\r\\n remove(out_file_name)\\r\\n fh.close()\\r\\n self.assertEqual(l, 112)\\r\\n\\r\\n # With strong filters nothing should be in\\r\\n fh = open(self.tiny_test)\\r\\n flowgrams, header = lazy_parse_sff_handle(fh)\\r\\n filter_list = [lambda f:within_length(f, 0, 0)]\\r\\n fd, out_file_name = mkstemp(\\r\\n prefix=\\\"test_filter_sff_file\\\",\\r\\n suffix=\\\".sff.txt\\\")\\r\\n close(fd)\\r\\n out_fh = open(out_file_name, \\\"w\\\")\\r\\n l = filter_sff_file(flowgrams, header, filter_list, out_fh)\\r\\n remove(out_file_name)\\r\\n self.assertEqual(l, 0)\",\n \"def test_doubled_file():\\n with contextlib.closing(get_test_data('Level2_KFTG_20150430_1419.ar2v')) as infile:\\n data = infile.read()\\n fobj = BytesIO(data + data)\\n f = Level2File(fobj)\\n assert len(f.sweeps) == 12\",\n \"def read(fname):\\n f = fabio.open(fname)\\n data = f.data\\n del f; # close file\\n return data\",\n \"def test_do_not_load_in_child_dir(self, tmp_path):\\n nested_directory = tmp_path / os.path.join(\\\"a\\\", \\\"b\\\", \\\"c\\\")\\n os.makedirs(nested_directory, exist_ok=True)\\n\\n # Create a FF in a nested directory\\n ForceField(\\\"openff-1.0.0.offxml\\\").to_file(\\n os.path.join(nested_directory, \\\"force-field.offxml\\\")\\n )\\n\\n # Check that the file does not exist in the current working directory.\\n assert not os.path.isfile(\\\"force-field.offxml\\\")\\n\\n with pytest.raises(\\n OSError, match=\\\"Source 'force-field.offxml' could not be read.\\\"\\n ):\\n ForceField(\\\"force-field.offxml\\\")\",\n \"def seekable(self):\\n ...\",\n \"def test_from_file_fail(self):\\n with TemporaryDirectory() as tmp:\\n fp = os.path.join(tmp, \\\"test.txt\\\")\\n open(fp, 'a').close()\\n assert os.path.exists(fp)\\n with self.assertRaises(TypeError):\\n BaseDataClass.from_file(fp)\",\n \"def test_init_flowgram_file(self):\\r\\n fh, tmp_filename = init_flowgram_file(n=100, l=400)\\r\\n self.assert_(exists(tmp_filename))\\r\\n self.tmp_filename = tmp_filename\\r\\n fh.close()\\r\\n result_file_content = list(open(tmp_filename))\\r\\n\\r\\n self.assertEqual(result_file_content, [\\\"100 400\\\\n\\\"])\",\n \"def test_as_file_false(self):\\n with TemporaryDirectory() as tmp:\\n # define path to file\\n fp = os.path.join(tmp, \\\"asdf.txt\\\")\\n\\n # invoke atomic_write with param as_file set to False\\n # this should return a temporary file path string\\n with atomic_write(fp, as_file=False) as f:\\n self.assertIsInstance(f, str)\",\n \"def test_get_filled_attributes_from_file_non_existent_file(tmp_path):\\n assert get_filled_attributes_from_file(tmp_path / \\\"does not exist\\\") == frozenset([])\",\n \"def test_add_read_fail(self):\\n file_handler = open(self.test_task_filename, 'w')\\n file_handler.write('Mock corrupt data')\\n file_handler.close()\\n os.chmod(self.test_task_filename, 000)\\n\\n self.assertRaises(IOError, self.task_storage.add, self.my_task)\",\n \"def test_noPermission(self):\\n log = logfile.LogFile(self.name, self.dir)\\n log.write(\\\"abc\\\")\\n\\n # change permissions so rotation would fail\\n os.chmod(self.dir, 0555)\\n\\n # if this succeeds, chmod doesn't restrict us, so we can't\\n # do the test\\n try:\\n f = open(os.path.join(self.dir,\\\"xxx\\\"), \\\"w\\\")\\n except (OSError, IOError):\\n pass\\n else:\\n f.close()\\n return\\n\\n log.rotate() # this should not fail\\n\\n log.write(\\\"def\\\")\\n log.flush()\\n\\n f = log._file\\n self.assertEquals(f.tell(), 6)\\n f.seek(0, 0)\\n self.assertEquals(f.read(), \\\"abcdef\\\")\\n log.close()\",\n \"def test_read_not_interested(self):\\n try:\\n self.reader.read(self.books[2], 0, 0)\\n self.fail(\\\"Readed book not interested\\\")\\n except AssertionError:\\n pass\",\n \"def uninitializedRead(self, address: ghidra.program.model.address.Address, size: int, buf: List[int], bufOffset: int) -> bool:\\n ...\",\n \"def test_open_read(self, remote_mock_dir):\\n\\n file_path = posixpath.join(remote_mock_dir, \\\"test.txt\\\")\\n with HdfsHook() as hook:\\n with hook.open(file_path) as file_:\\n content = file_.read()\\n assert content == b\\\"Test file\\\\n\\\"\",\n \"def test_nonfile(self):\\n self.assertEqual(None,readfiles.read_file(\\\"tests.txt))\",\n \"def safe_fd(fd):\\n toclose = []\\n try:\\n while fd < 3:\\n toclose.append(fd)\\n fd = _os.dup(fd)\\n finally:\\n for dfd in toclose:\\n try:\\n _os.close(dfd)\\n except OSError:\\n pass\\n return fd\",\n \"def test_close_stream_first(self):\\n z = ZipFile(self.f, 'r')\\n stream = z.readstream(FILENAMES[0])\\n z.close()\\n try:\\n stream.read()\\n except:\\n self.fail(\\\"Reading stream from closed archive failed!\\\")\\n stream.close()\\n # Now the archive should close.\\n self.assertIsNone(z._a)\\n self.assertTrue(stream.closed)\\n self.assertIsNone(z._stream)\",\n \"def test_bug1003(capfd):\\n input_dir = get_input_path('bug1003')\\n temp_dir = get_temp_dir_path('bug1003var')\\n copytree(input_dir, temp_dir)\\n ds_path = os.path.join(temp_dir, 'bug1003.designspace')\\n runner(CMD + ['-o', 'd', f'_{ds_path}'])\\n captured = capfd.readouterr()\\n assert \\\"The input set requires compatibilization\\\" in captured.err\",\n \"def test_read_components_from_rulefile_rulefile_not_specified2(tmp_path):\\n with pytest.raises(SystemExit):\\n _read_components_from_rulefile()\",\n \"def test_open_fill(self):\",\n \"def test_readbadformat(self):\\n\\n self.assertRaises(ParseError, self.hw, self.badfile)\",\n \"def test_file_open_bug():\\n \\n value = Value('test', context, 'reentrant_test', clsmap['file'], data_dir='./cache')\\n \\n try:\\n os.remove(value.namespacemanager.file)\\n except OSError:\\n pass\\n \\n value.set_value(\\\"x\\\")\\n\\n f = open(value.namespacemanager.file, 'w')\\n f.write(\\\"BLAH BLAH BLAH\\\")\\n f.close()\\n \\n # TODO: do we have an assertRaises() in nose to use here ?\\n try:\\n value.set_value(\\\"y\\\")\\n assert False\\n except:\\n pass\\n \\n _synchronizers.clear()\\n context.clear()\\n value = Value('test', context, 'reentrant_test', clsmap['file'], data_dir='./cache')\\n\\n # TODO: do we have an assertRaises() in nose to use here ?\\n try:\\n value.set_value(\\\"z\\\")\\n assert False\\n except:\\n pass\",\n \"def test_read_EOF2(demo_data):\\n\\n openeeg = openEDF(demo_data)\\n #read 200 samples starting from 100 samples before EOF\\n start = max(openeeg.header.samples) - 100\\n arr = openeeg.read(start, start + 200)\\n assert arr.shape[-1] == 100\\n\\n openeeg.close()\",\n \"def readinto(self, buf: bytes, /) -> Optional[int]:\",\n \"def test_read_0_2_smirnoff(self):\\n ForceField(\\n get_data_file_path(\\n \\\"test_forcefields/smirnoff99Frosst_reference_0_2_spec.offxml\\\"\\n )\\n )\",\n \"def test_fileDoesNotExist(self):\\n fp = FilePath(self.mktemp())\\n protocol = self.makeConnectedDccFileReceive(fp.path)\\n\\n self.allDataReceivedForProtocol(protocol, b\\\"I <3 Twisted\\\")\\n\\n self.assertEqual(fp.getContent(), b\\\"I <3 Twisted\\\")\",\n \"def testTransportReadAll(self):\\n trans = TTransport.TMemoryBuffer(self.data)\\n trans.readAll(1)\\n\\n try:\\n trans.readAll(10000)\\n except EOFError:\\n return\\n\\n self.fail(\\\"Should have gotten EOFError\\\")\",\n \"def close_datafile(fs):\\r\\n fs.close() # fs is the output from init_datafile\\r\",\n \"def test_qual_file(self):\\r\\n self.assertRaises(IOError, convert_fastaqual_fastq,\\r\\n self.fasta_file_path, self.read_only_output_dir)\",\n \"def testBinaryProtocolAcceleratedEof(self):\\n self.eofTestHelper(TBinaryProtocol.TBinaryProtocolAcceleratedFactory())\\n self.eofTestHelperStress(TBinaryProtocol.TBinaryProtocolAcceleratedFactory())\",\n \"def test_read_raw_supported(fname):\\n read_raw(fname)\\n read_raw(fname, verbose=False)\\n raw = read_raw(fname, preload=True)\\n assert \\\"data loaded\\\" in str(raw)\",\n \"def test_fortran_reader_notbasic():\\n\\n tabstr = dedent(\\n \\\"\\\"\\\"\\n a b\\n 1 1.23D4\\n 2 5.67D-8\\n \\\"\\\"\\\"\\n )[1:-1]\\n\\n t1 = ascii.read(tabstr.split(\\\"\\\\n\\\"), fast_reader={\\\"exponent_style\\\": \\\"D\\\"})\\n\\n assert t1[\\\"b\\\"].dtype.kind == \\\"f\\\"\\n\\n tabrdb = dedent(\\n \\\"\\\"\\\"\\n a\\\\tb\\n # A simple RDB table\\n N\\\\tN\\n 1\\\\t 1.23D4\\n 2\\\\t 5.67-008\\n \\\"\\\"\\\"\\n )[1:-1]\\n\\n t2 = ascii.read(\\n tabrdb.split(\\\"\\\\n\\\"), format=\\\"rdb\\\", fast_reader={\\\"exponent_style\\\": \\\"fortran\\\"}\\n )\\n\\n assert t2[\\\"b\\\"].dtype.kind == \\\"f\\\"\\n\\n tabrst = dedent(\\n \\\"\\\"\\\"\\n = =======\\n a b\\n = =======\\n 1 1.23E4\\n 2 5.67E-8\\n = =======\\n \\\"\\\"\\\"\\n )[1:-1]\\n\\n t3 = ascii.read(tabrst.split(\\\"\\\\n\\\"), format=\\\"rst\\\")\\n\\n assert t3[\\\"b\\\"].dtype.kind == \\\"f\\\"\\n\\n t4 = ascii.read(tabrst.split(\\\"\\\\n\\\"), guess=True)\\n\\n assert t4[\\\"b\\\"].dtype.kind == \\\"f\\\"\\n\\n # In the special case of fast_converter=True (the default),\\n # incompatibility is ignored\\n t5 = ascii.read(tabrst.split(\\\"\\\\n\\\"), format=\\\"rst\\\", fast_reader=True)\\n\\n assert t5[\\\"b\\\"].dtype.kind == \\\"f\\\"\\n\\n with pytest.raises(ParameterError):\\n ascii.read(tabrst.split(\\\"\\\\n\\\"), format=\\\"rst\\\", guess=False, fast_reader=\\\"force\\\")\\n\\n with pytest.raises(ParameterError):\\n ascii.read(\\n tabrst.split(\\\"\\\\n\\\"),\\n format=\\\"rst\\\",\\n guess=False,\\n fast_reader={\\\"use_fast_converter\\\": False},\\n )\\n\\n tabrst = tabrst.replace(\\\"E\\\", \\\"D\\\")\\n\\n with pytest.raises(ParameterError):\\n ascii.read(\\n tabrst.split(\\\"\\\\n\\\"),\\n format=\\\"rst\\\",\\n guess=False,\\n fast_reader={\\\"exponent_style\\\": \\\"D\\\"},\\n )\",\n \"def test_corrupt_dataofs(logger):\\n packet = layers.packet.Packet(IP(src=\\\"127.0.0.1\\\", dst=\\\"127.0.0.1\\\")/TCP(sport=2222, dport=3333, seq=100, ack=100, flags=\\\"S\\\", dataofs=\\\"6L\\\"))\\n original = copy.deepcopy(packet)\\n tamper = actions.tamper.TamperAction(None, field=\\\"dataofs\\\", tamper_type=\\\"corrupt\\\")\\n\\n tamper.tamper(packet, logger)\\n\\n # Confirm tamper actually corrupted the checksum\\n assert packet[TCP].dataofs != \\\"0\\\"\\n new_value = packet[TCP].dataofs\\n\\n # Must run this check repeatedly - if a scapy fuzz-ed value is not properly\\n # ._fix()-ed, it will return different values each time it's requested\\n for _ in range(0, 5):\\n assert packet[TCP].dataofs == new_value, \\\"Corrupted value is not stable\\\"\\n\\n # Confirm tamper didn't corrupt anything else in the TCP header\\n assert confirm_unchanged(packet, original, TCP, [\\\"dataofs\\\"])\\n\\n # Confirm tamper didn't corrupt anything in the IP header\\n assert confirm_unchanged(packet, original, IP, [])\",\n \"def test_read_0_1_smirnoff(self):\\n ForceField(\\n get_data_file_path(\\n \\\"test_forcefields/smirnoff99Frosst_reference_0_1_spec.offxml\\\"\\n )\\n )\",\n \"def test_LogReaderReadsZeroLine(self):\\n # We don't need any content, just a file path that can be opened.\\n with open(self.path, \\\"w\\\"):\\n pass\\n\\n reader = logfile.LogReader(self.path)\\n self.addCleanup(reader.close)\\n self.assertEqual([], reader.readLines(0))\",\n \"def test_fastaqual_output(self):\\r\\n self.assertRaises(IOError, convert_fastaqual, self.fasta_file_path,\\r\\n output_directory=self.read_only_output_dir)\",\n \"def test_unicode(self):\\n name = unicode(os.path.basename(self.cbf_filename))\\n obj = fabio.open(self.cbf_filename)\\n obj.write(os.path.join(self.tempdir, name))\\n other = fabio.open(os.path.join(self.tempdir, name))\\n self.assertEqual(abs(obj.data - other.data).max(), 0, \\\"data are the same\\\")\\n for key in obj.header:\\n if key in[ \\\"filename\\\", \\\"X-Binary-Size-Padding\\\"]:\\n continue\\n self.assertTrue(key in other.header, \\\"Key %s is in header\\\" % key)\\n self.assertEqual(obj.header[key], other.header[key], \\\"value are the same for key %s [%s|%s]\\\" % (key, obj.header[key], other.header[key]))\",\n \"def safe_open(fname, mode, buffering=-1):\\n # file descriptors\\n try:\\n return open(fname, mode, buffering=buffering)\\n except PermissionError as ex:\\n raise xt.XonshError(f\\\"xonsh: {fname}: permission denied\\\") from ex\\n except FileNotFoundError as ex:\\n raise xt.XonshError(f\\\"xonsh: {fname}: no such file or directory\\\") from ex\\n except Exception as ex:\\n raise xt.XonshError(f\\\"xonsh: {fname}: unable to open file\\\") from ex\",\n \"def test_conversion_lowlevel(path):\\n gff_file = gff.GFFFile.read(join(data_dir(\\\"sequence\\\"), path))\\n ref_entries = [entry for entry in gff_file]\\n\\n gff_file = gff.GFFFile()\\n for entry in ref_entries:\\n gff_file.append(*entry)\\n temp = TemporaryFile(\\\"w+\\\")\\n gff_file.write(temp)\\n\\n temp.seek(0)\\n gff_file = gff.GFFFile.read(temp)\\n temp.close()\\n test_entries = [field for field in gff_file]\\n assert test_entries == ref_entries\",\n \"def test_supply_file(self):\\n f = open(self.junk_file, 'w')\\n f.close()\\n self.assertRaises(argparse.ArgumentTypeError, generic.check_path, self.junk_file)\",\n \"def test_read_0_1_smirff(self):\\n ForceField(\\n get_data_file_path(\\n \\\"test_forcefields/smirff99Frosst_reference_0_1_spec.offxml\\\"\\n )\\n )\",\n \"def testGetDataStream(self):\\n path_spec = path_spec_factory.Factory.NewPathSpec(\\n definitions.TYPE_INDICATOR_HFS,\\n identifier=self._IDENTIFIER_ANOTHER_FILE,\\n location='/a_directory/another_file',\\n parent=self._raw_path_spec)\\n file_entry = self._file_system.GetFileEntryByPathSpec(path_spec)\\n self.assertIsNotNone(file_entry)\\n\\n data_stream = file_entry.GetDataStream('')\\n self.assertIsNotNone(data_stream)\\n\\n path_spec = path_spec_factory.Factory.NewPathSpec(\\n definitions.TYPE_INDICATOR_HFS, identifier=25,\\n location='/a_directory/a_resourcefork', parent=self._raw_path_spec)\\n file_entry = self._file_system.GetFileEntryByPathSpec(path_spec)\\n self.assertIsNotNone(file_entry)\\n\\n data_stream = file_entry.GetDataStream('rsrc')\\n self.assertIsNotNone(data_stream)\",\n \"def verify_fileobj(fileobj, writable=False):\\n\\n try:\\n data = fileobj.read(0)\\n except Exception:\\n if not hasattr(fileobj, \\\"read\\\"):\\n raise ValueError(\\\"%r not a valid file object\\\" % fileobj)\\n raise ValueError(\\\"Can't read from file object %r\\\" % fileobj)\\n\\n if not isinstance(data, bytes):\\n raise ValueError(\\n \\\"file object %r not opened in binary mode\\\" % fileobj)\\n\\n if writable:\\n try:\\n fileobj.write(b\\\"\\\")\\n except Exception:\\n if not hasattr(fileobj, \\\"write\\\"):\\n raise ValueError(\\\"%r not a valid file object\\\" % fileobj)\\n raise ValueError(\\\"Can't write to file object %r\\\" % fileobj)\",\n \"def read(self, size=-1):\\n ...\",\n \"def test_prep_sffs_in_dir_no_trim(self):\\r\\n output_dir = mkdtemp()\\r\\n gz_output_dir = mkdtemp()\\r\\n\\r\\n try:\\r\\n check_sffinfo()\\r\\n perform_test = True\\r\\n except:\\r\\n perform_test = False\\r\\n\\r\\n if perform_test:\\r\\n prep_sffs_in_dir(self.sff_dir, output_dir, make_flowgram=False,\\r\\n convert_to_flx=False, use_sfftools=True,\\r\\n no_trim=True)\\r\\n\\r\\n fna_fp = os.path.join(output_dir, 'test.fna')\\r\\n\\r\\n self.assertEqual(open(fna_fp).read(), fna_notrim_txt)\\r\\n\\r\\n qual_fp = os.path.join(output_dir, 'test.qual')\\r\\n self.assertEqual(open(qual_fp).read(), qual_notrim_txt)\\r\\n\\r\\n self.assertRaises(TypeError, \\\"gzipped SFF\\\", prep_sffs_in_dir,\\r\\n self.gz_sff_dir, gz_output_dir, make_flowgram=False,\\r\\n convert_to_flx=False, use_sfftools=True,\\r\\n no_trim=True)\\r\\n\\r\\n shutil.rmtree(output_dir)\\r\\n shutil.rmtree(gz_output_dir)\",\n \"def test_good_input():\\n\\n out_file = 'unclustered.fa'\\n if os.path.isfile(out_file):\\n os.remove(out_file)\\n\\n try:\\n rv, out = getstatusoutput(f'{prg} -c {cdhit} -p {proteins}')\\n assert rv == 0\\n assert out == ('Wrote 309 of 220,520 unclustered '\\n 'proteins to \\\"unclustered.fa\\\"')\\n\\n assert os.path.isfile(out_file)\\n\\n seqs = list(SeqIO.parse(out_file, 'fasta'))\\n\\n assert len(seqs) == 309\\n finally:\\n if os.path.isfile(out_file):\\n os.remove(out_file)\",\n \"def test_fileinuse (self):\\t\\t\\n\\t\\t# open a file:\\n\\t\\ttestfilepath = os.path.join (self.testfolder, \\\"fileinuse.txt\\\")\\n\\t\\tf = open(testfilepath,\\\"a\\\") #opens file with name of \\\"test.txt\\\"\\n\\t\\tf.write(\\\"This file is now opened and i'm writting on it \\\\n\\\")\\n\\t\\tself.assertEqual (MD.fileinuse(testfilepath), True) # Checks a file that it is beign written.\\n\\t\\tself.assertEqual (MD.folderinuse(self.testfolder), True) # Checks if any file inside the folder is beign used.\\n\\t\\tf.close()\\n\\t\\tself.assertEqual (MD.fileinuse(testfilepath), False) # Cheks a file that it is closed.\\n\\t\\tself.assertEqual (MD.folderinuse(self.testfolder), False)\",\n \"def read_and_unpack(self, fmt):\\n try:\\n return unpack(\\n self.byte_order + fmt,\\n self.read(calcsize(self.byte_order + fmt)))\\n except Exception as e:\\n if e.args[0].startswith('unpack requires a buffer of'):\\n raise EOFError(e)\\n else:\\n raise\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6067853","0.59570915","0.5916047","0.5873482","0.5731206","0.57067436","0.5683966","0.5675375","0.5667967","0.5606461","0.5593845","0.557636","0.556104","0.5553911","0.55134106","0.5493101","0.5419356","0.5418688","0.5415278","0.5410945","0.53708446","0.53554213","0.5353923","0.5341025","0.5335815","0.5308719","0.5305879","0.529503","0.5286936","0.52552974","0.52549446","0.522892","0.522241","0.52190894","0.5208856","0.519914","0.51810575","0.51706123","0.5170023","0.5160514","0.5157703","0.51474035","0.51467794","0.51281923","0.5126071","0.5094816","0.5073266","0.50692946","0.5055498","0.5044338","0.5038003","0.50298226","0.50290805","0.5028495","0.50222665","0.50205314","0.5020005","0.50121886","0.5010824","0.49968317","0.4980761","0.49775398","0.4975638","0.49726763","0.49697733","0.49649665","0.49615636","0.49597025","0.49581894","0.4937652","0.49274033","0.49250996","0.49224308","0.49157324","0.49020436","0.4899269","0.48950526","0.48834905","0.48825037","0.486239","0.48560664","0.48537058","0.48506728","0.4850396","0.48503083","0.48493025","0.48431367","0.48429972","0.48422137","0.48411658","0.48378643","0.48365957","0.48299414","0.48230642","0.48139456","0.48126745","0.48100168","0.4807779","0.48005205","0.47998807"],"string":"[\n \"0.6067853\",\n \"0.59570915\",\n \"0.5916047\",\n \"0.5873482\",\n \"0.5731206\",\n \"0.57067436\",\n \"0.5683966\",\n \"0.5675375\",\n \"0.5667967\",\n \"0.5606461\",\n \"0.5593845\",\n \"0.557636\",\n \"0.556104\",\n \"0.5553911\",\n \"0.55134106\",\n \"0.5493101\",\n \"0.5419356\",\n \"0.5418688\",\n \"0.5415278\",\n \"0.5410945\",\n \"0.53708446\",\n \"0.53554213\",\n \"0.5353923\",\n \"0.5341025\",\n \"0.5335815\",\n \"0.5308719\",\n \"0.5305879\",\n \"0.529503\",\n \"0.5286936\",\n \"0.52552974\",\n \"0.52549446\",\n \"0.522892\",\n \"0.522241\",\n \"0.52190894\",\n \"0.5208856\",\n \"0.519914\",\n \"0.51810575\",\n \"0.51706123\",\n \"0.5170023\",\n \"0.5160514\",\n \"0.5157703\",\n \"0.51474035\",\n \"0.51467794\",\n \"0.51281923\",\n \"0.5126071\",\n \"0.5094816\",\n \"0.5073266\",\n \"0.50692946\",\n \"0.5055498\",\n \"0.5044338\",\n \"0.5038003\",\n \"0.50298226\",\n \"0.50290805\",\n \"0.5028495\",\n \"0.50222665\",\n \"0.50205314\",\n \"0.5020005\",\n \"0.50121886\",\n \"0.5010824\",\n \"0.49968317\",\n \"0.4980761\",\n \"0.49775398\",\n \"0.4975638\",\n \"0.49726763\",\n \"0.49697733\",\n \"0.49649665\",\n \"0.49615636\",\n \"0.49597025\",\n \"0.49581894\",\n \"0.4937652\",\n \"0.49274033\",\n \"0.49250996\",\n \"0.49224308\",\n \"0.49157324\",\n \"0.49020436\",\n \"0.4899269\",\n \"0.48950526\",\n \"0.48834905\",\n \"0.48825037\",\n \"0.486239\",\n \"0.48560664\",\n \"0.48537058\",\n \"0.48506728\",\n \"0.4850396\",\n \"0.48503083\",\n \"0.48493025\",\n \"0.48431367\",\n \"0.48429972\",\n \"0.48422137\",\n \"0.48411658\",\n \"0.48378643\",\n \"0.48365957\",\n \"0.48299414\",\n \"0.48230642\",\n \"0.48139456\",\n \"0.48126745\",\n \"0.48100168\",\n \"0.4807779\",\n \"0.48005205\",\n \"0.47998807\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.48357132"},"document_rank":{"kind":"string","value":"92"}}},{"rowIdx":492,"cells":{"query":{"kind":"string","value":"Tests gotoField if there is a mismatch between MCP and guider."},"document":{"kind":"string","value":"def test_goto_field_cartridge_mismatch(self):\n\n sopTester.updateModel('guider', TestHelper.guiderState['bossLoaded'])\n\n mcpState = TestHelper.mcpState['boss_science']\n mcpState.update({'instrumentNum': [15]})\n sopTester.updateModel('mcp', mcpState)\n\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n\n masterThread.goto_field(self.cmd, cmdState, myGlobals.actorState)\n self._check_cmd(0, 14, 0, 0, finish=True, didFail=True)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_goto_field_apogee_no_guider(self):\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doGuider = False\n self._goto_feld_apogee(3, 11, 0, 0, cmdState)","def test_goto_field_apogee(self):\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n self._goto_feld_apogee(13, 46, 0, 0, cmdState)","def test_goto_field_boss_flat_on_fails(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n self.cmd.failOn = 'mcp ff.on'\n self._goto_field_boss(16, 71, 0, 1, cmdState, didFail=True, finish=True)","def test_goto_field_boss_guider(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n sopTester.updateModel('guider', TestHelper.guiderState['guiderOnDecenter'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doSlew = False\n cmdState.doHartmann = False\n cmdState.doCalibs = False\n cmdState.arcTime = 0\n cmdState.flatTime = 0\n self._goto_field_boss(9, 37, 0, 0, cmdState)","def test_goto_field_apogee_no_slew(self):\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doSlew = False\n self._goto_feld_apogee(9, 37, 0, 0, cmdState)","def test_goto_field_boss_ffs_open_fails(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n self.cmd.failOn = 'mcp ffs.open'\n self._goto_field_boss(21, 102, 1, 1, cmdState, didFail=True, finish=True)","def test_goto_field_apogee_no_slew_decenter_off(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n sopTester.updateModel('guider', TestHelper.guiderState['guiderOnDecenter'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doSlew = False\n self._goto_feld_apogee(9, 37, 0, 0, cmdState)","def test_goto_field_boss_hartmann_blue_fails(self):\n\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n sopTester.updateModel('hartmann', TestHelper.hartmannState['blue_fails'])\n\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n\n self._goto_field_boss(12, 37, 0, 0, cmdState, didFail=True, finish=True)","def test_goto_field_apogee_bypass_gangToCart(self):\n self._prep_bypass('gangToCart', clear=True)\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n self._goto_feld_apogee(13, 44, 4, 0, cmdState)","def test_goto_field_boss_calibs(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doSlew = False\n cmdState.doHartmann = False\n cmdState.doGuider = False\n self._goto_field_boss(10, 57, 0, 0, cmdState)","def test_goto_field_apogee_no_slew_shutter_open(self):\n sopTester.updateModel('apogee', TestHelper.apogeeState['B_open'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doSlew = False\n self._goto_feld_apogee(10, 37, 0, 0, cmdState)","def test_defining_only_or_defer_on_nonexistant_fields_fails(self):","def test_goto_field_boss_slew(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doGuider = False\n cmdState.doHartmann = False\n cmdState.doCalibs = False\n cmdState.arcTime = 0\n cmdState.flatTime = 0\n self._goto_field_boss(3, 26, 0, 0, cmdState)","def _validator_target(self, field, value):\n if not REG.match(value):\n self._error(field, \"{} is not a valid target\".format(value))","def verifyField(self, pv, field, reference):\n full_pv = pv + \".\" + field\n if (caget(full_pv) != reference):\n msg = \"ERROR: \" + full_pv + \" not equal to \" + str(reference)\n raise Exception(__name__ + msg)\n\n return self.__g.SUCCESS","def test_mutate_field(self):\n # Test adding a field\n with self.assertRaises(ValueError):\n self.email.add_field('', '')\n\n self.email.add_field(self.key, self.regex)\n\n found_key = False\n found_regex = r''\n for field in self.email.fields:\n if field['key'] == self.key:\n found_key = True\n found_regex = field['regex']\n\n self.assertTrue(found_key)\n self.assertEqual(found_regex, self.regex)\n\n # Test getting a field\n with self.assertRaises(LookupError):\n self.email.get_field('')\n\n field = self.email.get_field(self.key)\n self.assertEqual(\n field, {'key': self.key, 'regex': self.regex, 'value': []})\n\n # Test removing a field\n with self.assertRaises(LookupError):\n self.email.remove_field('')\n\n self.email.remove_field(self.key)\n\n found_key = False\n found_regex = r''\n for field in self.email.fields:\n if field['key'] == self.key:\n found_key = True\n found_regex = field['regex']\n\n self.assertFalse(found_key)\n self.assertNotEqual(found_regex, self.regex)","def test_goto_field_boss_hartmann(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doSlew = False\n cmdState.doCalibs = False\n cmdState.arcTime = 0\n cmdState.flatTime = 0\n cmdState.doGuider = False\n self._goto_field_boss(5, 29, 0, 0, cmdState)","def test_invalid_field_access(self):\r\n out = self.c.post(self.url, {'op': 'delete hints', 'field': 'all your private data'})\r\n print out\r\n self.assertTrue('an invalid field was accessed' in out.content)","def test_field_id_lt(self):\n field = '<6'\n ref_idx = [0]\n self.res=self.run_task(infile=self.rawfile,field=field,calmode=self.calmode,outfile=self.outname,outform='ASAP')\n self.assertEqual(self.res,None,\n msg='Any error occurred during calibration')\n self._compare_with_analytic(self.outname, self.line, self.baseline, ref_idx)","def test_51(self):\n assert 'False' == Api.requestBlock('test-51', CustomFields=True)","def test_field_id_gt(self):\n field = '>7'\n ref_idx = [3]\n self.res=self.run_task(infile=self.rawfile,field=field,calmode=self.calmode,outfile=self.outname,outform='ASAP')\n self.assertEqual(self.res,None,\n msg='Any error occurred during calibration')\n self._compare_with_analytic(self.outname, self.line, self.baseline, ref_idx)","def test_select_field():","def ask_for_field(self, row, col):\n field = self.map.fields[row][col]\n # return the field kind, team, and if there is an entity or not\n return field.passable, field.team, field.entity is not None","def checkField(fieldset, text=True):\n if text:\n print \"\\nFieldset contains the following fields:\"\n for i in range(len(fieldset.fields)):\n print fieldset.fields[i].name\n\n ulon = fieldset.U.grid.lon\n ulat = fieldset.U.grid.lat\n udep = fieldset.U.grid.depth\n vlon = fieldset.V.grid.lon\n vlat = fieldset.V.grid.lat\n vdep = fieldset.V.grid.depth\n\n if text:\n if np.all(ulon == vlon):\n print \"longitudes are the same for U and V\"\n else:\n print \"longitudes are not the same for U and V. Note that not all functions will work as intended.\"\n if np.all(ulat == vlat):\n print \"latitudes are the same for U and V\"\n else:\n print \"latitudes are not the same for U and V. Note that not all functions will work as intended.\"\n if np.all(udep == vdep):\n print \"depths are the same for U and V\"\n else:\n print \"depths are not the same for U and V. Note that not all functions will work as intended.\"\n\n return np.all(ulon == vlon) and np.all(ulat == vlat) and np.all(udep == vdep)","def check_field_name(field_name):\n\n error_checking.assert_is_string(field_name)\n if field_name in ALL_PREDICTOR_NAMES + ALL_TARGET_NAMES:\n return\n\n error_string = (\n '\\nField \"{0:s}\" is not valid predictor or target variable. Valid '\n 'options listed below:\\n{1:s}'\n ).format(field_name, str(ALL_PREDICTOR_NAMES + ALL_TARGET_NAMES))\n\n raise ValueError(error_string)","def _is_ifgoto(self, words):\n if words[0] == 'if-goto':\n if len(words) != 2:\n raise SyntaxError(\"File line {}: Invalid number of arguments for C_IFGOTO command.\".format(self._file_line))\n return True\n else:\n return False","def test_02_visit_again(self):","def test_get_critical_from_existing_fields(self):\n name = 'generic_field'\n opts = {'names': (name, ), 'alt_field': '', 'computed': False}\n expected_field = self.form.fields.get(name, None)\n actual_name, actual_field = self.form.get_critical_field(opts['names'])\n self.assertEqual(name, actual_name)\n self.assertEqual(expected_field, actual_field)","def assert_known_field(self, name):\n if not (name == self.id_field_name or self.is_known_field(name)):\n raise ChipsError(\"Unknown field in model %s [%s]\", self.__class__.__name__, name)","def check():","def _is_goto(self, words):\n if words[0] == 'goto':\n if len(words) != 2:\n raise SyntaxError(\"File line {}: Invalid number of arguments for C_GOTO command.\".format(self._file_line))\n return True\n else:\n return False","def test_field_rules():","def test(self):\n self.build()\n exe = self.getBuildArtifact(\"a.out\")\n self.runCmd(\"file \" + exe, CURRENT_EXECUTABLE_SET)\n\n lldbutil.run_to_source_breakpoint(\n self, '// Breakpoint for bitfield', lldb.SBFileSpec(\"main.c\"))\n\n self.expect(\"fr var a\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = A$'])\n self.expect(\"fr var b\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = B$'])\n self.expect(\"fr var c\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = C$'])\n self.expect(\"fr var ab\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = AB$'])\n self.expect(\"fr var ac\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = A | C$'])\n self.expect(\"fr var all\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = ALL$'])\n # Test that an enum that doesn't match the heuristic we use in\n # ClangASTContext::DumpEnumValue, gets printed as a raw integer.\n self.expect(\"fr var omega\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = 7$'])\n # Test the behavior in case have a variable of a type considered\n # 'bitfield' by the heuristic, but the value isn't actually fully\n # covered by the enumerators.\n self.expect(\"p (enum bitfield)nonsense\", DATA_TYPES_DISPLAYED_CORRECTLY,\n patterns=[' = B | C | 0x10$'])\n\n # Break inside the main.\n bkpt_id = lldbutil.run_break_set_by_file_and_line(\n self, \"main.c\", self.line, num_expected_locations=1, loc_exact=True)\n self.runCmd(\"c\", RUN_SUCCEEDED)\n\n # The stop reason of the thread should be breakpoint.\n self.expect(\"thread list\", STOPPED_DUE_TO_BREAKPOINT,\n substrs=['stopped',\n 'stop reason = breakpoint'])\n\n # The breakpoint should have a hit count of 1.\n self.expect(\"breakpoint list -f\", BREAKPOINT_HIT_ONCE,\n substrs=[' resolved, hit count = 1'])\n\n # Look up information about the 'days' enum type.\n # Check for correct display.\n self.expect(\"image lookup -t days\", DATA_TYPES_DISPLAYED_CORRECTLY,\n substrs=['enum days {',\n 'Monday',\n 'Tuesday',\n 'Wednesday',\n 'Thursday',\n 'Friday',\n 'Saturday',\n 'Sunday',\n 'kNumDays',\n '}'])\n\n enum_values = ['-4',\n 'Monday',\n 'Tuesday',\n 'Wednesday',\n 'Thursday',\n 'Friday',\n 'Saturday',\n 'Sunday',\n 'kNumDays',\n '5']\n\n # Make sure a pointer to an anonymous enum type does crash LLDB and displays correctly using\n # frame variable and expression commands\n self.expect(\n 'frame variable f.op',\n DATA_TYPES_DISPLAYED_CORRECTLY,\n substrs=[\n 'ops *',\n 'f.op'],\n patterns=['0x0+$'])\n self.expect(\n 'frame variable *f.op',\n DATA_TYPES_DISPLAYED_CORRECTLY,\n substrs=[\n 'ops',\n '*f.op',\n '<parent is NULL>'])\n self.expect(\n 'expr f.op',\n DATA_TYPES_DISPLAYED_CORRECTLY,\n substrs=[\n 'ops *',\n '$'],\n patterns=['0x0+$'])\n self.expect(\n 'expr *f.op',\n DATA_TYPES_DISPLAYED_CORRECTLY,\n substrs=['error:'],\n error=True)\n\n bkpt = self.target().FindBreakpointByID(bkpt_id)\n for enum_value in enum_values:\n self.expect(\n \"frame variable day\",\n 'check for valid enumeration value',\n substrs=[enum_value])\n lldbutil.continue_to_breakpoint(self.process(), bkpt)","def test_login_field(self):\n field = self.record.find('field[@name=\\'login\\']')\n self.assertEqual(field.text, 'adt', 'Incorrect login Field')","def test_47(self):\n assert 'False' == Api.requestBlock('test-47', CustomFields=True)","def test_check_source_8(self):\n self.src1._organism_host_genus = \"Gordonia\"\n import_genome.check_source(self.src1, self.eval_flags,\n host_genus=\"Mycobacterium\")\n count = count_status(self.src1, \"error\", \"warning\")\n self.assertEqual(count, 1)","def op_jump_preconditions(self,piece):\n\n # Flag must be FREE or JUMP\n if(self.next_move == self.CAPT or self.next_move == self.ADDPIECE_1 or self.next_move == self.ADDPIECE_2):\n return False\n\n # Check if the piece is in the next pieces (deals with obligatory jumps)\n if(self.next_move == self.JUMP and piece not in self.next_pieces):\n return False\n\n return True","def test_get_field_state_comparisons_bad_comp_state(self):\r\n self.assertRaises(ValueError, get_field_state_comparisons,\r\n self.dist_matrix_header, self.dist_matrix,\r\n self.mapping_header, self.mapping, self.field,\r\n ['T0', 'Fast'])\r\n self.assertRaises(ValueError, get_field_state_comparisons,\r\n self.dist_matrix_header, self.dist_matrix,\r\n self.mapping_header, self.mapping, self.field,\r\n ['Fast', 'T0'])","def trivialFieldChecker(self, event):\n\n self.widget_insert_page_item[event.widget].is_good_flag = True","def checkField(fromFieldType, toFieldType, delimiter):\n\n if fromFieldType == \"String\":\n if not toFieldType == \"String\":\n arcpy.AddError(\"Copy To Field must be of type text when Read From Field is of type text.\")\n else:\n if not toFieldType == \"String\":\n if delimiter != \"\":\n arcpy.AddError(\"Copy To Field must be of type text when Read From Field is of type numeric or date and you are using a delimiter.\")\n\n if delimiter == \"\":\n if fromFieldType == \"SmallInteger\":\n if not toFieldType in [\"Integer\", \"SmallInteger\", \"Float\", \"Double\"]:\n if toFieldType == \"Date\":\n arcpy.AddError(\"Copy To Field must be of type text.\")\n\n if fromFieldType == \"Integer\":\n if toFieldType in [\"SmallInteger\", \"Integer\", \"Float\", \"Double\", \"Date\"]:\n arcpy.AddError(\"Copy To Field must be of type text.\")\n\n else:\n if fromFieldType in [\"Float\", \"Double\" , \"Date\"]:\n if toFieldType in [\"Integer\", \"SmallInteger\", \"Float\", \"Double\" , \"Date\"]:\n arcpy.AddError(\"Copy To Field must be of type text.\")","def test_should_name_field(self):\n self.assertIn(\"name\", self.fields)","def test_single_field_success(self, client):\n field_dependency = client.single_field_dependency(9)\n assert field_dependency == self.test_field_dep","def _guider_start(self, nCall, nInfo, nWarn, nErr, finish=False, didFail=False):\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n result = masterThread.guider_start(self.cmd, cmdState, myGlobals.actorState, 'gotoField')\n self.assertEqual(result, not didFail)\n self._check_cmd(nCall, nInfo, nWarn, nErr, finish, didFail=didFail)","def test_get_curr_bc_added_field_bc_and_added_field_no_hit(self):\r\n\r\n curr_bc = \"\"\r\n ids_bcs_added_field = {(\"\", \"1\"): \"s1\",\r\n (\"\", \"2\"): \"s2\", (\"\", \"3\"): \"s3\"}\r\n fasta_label = \"123ABC region=1 length=255\"\r\n all_bcs = [\"\"]\r\n barcode_type = 0,\r\n disable_bc_correction = False\r\n added_demultiplex_field = 'region'\r\n corrected_bc, num_errors, added_field =\\\r\n get_curr_bc_added_field(curr_bc, ids_bcs_added_field, fasta_label,\r\n all_bcs, barcode_type, disable_bc_correction, added_demultiplex_field)\r\n\r\n expected_corrected_bc = \"\"\r\n expected_num_errors = 0\r\n expected_added_field = \"1\"\r\n\r\n self.assertEqual(corrected_bc, expected_corrected_bc)\r\n self.assertEqual(num_errors, expected_num_errors)\r\n self.assertEqual(added_field, expected_added_field)","def test_check_source_9(self):\n self.src1._host_host_genus = \"Gordonia\"\n import_genome.check_source(self.src1, self.eval_flags,\n host_genus=\"Mycobacterium\")\n count = count_status(self.src1, \"error\", \"warning\")\n self.assertEqual(count, 1)","def required_field(variable_to_test: any, err_string: str) -> None:\n if variable_to_test is None:\n print('\\n' + err_string + '\\n')\n sys.exit(1)","def test_region_check(self):\n reference = {'region': 'reference'}\n target = {'region': 'target'}\n\n # Check that IOError is raised for nonmatching regions\n self.assertRaises(IOError, librad_drift.RadiometricDrift.check_fields, reference, target)\n\n # Check no error raised if regions match\n librad_drift.RadiometricDrift.check_fields(reference, reference)","def test_field_value_exact(self):\n field = 'M30'\n ref_idx = [2]\n self.res=self.run_task(infile=self.rawfile,field=field,calmode=self.calmode,outfile=self.outname,outform='ASAP')\n self.assertEqual(self.res,None,\n msg='Any error occurred during calibration')\n self._compare_with_analytic(self.outname, self.line, self.baseline, ref_idx)","def test_48(self):\n assert 'False' == Api.requestBlock('test-48', CustomFields=True)","def _validate_fields(self, change_fields):\n pass","def test_49(self):\n assert 'False' == Api.requestBlock('test-49', CustomFields=True)","def is_field(self, proof = True):\n return True","def check_general(self, gb, gr):\n gb = General(\"BLUE\")\n gr = General(\"RED\")\n # Look to see if the generals are in the same column\n \n gr_row = self.ind(new_pos)[0]\n gr_col = self.ind(new_pos)[1]\n gb_row = self.ind(cur_pos)[0]\n gb_col = self.ind(cur_pos)[1]","def test_init_get_critical_for_needed(self):\n # needed_names = [nf for nf in ('country_display', 'country_flag') if nf not in self.form.base_fields]\n # for name in needed_names: name, field = self.get_critical_field(name, name)\n # original_get_critical_field = self.form.get_critical_field\n # self.form.get_critical_field = self.get_critical_field_signal\n print(\"================ TEST INIT GET CRITICAL FOR NEEDED ==================\")\n print(self.form.get_critical_field.__name__)\n # print(getattr(self, 'get_critical_call', 'NOT FOUND'))\n # print(getattr(self.form, 'get_critical_call', 'NOT FOUND'))\n name = 'country_display'\n expected = {'names': name, 'alt_name': name}\n field = self.form.fields.get(name, None) or self.form.computed_fields(name, None)\n response = self.form.get_critical_field(name, name)\n actual = getattr(self, 'get_critical_call', 'NOT FOUND')\n print(\"----------------------------------------\")\n print(response)\n print(expected)\n print(actual)\n # self.assertDictEqual(expected, actual)\n self.assertEqual((name, field), response)\n\n # self.get_critical_field = original_get_critical_field","def test_step_gol():\n test_field = torch.tensor([[0, 1, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])\n\n # Checking that the game works properly\n assert torch.all(torch.eq(step(test_field), torch.tensor([[0, 1, 1, 1],\n [0, 0, 1, 0],\n [0, 0, 0, 0],\n [0, 0, 1, 0]])))\n return","def test_callable_name_get_critical_field(self):\n special = self.get_generic_name\n name, field = self.form.get_critical_field(special)\n expected_name = special()\n expected_field = self.form.fields[expected_name]\n self.assertEqual(expected_name, name)\n self.assertEqual(expected_field, field)","def test_fields_effort_default_reference_unit_invalid(self, _mock_check):\n field = EffortField(\n time_units={\"minute\": (\"minute\", \"minutes\")},\n default_reference_unit=\"invalid\",\n )\n\n errors = field.check()\n self.assertEqual(len(errors), 1)\n\n error = errors[0]\n self.assertEqual(error.msg, \"'invalid' is not a valid time unit.\")\n self.assertEqual(error.obj, field)\n self.assertEqual(error.id, \"fields.E1013\")","def test_field_code(self):\n inv_search = \"subject:p\"\n spi_search = \"f f p\"\n self._compare_searches(inv_search, spi_search)","def test_raises_on_missing_needed_fields(self):\n test_name = \"impossible_creature_not_present\"\n self.form.constructor_fields = [*self.form.constructor_fields, test_name]\n message = \"The fields for email, username, and constructor must be set in fields. \"\n self.assertNotIn(test_name, self.form.base_fields)\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.confirm_required_fields()","def test_no_flag_handle_flag_field(self):\n original_flag_name = self.form.USERNAME_FLAG_FIELD\n self.form.USERNAME_FLAG_FIELD = \"This is not a valid field name\"\n expected = None\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n\n self.assertEqual(expected, actual)\n self.form.USERNAME_FLAG_FIELD = original_flag_name","def test_raise_missing_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_flag = self.form.USERNAME_FLAG_FIELD\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n original_errors = getattr(self.form, '_errors', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.USERNAME_FLAG_FIELD = 'Not a valid field name'\n self.form.cleaned_data = {self.form.name_for_user: 'test_username', self.form.name_for_email: 'test_email'}\n # self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n self.form._errors = None if original_errors is None else original_errors.copy()\n\n with self.assertRaises(ImproperlyConfigured):\n self.form.configure_username_confirmation()\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.USERNAME_FLAG_FIELD = original_flag\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n if original_cleaned_data is None:\n del self.form.cleaned_data\n if original_errors is None:\n del self.form._errors","def test_entities__Field__1():\n zope.interface.verify.verifyObject(IField, Field())","def goto(vehicle, dNorth, dEast):\n goto_function = vehicle.simple_goto # can be changed\n currentLocation = vehicle.location.global_relative_frame\n targetLocation = get_location_metres(currentLocation, dNorth, dEast)\n targetDistance = get_distance_metres(currentLocation, targetLocation)\n goto_function(targetLocation)\n\n #Stop action if we are no longer in guided mode.\n while vehicle.mode.name == \"GUIDED\": \n remainingDistance = get_distance_metres(vehicle.location.global_relative_frame, targetLocation)\n #print \"Distance to target: \", remainingDistance\n if remainingDistance <= shared.WP_RADIUS: #Just below target, in case of undershoot.\n #print \"Reached target\"\n break;\n\n time.sleep(0.5)","def condition_forward_checking(csp, var) :\n return False","def condition_forward_checking(csp, var) :\n return False","def checkFieldMappings(self, param):\n field_mappings = param.value\n over_fields = []\n fields_warning = ('The following visible field name(s) are' +\n ' over 10 characters and will be shortened' +\n ' automatically by ArcGIS: ')\n for idx, val in enumerate(range(field_mappings.count)):\n if field_mappings.getVisible(idx) == 'VISIBLE':\n field = field_mappings.getNewName(idx)\n if len(field) > 10:\n over_fields.append(field)\n if over_fields:\n param.setWarningMessage(fields_warning + \", \".join(over_fields))\n else:\n param.clearMessage()","def test_model_custom_field_editing_attribute_missing(self):\n\n try:\n error = False\n\n # GIVEN invalid model field definition\n # WHEN model gets executed in the system\n class TestTestModel(models.Model):\n name = AppModelCharField(max_length=256, blank=True, null=True)\n\n except Exception as e:\n msg = e.args[0]\n error = True\n\n # THEN error should be raised\n self.assertTrue(error)\n\n # AND clear error description is present\n ref_msg = 'Field editing statuses are missing for AppModelCharField; called from TestTestModel'\n self.assertEqual(ref_msg, msg)","def test_handle_flag_error(self):\n pass","def _WaitForField(self, field):\n self._GaiaWebviewContext().WaitForJavaScriptCondition(\n \"document.getElementById({{ field }}) != null && \"\n \"!document.getElementById({{ field }}).hidden\",\n field=field, timeout=20)","def test_fields_effort_default_reference_unit_success(self, _mock_check):\n field = EffortField(\n time_units={\"minute\": (\"minute\", \"minutes\")},\n default_reference_unit=\"minute\",\n )\n\n errors = field.check()\n self.assertEqual(len(errors), 0)","def test_raises_if_missed_fields(self):\n name = 'second'\n self.form.called_handle_modifiers = False\n remove = {'remove_field': name}\n self.form.handle_modifiers({}, [], **remove)\n self.assertNotIn(name, self.form.fields)\n self.assertIn(name, self.form.hold_field)\n message = \"Some unassigned fields, perhaps some added during handle_modifiers. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets(add_field=name)\n self.form.called_handle_modifiers = False","def check_returnable_fields(fields, result):\n returnable_fields = get_returnable_fields(result, verbose=False)\n for field in fields:\n if field not in returnable_fields:\n err_str = \"The field %s is not a returnable field for \" % (field)\n err_str += \"result %s\" % (result)\n raise ValueError(err_str)","def test_check_source_11(self):\n self.src1._organism_host_genus = \"Mycobacterio\"\n import_genome.check_source(self.src1, self.eval_flags,\n host_genus=\"Mycobacterium\")\n count = count_status(self.src1, \"error\")\n self.assertEqual(count, 0)","def test_parse_case_field_00(input_, expected):\n actual = regex.match_case_field(input_)\n assert actual == expected","def _assert_reg_field(self, extra_fields_setting, expected_field):\n # Add in fields that are always present\n self._populate_always_present_fields(expected_field)\n\n # Retrieve the registration form description\n with override_settings(REGISTRATION_EXTRA_FIELDS=extra_fields_setting):\n response = self.client.get(self.url)\n self.assertHttpOK(response)\n\n # Verify that the form description matches what we'd expect\n form_desc = json.loads(response.content.decode('utf-8'))\n\n actual_field = None\n for field in form_desc[\"fields\"]:\n if field[\"name\"] == expected_field[\"name\"]:\n actual_field = field\n break\n\n self._assert_fields_match(actual_field, expected_field)","def test_name_field(self):\n field = self.record.find('field[@name=\\'name\\']')\n self.assertEqual(field.text, 'GUH-ADT', 'Incorrect Name Field')","def test_init_valid_field(self):\n fields = {'Conn Note': {'offset': 0,\n 'length': 20}}\n parser = top.Parser(fields=fields)\n received = parser.get_fields()\n expected = fields\n msg = 'Fields initialisation property setter/getter error.'\n self.assertEqual(received, expected, msg)","def link_check(form, field):\n if form.registrable.data and len(field.data)==0:\n raise validators.ValidationError('link should is required when the forum is registrable')","def test_check_source_10(self):\n self.src1._lab_host_host_genus = \"Gordonia\"\n import_genome.check_source(self.src1, self.eval_flags,\n host_genus=\"Mycobacterium\")\n count = count_status(self.src1, \"error\", \"warning\")\n self.assertEqual(count, 1)","def test_field_value_pattern(self):\n field = 'M*'\n ref_idx = [0,1,2]\n self.res=self.run_task(infile=self.rawfile,field=field,calmode=self.calmode,outfile=self.outname,outform='ASAP')\n self.assertEqual(self.res,None,\n msg='Any error occurred during calibration')\n self._compare_with_analytic(self.outname, self.line, self.baseline, ref_idx)","def check(self) -> None:","def _test(self, c):\n\treturn self.UNRESOLVED\t\t# Placeholder","def test_50(self):\n assert 'False' == Api.requestBlock('test-50', CustomFields=True)","def test_kyc_post_legal_board_member(self):\n pass","def inspect_melons(self,passed):\n if passed == True:\n self.passed_inspection = True\n # return True","def validate_field(self, fieldname):\n fieldname = self.__class__.FIELD_ALIAS.get(fieldname, fieldname)\n v = self._data[fieldname]\n t = self._field_or_default_datatype(fieldname, v)\n gfapy.Field._validate_gfa_field(v, t, fieldname)","def test_raise_error_unknown_field():\n\n options = {'fields': ['kHello']}\n\n with pytest.raises(KeyError) as excinfo:\n process.Packager(options)\n excinfo.match('Field ([a-zA-Z].*) not found in file list.')","def test_field_id_range(self):\n field = '6~8'\n ref_idx = [1,2,3]\n self.res=self.run_task(infile=self.rawfile,field=field,calmode=self.calmode,outfile=self.outname,outform='ASAP')\n self.assertEqual(self.res,None,\n msg='Any error occurred during calibration')\n self._compare_with_analytic(self.outname, self.line, self.baseline, ref_idx)","def test_get_curr_bc_added_field_bc_and_added_field(self):\r\n\r\n curr_bc = \"GGCAGCACTTGT\"\r\n ids_bcs_added_field = {(\"AACTCGTCGATG\", \"123\"): \"s1\",\r\n (\"AGCAGCACTTGT\", \"123\"): \"s2\", (\"ACAGAGTCGGCT\", \"ABCD\"): \"s3\"}\r\n fasta_label = \"123ABC region=1 length=255\"\r\n all_bcs = [\"AACTCGTCGATG\", \"AGCAGCACTTGT\", \"ACAGAGTCGGCT\"]\r\n barcode_type = \"golay_12\",\r\n disable_bc_correction = False\r\n added_demultiplex_field = 'run_prefix'\r\n corrected_bc, num_errors, added_field =\\\r\n get_curr_bc_added_field(curr_bc, ids_bcs_added_field, fasta_label,\r\n all_bcs, barcode_type, disable_bc_correction, added_demultiplex_field)\r\n\r\n expected_corrected_bc = \"AGCAGCACTTGT\"\r\n expected_num_errors = 1\r\n expected_added_field = \"123\"\r\n\r\n self.assertEqual(corrected_bc, expected_corrected_bc)\r\n self.assertEqual(num_errors, expected_num_errors)\r\n self.assertEqual(added_field, expected_added_field)","def test_get_field_state_comparisons_no_comp_states(self):\r\n self.assertRaises(ValueError, get_field_state_comparisons,\r\n self.dist_matrix_header, self.dist_matrix,\r\n self.mapping_header, self.mapping, self.field,\r\n [])","def test_make_form_field():","def test_single_field_failure(self, client):\n with pytest.raises(CastorException) as e:\n client.single_field_dependency(2)\n assert str(e.value) == \"404 Entity not found.\"","def test_clean_country_flag(self):\n # country_flag = self.cleaned_data.get('country_flag', None)\n # field = self.fields.get(self.country_field_name, None)\n # if not field and hasattr(self, 'computed_fields'):\n # field = self.computed_fields.get(self.country_field_name, None)\n # if field.initial == self.cleaned_data.get(self.country_field_name, None)\n pass","def test_select_var_failed_if_bad_var_name(self):\n with patch('esmvalcore.cmor._fixes.fix.Fix.get_fixes',\n return_value=[]):\n with self.assertRaises(ValueError):\n fix_metadata(\n cubes=[\n self._create_mock_cube('not_me'),\n self._create_mock_cube('me_neither')\n ],\n short_name='short_name',\n project='CMIP6',\n dataset='model',\n mip='mip',\n )","def test_27(self):\n assert 'False' == Api.requestBlock('test-27')","def test_field_errors(self):\n # For username field\n response = self.client.post(reverse('users:login'), data={\n 'username': 'username_that_not_exist',\n 'password': '11111111',\n })\n error = BeautifulSoup(response.content, 'html.parser').find('p', 'username-error').text\n\n self.assertEqual(error, 'User with this username doesn\\'t exist.')\n\n # For password field\n response = self.client.post(reverse('users:login'), data={\n 'username': 'temp1',\n 'password': '11111111',\n })\n error = BeautifulSoup(response.content, 'html.parser').find('p', 'non-field-error').text\n\n self.assertEqual(error, 'Enter correct password.')","def test_field_id_exact(self):\n field = '6'\n ref_idx = [1]\n self.res=self.run_task(infile=self.rawfile,field=field,calmode=self.calmode,outfile=self.outname,outform='ASAP')\n self.assertEqual(self.res,None,\n msg='Any error occurred during calibration')\n self._compare_with_analytic(self.outname, self.line, self.baseline, ref_idx)","def test_entities__Entity__getField__2(entity):\n assert IDummy['dummy2'] == entity.getField('dummy2')","def check_grue(self, tile):\n if tile[2] == 'grue':\n if self.lab.inventory > 0:\n self.lab.fire()\n print 'Lighted match'","def test_fields(self):\n form = self._get_form(data=None)\n self.assertEquals(len(form.fields), 4)\n self.assertTrue('tests_url' in form.fields)\n self.assertTrue('repo_url' in form.fields)\n self.assertTrue('pkg_type' in form.fields)\n self.assertTrue('tags' in form.fields)"],"string":"[\n \"def test_goto_field_apogee_no_guider(self):\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n cmdState.doGuider = False\\n self._goto_feld_apogee(3, 11, 0, 0, cmdState)\",\n \"def test_goto_field_apogee(self):\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n self._goto_feld_apogee(13, 46, 0, 0, cmdState)\",\n \"def test_goto_field_boss_flat_on_fails(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n self.cmd.failOn = 'mcp ff.on'\\n self._goto_field_boss(16, 71, 0, 1, cmdState, didFail=True, finish=True)\",\n \"def test_goto_field_boss_guider(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\\n sopTester.updateModel('guider', TestHelper.guiderState['guiderOnDecenter'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n cmdState.doSlew = False\\n cmdState.doHartmann = False\\n cmdState.doCalibs = False\\n cmdState.arcTime = 0\\n cmdState.flatTime = 0\\n self._goto_field_boss(9, 37, 0, 0, cmdState)\",\n \"def test_goto_field_apogee_no_slew(self):\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n cmdState.doSlew = False\\n self._goto_feld_apogee(9, 37, 0, 0, cmdState)\",\n \"def test_goto_field_boss_ffs_open_fails(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n self.cmd.failOn = 'mcp ffs.open'\\n self._goto_field_boss(21, 102, 1, 1, cmdState, didFail=True, finish=True)\",\n \"def test_goto_field_apogee_no_slew_decenter_off(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\\n sopTester.updateModel('guider', TestHelper.guiderState['guiderOnDecenter'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n cmdState.doSlew = False\\n self._goto_feld_apogee(9, 37, 0, 0, cmdState)\",\n \"def test_goto_field_boss_hartmann_blue_fails(self):\\n\\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\\n sopTester.updateModel('hartmann', TestHelper.hartmannState['blue_fails'])\\n\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n\\n self._goto_field_boss(12, 37, 0, 0, cmdState, didFail=True, finish=True)\",\n \"def test_goto_field_apogee_bypass_gangToCart(self):\\n self._prep_bypass('gangToCart', clear=True)\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n self._goto_feld_apogee(13, 44, 4, 0, cmdState)\",\n \"def test_goto_field_boss_calibs(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n cmdState.doSlew = False\\n cmdState.doHartmann = False\\n cmdState.doGuider = False\\n self._goto_field_boss(10, 57, 0, 0, cmdState)\",\n \"def test_goto_field_apogee_no_slew_shutter_open(self):\\n sopTester.updateModel('apogee', TestHelper.apogeeState['B_open'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n cmdState.doSlew = False\\n self._goto_feld_apogee(10, 37, 0, 0, cmdState)\",\n \"def test_defining_only_or_defer_on_nonexistant_fields_fails(self):\",\n \"def test_goto_field_boss_slew(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n cmdState.doGuider = False\\n cmdState.doHartmann = False\\n cmdState.doCalibs = False\\n cmdState.arcTime = 0\\n cmdState.flatTime = 0\\n self._goto_field_boss(3, 26, 0, 0, cmdState)\",\n \"def _validator_target(self, field, value):\\n if not REG.match(value):\\n self._error(field, \\\"{} is not a valid target\\\".format(value))\",\n \"def verifyField(self, pv, field, reference):\\n full_pv = pv + \\\".\\\" + field\\n if (caget(full_pv) != reference):\\n msg = \\\"ERROR: \\\" + full_pv + \\\" not equal to \\\" + str(reference)\\n raise Exception(__name__ + msg)\\n\\n return self.__g.SUCCESS\",\n \"def test_mutate_field(self):\\n # Test adding a field\\n with self.assertRaises(ValueError):\\n self.email.add_field('', '')\\n\\n self.email.add_field(self.key, self.regex)\\n\\n found_key = False\\n found_regex = r''\\n for field in self.email.fields:\\n if field['key'] == self.key:\\n found_key = True\\n found_regex = field['regex']\\n\\n self.assertTrue(found_key)\\n self.assertEqual(found_regex, self.regex)\\n\\n # Test getting a field\\n with self.assertRaises(LookupError):\\n self.email.get_field('')\\n\\n field = self.email.get_field(self.key)\\n self.assertEqual(\\n field, {'key': self.key, 'regex': self.regex, 'value': []})\\n\\n # Test removing a field\\n with self.assertRaises(LookupError):\\n self.email.remove_field('')\\n\\n self.email.remove_field(self.key)\\n\\n found_key = False\\n found_regex = r''\\n for field in self.email.fields:\\n if field['key'] == self.key:\\n found_key = True\\n found_regex = field['regex']\\n\\n self.assertFalse(found_key)\\n self.assertNotEqual(found_regex, self.regex)\",\n \"def test_goto_field_boss_hartmann(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n cmdState.doSlew = False\\n cmdState.doCalibs = False\\n cmdState.arcTime = 0\\n cmdState.flatTime = 0\\n cmdState.doGuider = False\\n self._goto_field_boss(5, 29, 0, 0, cmdState)\",\n \"def test_invalid_field_access(self):\\r\\n out = self.c.post(self.url, {'op': 'delete hints', 'field': 'all your private data'})\\r\\n print out\\r\\n self.assertTrue('an invalid field was accessed' in out.content)\",\n \"def test_field_id_lt(self):\\n field = '<6'\\n ref_idx = [0]\\n self.res=self.run_task(infile=self.rawfile,field=field,calmode=self.calmode,outfile=self.outname,outform='ASAP')\\n self.assertEqual(self.res,None,\\n msg='Any error occurred during calibration')\\n self._compare_with_analytic(self.outname, self.line, self.baseline, ref_idx)\",\n \"def test_51(self):\\n assert 'False' == Api.requestBlock('test-51', CustomFields=True)\",\n \"def test_field_id_gt(self):\\n field = '>7'\\n ref_idx = [3]\\n self.res=self.run_task(infile=self.rawfile,field=field,calmode=self.calmode,outfile=self.outname,outform='ASAP')\\n self.assertEqual(self.res,None,\\n msg='Any error occurred during calibration')\\n self._compare_with_analytic(self.outname, self.line, self.baseline, ref_idx)\",\n \"def test_select_field():\",\n \"def ask_for_field(self, row, col):\\n field = self.map.fields[row][col]\\n # return the field kind, team, and if there is an entity or not\\n return field.passable, field.team, field.entity is not None\",\n \"def checkField(fieldset, text=True):\\n if text:\\n print \\\"\\\\nFieldset contains the following fields:\\\"\\n for i in range(len(fieldset.fields)):\\n print fieldset.fields[i].name\\n\\n ulon = fieldset.U.grid.lon\\n ulat = fieldset.U.grid.lat\\n udep = fieldset.U.grid.depth\\n vlon = fieldset.V.grid.lon\\n vlat = fieldset.V.grid.lat\\n vdep = fieldset.V.grid.depth\\n\\n if text:\\n if np.all(ulon == vlon):\\n print \\\"longitudes are the same for U and V\\\"\\n else:\\n print \\\"longitudes are not the same for U and V. Note that not all functions will work as intended.\\\"\\n if np.all(ulat == vlat):\\n print \\\"latitudes are the same for U and V\\\"\\n else:\\n print \\\"latitudes are not the same for U and V. Note that not all functions will work as intended.\\\"\\n if np.all(udep == vdep):\\n print \\\"depths are the same for U and V\\\"\\n else:\\n print \\\"depths are not the same for U and V. Note that not all functions will work as intended.\\\"\\n\\n return np.all(ulon == vlon) and np.all(ulat == vlat) and np.all(udep == vdep)\",\n \"def check_field_name(field_name):\\n\\n error_checking.assert_is_string(field_name)\\n if field_name in ALL_PREDICTOR_NAMES + ALL_TARGET_NAMES:\\n return\\n\\n error_string = (\\n '\\\\nField \\\"{0:s}\\\" is not valid predictor or target variable. Valid '\\n 'options listed below:\\\\n{1:s}'\\n ).format(field_name, str(ALL_PREDICTOR_NAMES + ALL_TARGET_NAMES))\\n\\n raise ValueError(error_string)\",\n \"def _is_ifgoto(self, words):\\n if words[0] == 'if-goto':\\n if len(words) != 2:\\n raise SyntaxError(\\\"File line {}: Invalid number of arguments for C_IFGOTO command.\\\".format(self._file_line))\\n return True\\n else:\\n return False\",\n \"def test_02_visit_again(self):\",\n \"def test_get_critical_from_existing_fields(self):\\n name = 'generic_field'\\n opts = {'names': (name, ), 'alt_field': '', 'computed': False}\\n expected_field = self.form.fields.get(name, None)\\n actual_name, actual_field = self.form.get_critical_field(opts['names'])\\n self.assertEqual(name, actual_name)\\n self.assertEqual(expected_field, actual_field)\",\n \"def assert_known_field(self, name):\\n if not (name == self.id_field_name or self.is_known_field(name)):\\n raise ChipsError(\\\"Unknown field in model %s [%s]\\\", self.__class__.__name__, name)\",\n \"def check():\",\n \"def _is_goto(self, words):\\n if words[0] == 'goto':\\n if len(words) != 2:\\n raise SyntaxError(\\\"File line {}: Invalid number of arguments for C_GOTO command.\\\".format(self._file_line))\\n return True\\n else:\\n return False\",\n \"def test_field_rules():\",\n \"def test(self):\\n self.build()\\n exe = self.getBuildArtifact(\\\"a.out\\\")\\n self.runCmd(\\\"file \\\" + exe, CURRENT_EXECUTABLE_SET)\\n\\n lldbutil.run_to_source_breakpoint(\\n self, '// Breakpoint for bitfield', lldb.SBFileSpec(\\\"main.c\\\"))\\n\\n self.expect(\\\"fr var a\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = A$'])\\n self.expect(\\\"fr var b\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = B$'])\\n self.expect(\\\"fr var c\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = C$'])\\n self.expect(\\\"fr var ab\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = AB$'])\\n self.expect(\\\"fr var ac\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = A | C$'])\\n self.expect(\\\"fr var all\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = ALL$'])\\n # Test that an enum that doesn't match the heuristic we use in\\n # ClangASTContext::DumpEnumValue, gets printed as a raw integer.\\n self.expect(\\\"fr var omega\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = 7$'])\\n # Test the behavior in case have a variable of a type considered\\n # 'bitfield' by the heuristic, but the value isn't actually fully\\n # covered by the enumerators.\\n self.expect(\\\"p (enum bitfield)nonsense\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n patterns=[' = B | C | 0x10$'])\\n\\n # Break inside the main.\\n bkpt_id = lldbutil.run_break_set_by_file_and_line(\\n self, \\\"main.c\\\", self.line, num_expected_locations=1, loc_exact=True)\\n self.runCmd(\\\"c\\\", RUN_SUCCEEDED)\\n\\n # The stop reason of the thread should be breakpoint.\\n self.expect(\\\"thread list\\\", STOPPED_DUE_TO_BREAKPOINT,\\n substrs=['stopped',\\n 'stop reason = breakpoint'])\\n\\n # The breakpoint should have a hit count of 1.\\n self.expect(\\\"breakpoint list -f\\\", BREAKPOINT_HIT_ONCE,\\n substrs=[' resolved, hit count = 1'])\\n\\n # Look up information about the 'days' enum type.\\n # Check for correct display.\\n self.expect(\\\"image lookup -t days\\\", DATA_TYPES_DISPLAYED_CORRECTLY,\\n substrs=['enum days {',\\n 'Monday',\\n 'Tuesday',\\n 'Wednesday',\\n 'Thursday',\\n 'Friday',\\n 'Saturday',\\n 'Sunday',\\n 'kNumDays',\\n '}'])\\n\\n enum_values = ['-4',\\n 'Monday',\\n 'Tuesday',\\n 'Wednesday',\\n 'Thursday',\\n 'Friday',\\n 'Saturday',\\n 'Sunday',\\n 'kNumDays',\\n '5']\\n\\n # Make sure a pointer to an anonymous enum type does crash LLDB and displays correctly using\\n # frame variable and expression commands\\n self.expect(\\n 'frame variable f.op',\\n DATA_TYPES_DISPLAYED_CORRECTLY,\\n substrs=[\\n 'ops *',\\n 'f.op'],\\n patterns=['0x0+$'])\\n self.expect(\\n 'frame variable *f.op',\\n DATA_TYPES_DISPLAYED_CORRECTLY,\\n substrs=[\\n 'ops',\\n '*f.op',\\n '<parent is NULL>'])\\n self.expect(\\n 'expr f.op',\\n DATA_TYPES_DISPLAYED_CORRECTLY,\\n substrs=[\\n 'ops *',\\n '$'],\\n patterns=['0x0+$'])\\n self.expect(\\n 'expr *f.op',\\n DATA_TYPES_DISPLAYED_CORRECTLY,\\n substrs=['error:'],\\n error=True)\\n\\n bkpt = self.target().FindBreakpointByID(bkpt_id)\\n for enum_value in enum_values:\\n self.expect(\\n \\\"frame variable day\\\",\\n 'check for valid enumeration value',\\n substrs=[enum_value])\\n lldbutil.continue_to_breakpoint(self.process(), bkpt)\",\n \"def test_login_field(self):\\n field = self.record.find('field[@name=\\\\'login\\\\']')\\n self.assertEqual(field.text, 'adt', 'Incorrect login Field')\",\n \"def test_47(self):\\n assert 'False' == Api.requestBlock('test-47', CustomFields=True)\",\n \"def test_check_source_8(self):\\n self.src1._organism_host_genus = \\\"Gordonia\\\"\\n import_genome.check_source(self.src1, self.eval_flags,\\n host_genus=\\\"Mycobacterium\\\")\\n count = count_status(self.src1, \\\"error\\\", \\\"warning\\\")\\n self.assertEqual(count, 1)\",\n \"def op_jump_preconditions(self,piece):\\n\\n # Flag must be FREE or JUMP\\n if(self.next_move == self.CAPT or self.next_move == self.ADDPIECE_1 or self.next_move == self.ADDPIECE_2):\\n return False\\n\\n # Check if the piece is in the next pieces (deals with obligatory jumps)\\n if(self.next_move == self.JUMP and piece not in self.next_pieces):\\n return False\\n\\n return True\",\n \"def test_get_field_state_comparisons_bad_comp_state(self):\\r\\n self.assertRaises(ValueError, get_field_state_comparisons,\\r\\n self.dist_matrix_header, self.dist_matrix,\\r\\n self.mapping_header, self.mapping, self.field,\\r\\n ['T0', 'Fast'])\\r\\n self.assertRaises(ValueError, get_field_state_comparisons,\\r\\n self.dist_matrix_header, self.dist_matrix,\\r\\n self.mapping_header, self.mapping, self.field,\\r\\n ['Fast', 'T0'])\",\n \"def trivialFieldChecker(self, event):\\n\\n self.widget_insert_page_item[event.widget].is_good_flag = True\",\n \"def checkField(fromFieldType, toFieldType, delimiter):\\n\\n if fromFieldType == \\\"String\\\":\\n if not toFieldType == \\\"String\\\":\\n arcpy.AddError(\\\"Copy To Field must be of type text when Read From Field is of type text.\\\")\\n else:\\n if not toFieldType == \\\"String\\\":\\n if delimiter != \\\"\\\":\\n arcpy.AddError(\\\"Copy To Field must be of type text when Read From Field is of type numeric or date and you are using a delimiter.\\\")\\n\\n if delimiter == \\\"\\\":\\n if fromFieldType == \\\"SmallInteger\\\":\\n if not toFieldType in [\\\"Integer\\\", \\\"SmallInteger\\\", \\\"Float\\\", \\\"Double\\\"]:\\n if toFieldType == \\\"Date\\\":\\n arcpy.AddError(\\\"Copy To Field must be of type text.\\\")\\n\\n if fromFieldType == \\\"Integer\\\":\\n if toFieldType in [\\\"SmallInteger\\\", \\\"Integer\\\", \\\"Float\\\", \\\"Double\\\", \\\"Date\\\"]:\\n arcpy.AddError(\\\"Copy To Field must be of type text.\\\")\\n\\n else:\\n if fromFieldType in [\\\"Float\\\", \\\"Double\\\" , \\\"Date\\\"]:\\n if toFieldType in [\\\"Integer\\\", \\\"SmallInteger\\\", \\\"Float\\\", \\\"Double\\\" , \\\"Date\\\"]:\\n arcpy.AddError(\\\"Copy To Field must be of type text.\\\")\",\n \"def test_should_name_field(self):\\n self.assertIn(\\\"name\\\", self.fields)\",\n \"def test_single_field_success(self, client):\\n field_dependency = client.single_field_dependency(9)\\n assert field_dependency == self.test_field_dep\",\n \"def _guider_start(self, nCall, nInfo, nWarn, nErr, finish=False, didFail=False):\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n result = masterThread.guider_start(self.cmd, cmdState, myGlobals.actorState, 'gotoField')\\n self.assertEqual(result, not didFail)\\n self._check_cmd(nCall, nInfo, nWarn, nErr, finish, didFail=didFail)\",\n \"def test_get_curr_bc_added_field_bc_and_added_field_no_hit(self):\\r\\n\\r\\n curr_bc = \\\"\\\"\\r\\n ids_bcs_added_field = {(\\\"\\\", \\\"1\\\"): \\\"s1\\\",\\r\\n (\\\"\\\", \\\"2\\\"): \\\"s2\\\", (\\\"\\\", \\\"3\\\"): \\\"s3\\\"}\\r\\n fasta_label = \\\"123ABC region=1 length=255\\\"\\r\\n all_bcs = [\\\"\\\"]\\r\\n barcode_type = 0,\\r\\n disable_bc_correction = False\\r\\n added_demultiplex_field = 'region'\\r\\n corrected_bc, num_errors, added_field =\\\\\\r\\n get_curr_bc_added_field(curr_bc, ids_bcs_added_field, fasta_label,\\r\\n all_bcs, barcode_type, disable_bc_correction, added_demultiplex_field)\\r\\n\\r\\n expected_corrected_bc = \\\"\\\"\\r\\n expected_num_errors = 0\\r\\n expected_added_field = \\\"1\\\"\\r\\n\\r\\n self.assertEqual(corrected_bc, expected_corrected_bc)\\r\\n self.assertEqual(num_errors, expected_num_errors)\\r\\n self.assertEqual(added_field, expected_added_field)\",\n \"def test_check_source_9(self):\\n self.src1._host_host_genus = \\\"Gordonia\\\"\\n import_genome.check_source(self.src1, self.eval_flags,\\n host_genus=\\\"Mycobacterium\\\")\\n count = count_status(self.src1, \\\"error\\\", \\\"warning\\\")\\n self.assertEqual(count, 1)\",\n \"def required_field(variable_to_test: any, err_string: str) -> None:\\n if variable_to_test is None:\\n print('\\\\n' + err_string + '\\\\n')\\n sys.exit(1)\",\n \"def test_region_check(self):\\n reference = {'region': 'reference'}\\n target = {'region': 'target'}\\n\\n # Check that IOError is raised for nonmatching regions\\n self.assertRaises(IOError, librad_drift.RadiometricDrift.check_fields, reference, target)\\n\\n # Check no error raised if regions match\\n librad_drift.RadiometricDrift.check_fields(reference, reference)\",\n \"def test_field_value_exact(self):\\n field = 'M30'\\n ref_idx = [2]\\n self.res=self.run_task(infile=self.rawfile,field=field,calmode=self.calmode,outfile=self.outname,outform='ASAP')\\n self.assertEqual(self.res,None,\\n msg='Any error occurred during calibration')\\n self._compare_with_analytic(self.outname, self.line, self.baseline, ref_idx)\",\n \"def test_48(self):\\n assert 'False' == Api.requestBlock('test-48', CustomFields=True)\",\n \"def _validate_fields(self, change_fields):\\n pass\",\n \"def test_49(self):\\n assert 'False' == Api.requestBlock('test-49', CustomFields=True)\",\n \"def is_field(self, proof = True):\\n return True\",\n \"def check_general(self, gb, gr):\\n gb = General(\\\"BLUE\\\")\\n gr = General(\\\"RED\\\")\\n # Look to see if the generals are in the same column\\n \\n gr_row = self.ind(new_pos)[0]\\n gr_col = self.ind(new_pos)[1]\\n gb_row = self.ind(cur_pos)[0]\\n gb_col = self.ind(cur_pos)[1]\",\n \"def test_init_get_critical_for_needed(self):\\n # needed_names = [nf for nf in ('country_display', 'country_flag') if nf not in self.form.base_fields]\\n # for name in needed_names: name, field = self.get_critical_field(name, name)\\n # original_get_critical_field = self.form.get_critical_field\\n # self.form.get_critical_field = self.get_critical_field_signal\\n print(\\\"================ TEST INIT GET CRITICAL FOR NEEDED ==================\\\")\\n print(self.form.get_critical_field.__name__)\\n # print(getattr(self, 'get_critical_call', 'NOT FOUND'))\\n # print(getattr(self.form, 'get_critical_call', 'NOT FOUND'))\\n name = 'country_display'\\n expected = {'names': name, 'alt_name': name}\\n field = self.form.fields.get(name, None) or self.form.computed_fields(name, None)\\n response = self.form.get_critical_field(name, name)\\n actual = getattr(self, 'get_critical_call', 'NOT FOUND')\\n print(\\\"----------------------------------------\\\")\\n print(response)\\n print(expected)\\n print(actual)\\n # self.assertDictEqual(expected, actual)\\n self.assertEqual((name, field), response)\\n\\n # self.get_critical_field = original_get_critical_field\",\n \"def test_step_gol():\\n test_field = torch.tensor([[0, 1, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])\\n\\n # Checking that the game works properly\\n assert torch.all(torch.eq(step(test_field), torch.tensor([[0, 1, 1, 1],\\n [0, 0, 1, 0],\\n [0, 0, 0, 0],\\n [0, 0, 1, 0]])))\\n return\",\n \"def test_callable_name_get_critical_field(self):\\n special = self.get_generic_name\\n name, field = self.form.get_critical_field(special)\\n expected_name = special()\\n expected_field = self.form.fields[expected_name]\\n self.assertEqual(expected_name, name)\\n self.assertEqual(expected_field, field)\",\n \"def test_fields_effort_default_reference_unit_invalid(self, _mock_check):\\n field = EffortField(\\n time_units={\\\"minute\\\": (\\\"minute\\\", \\\"minutes\\\")},\\n default_reference_unit=\\\"invalid\\\",\\n )\\n\\n errors = field.check()\\n self.assertEqual(len(errors), 1)\\n\\n error = errors[0]\\n self.assertEqual(error.msg, \\\"'invalid' is not a valid time unit.\\\")\\n self.assertEqual(error.obj, field)\\n self.assertEqual(error.id, \\\"fields.E1013\\\")\",\n \"def test_field_code(self):\\n inv_search = \\\"subject:p\\\"\\n spi_search = \\\"f f p\\\"\\n self._compare_searches(inv_search, spi_search)\",\n \"def test_raises_on_missing_needed_fields(self):\\n test_name = \\\"impossible_creature_not_present\\\"\\n self.form.constructor_fields = [*self.form.constructor_fields, test_name]\\n message = \\\"The fields for email, username, and constructor must be set in fields. \\\"\\n self.assertNotIn(test_name, self.form.base_fields)\\n with self.assertRaisesMessage(ImproperlyConfigured, message):\\n self.form.confirm_required_fields()\",\n \"def test_no_flag_handle_flag_field(self):\\n original_flag_name = self.form.USERNAME_FLAG_FIELD\\n self.form.USERNAME_FLAG_FIELD = \\\"This is not a valid field name\\\"\\n expected = None\\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\\n\\n self.assertEqual(expected, actual)\\n self.form.USERNAME_FLAG_FIELD = original_flag_name\",\n \"def test_raise_missing_flag_field(self):\\n original_data = self.form.data\\n original_fields = self.form.fields\\n original_flag = self.form.USERNAME_FLAG_FIELD\\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\\n original_errors = getattr(self.form, '_errors', None)\\n self.form.data = original_data.copy()\\n self.form.fields = original_fields.copy()\\n self.form.USERNAME_FLAG_FIELD = 'Not a valid field name'\\n self.form.cleaned_data = {self.form.name_for_user: 'test_username', self.form.name_for_email: 'test_email'}\\n # self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\\n self.form._errors = None if original_errors is None else original_errors.copy()\\n\\n with self.assertRaises(ImproperlyConfigured):\\n self.form.configure_username_confirmation()\\n\\n self.form.data = original_data\\n self.form.fields = original_fields\\n self.form.USERNAME_FLAG_FIELD = original_flag\\n self.form.cleaned_data = original_cleaned_data\\n self.form._errors = original_errors\\n if original_cleaned_data is None:\\n del self.form.cleaned_data\\n if original_errors is None:\\n del self.form._errors\",\n \"def test_entities__Field__1():\\n zope.interface.verify.verifyObject(IField, Field())\",\n \"def goto(vehicle, dNorth, dEast):\\n goto_function = vehicle.simple_goto # can be changed\\n currentLocation = vehicle.location.global_relative_frame\\n targetLocation = get_location_metres(currentLocation, dNorth, dEast)\\n targetDistance = get_distance_metres(currentLocation, targetLocation)\\n goto_function(targetLocation)\\n\\n #Stop action if we are no longer in guided mode.\\n while vehicle.mode.name == \\\"GUIDED\\\": \\n remainingDistance = get_distance_metres(vehicle.location.global_relative_frame, targetLocation)\\n #print \\\"Distance to target: \\\", remainingDistance\\n if remainingDistance <= shared.WP_RADIUS: #Just below target, in case of undershoot.\\n #print \\\"Reached target\\\"\\n break;\\n\\n time.sleep(0.5)\",\n \"def condition_forward_checking(csp, var) :\\n return False\",\n \"def condition_forward_checking(csp, var) :\\n return False\",\n \"def checkFieldMappings(self, param):\\n field_mappings = param.value\\n over_fields = []\\n fields_warning = ('The following visible field name(s) are' +\\n ' over 10 characters and will be shortened' +\\n ' automatically by ArcGIS: ')\\n for idx, val in enumerate(range(field_mappings.count)):\\n if field_mappings.getVisible(idx) == 'VISIBLE':\\n field = field_mappings.getNewName(idx)\\n if len(field) > 10:\\n over_fields.append(field)\\n if over_fields:\\n param.setWarningMessage(fields_warning + \\\", \\\".join(over_fields))\\n else:\\n param.clearMessage()\",\n \"def test_model_custom_field_editing_attribute_missing(self):\\n\\n try:\\n error = False\\n\\n # GIVEN invalid model field definition\\n # WHEN model gets executed in the system\\n class TestTestModel(models.Model):\\n name = AppModelCharField(max_length=256, blank=True, null=True)\\n\\n except Exception as e:\\n msg = e.args[0]\\n error = True\\n\\n # THEN error should be raised\\n self.assertTrue(error)\\n\\n # AND clear error description is present\\n ref_msg = 'Field editing statuses are missing for AppModelCharField; called from TestTestModel'\\n self.assertEqual(ref_msg, msg)\",\n \"def test_handle_flag_error(self):\\n pass\",\n \"def _WaitForField(self, field):\\n self._GaiaWebviewContext().WaitForJavaScriptCondition(\\n \\\"document.getElementById({{ field }}) != null && \\\"\\n \\\"!document.getElementById({{ field }}).hidden\\\",\\n field=field, timeout=20)\",\n \"def test_fields_effort_default_reference_unit_success(self, _mock_check):\\n field = EffortField(\\n time_units={\\\"minute\\\": (\\\"minute\\\", \\\"minutes\\\")},\\n default_reference_unit=\\\"minute\\\",\\n )\\n\\n errors = field.check()\\n self.assertEqual(len(errors), 0)\",\n \"def test_raises_if_missed_fields(self):\\n name = 'second'\\n self.form.called_handle_modifiers = False\\n remove = {'remove_field': name}\\n self.form.handle_modifiers({}, [], **remove)\\n self.assertNotIn(name, self.form.fields)\\n self.assertIn(name, self.form.hold_field)\\n message = \\\"Some unassigned fields, perhaps some added during handle_modifiers. \\\"\\n with self.assertRaisesMessage(ImproperlyConfigured, message):\\n self.form.make_fieldsets(add_field=name)\\n self.form.called_handle_modifiers = False\",\n \"def check_returnable_fields(fields, result):\\n returnable_fields = get_returnable_fields(result, verbose=False)\\n for field in fields:\\n if field not in returnable_fields:\\n err_str = \\\"The field %s is not a returnable field for \\\" % (field)\\n err_str += \\\"result %s\\\" % (result)\\n raise ValueError(err_str)\",\n \"def test_check_source_11(self):\\n self.src1._organism_host_genus = \\\"Mycobacterio\\\"\\n import_genome.check_source(self.src1, self.eval_flags,\\n host_genus=\\\"Mycobacterium\\\")\\n count = count_status(self.src1, \\\"error\\\")\\n self.assertEqual(count, 0)\",\n \"def test_parse_case_field_00(input_, expected):\\n actual = regex.match_case_field(input_)\\n assert actual == expected\",\n \"def _assert_reg_field(self, extra_fields_setting, expected_field):\\n # Add in fields that are always present\\n self._populate_always_present_fields(expected_field)\\n\\n # Retrieve the registration form description\\n with override_settings(REGISTRATION_EXTRA_FIELDS=extra_fields_setting):\\n response = self.client.get(self.url)\\n self.assertHttpOK(response)\\n\\n # Verify that the form description matches what we'd expect\\n form_desc = json.loads(response.content.decode('utf-8'))\\n\\n actual_field = None\\n for field in form_desc[\\\"fields\\\"]:\\n if field[\\\"name\\\"] == expected_field[\\\"name\\\"]:\\n actual_field = field\\n break\\n\\n self._assert_fields_match(actual_field, expected_field)\",\n \"def test_name_field(self):\\n field = self.record.find('field[@name=\\\\'name\\\\']')\\n self.assertEqual(field.text, 'GUH-ADT', 'Incorrect Name Field')\",\n \"def test_init_valid_field(self):\\n fields = {'Conn Note': {'offset': 0,\\n 'length': 20}}\\n parser = top.Parser(fields=fields)\\n received = parser.get_fields()\\n expected = fields\\n msg = 'Fields initialisation property setter/getter error.'\\n self.assertEqual(received, expected, msg)\",\n \"def link_check(form, field):\\n if form.registrable.data and len(field.data)==0:\\n raise validators.ValidationError('link should is required when the forum is registrable')\",\n \"def test_check_source_10(self):\\n self.src1._lab_host_host_genus = \\\"Gordonia\\\"\\n import_genome.check_source(self.src1, self.eval_flags,\\n host_genus=\\\"Mycobacterium\\\")\\n count = count_status(self.src1, \\\"error\\\", \\\"warning\\\")\\n self.assertEqual(count, 1)\",\n \"def test_field_value_pattern(self):\\n field = 'M*'\\n ref_idx = [0,1,2]\\n self.res=self.run_task(infile=self.rawfile,field=field,calmode=self.calmode,outfile=self.outname,outform='ASAP')\\n self.assertEqual(self.res,None,\\n msg='Any error occurred during calibration')\\n self._compare_with_analytic(self.outname, self.line, self.baseline, ref_idx)\",\n \"def check(self) -> None:\",\n \"def _test(self, c):\\n\\treturn self.UNRESOLVED\\t\\t# Placeholder\",\n \"def test_50(self):\\n assert 'False' == Api.requestBlock('test-50', CustomFields=True)\",\n \"def test_kyc_post_legal_board_member(self):\\n pass\",\n \"def inspect_melons(self,passed):\\n if passed == True:\\n self.passed_inspection = True\\n # return True\",\n \"def validate_field(self, fieldname):\\n fieldname = self.__class__.FIELD_ALIAS.get(fieldname, fieldname)\\n v = self._data[fieldname]\\n t = self._field_or_default_datatype(fieldname, v)\\n gfapy.Field._validate_gfa_field(v, t, fieldname)\",\n \"def test_raise_error_unknown_field():\\n\\n options = {'fields': ['kHello']}\\n\\n with pytest.raises(KeyError) as excinfo:\\n process.Packager(options)\\n excinfo.match('Field ([a-zA-Z].*) not found in file list.')\",\n \"def test_field_id_range(self):\\n field = '6~8'\\n ref_idx = [1,2,3]\\n self.res=self.run_task(infile=self.rawfile,field=field,calmode=self.calmode,outfile=self.outname,outform='ASAP')\\n self.assertEqual(self.res,None,\\n msg='Any error occurred during calibration')\\n self._compare_with_analytic(self.outname, self.line, self.baseline, ref_idx)\",\n \"def test_get_curr_bc_added_field_bc_and_added_field(self):\\r\\n\\r\\n curr_bc = \\\"GGCAGCACTTGT\\\"\\r\\n ids_bcs_added_field = {(\\\"AACTCGTCGATG\\\", \\\"123\\\"): \\\"s1\\\",\\r\\n (\\\"AGCAGCACTTGT\\\", \\\"123\\\"): \\\"s2\\\", (\\\"ACAGAGTCGGCT\\\", \\\"ABCD\\\"): \\\"s3\\\"}\\r\\n fasta_label = \\\"123ABC region=1 length=255\\\"\\r\\n all_bcs = [\\\"AACTCGTCGATG\\\", \\\"AGCAGCACTTGT\\\", \\\"ACAGAGTCGGCT\\\"]\\r\\n barcode_type = \\\"golay_12\\\",\\r\\n disable_bc_correction = False\\r\\n added_demultiplex_field = 'run_prefix'\\r\\n corrected_bc, num_errors, added_field =\\\\\\r\\n get_curr_bc_added_field(curr_bc, ids_bcs_added_field, fasta_label,\\r\\n all_bcs, barcode_type, disable_bc_correction, added_demultiplex_field)\\r\\n\\r\\n expected_corrected_bc = \\\"AGCAGCACTTGT\\\"\\r\\n expected_num_errors = 1\\r\\n expected_added_field = \\\"123\\\"\\r\\n\\r\\n self.assertEqual(corrected_bc, expected_corrected_bc)\\r\\n self.assertEqual(num_errors, expected_num_errors)\\r\\n self.assertEqual(added_field, expected_added_field)\",\n \"def test_get_field_state_comparisons_no_comp_states(self):\\r\\n self.assertRaises(ValueError, get_field_state_comparisons,\\r\\n self.dist_matrix_header, self.dist_matrix,\\r\\n self.mapping_header, self.mapping, self.field,\\r\\n [])\",\n \"def test_make_form_field():\",\n \"def test_single_field_failure(self, client):\\n with pytest.raises(CastorException) as e:\\n client.single_field_dependency(2)\\n assert str(e.value) == \\\"404 Entity not found.\\\"\",\n \"def test_clean_country_flag(self):\\n # country_flag = self.cleaned_data.get('country_flag', None)\\n # field = self.fields.get(self.country_field_name, None)\\n # if not field and hasattr(self, 'computed_fields'):\\n # field = self.computed_fields.get(self.country_field_name, None)\\n # if field.initial == self.cleaned_data.get(self.country_field_name, None)\\n pass\",\n \"def test_select_var_failed_if_bad_var_name(self):\\n with patch('esmvalcore.cmor._fixes.fix.Fix.get_fixes',\\n return_value=[]):\\n with self.assertRaises(ValueError):\\n fix_metadata(\\n cubes=[\\n self._create_mock_cube('not_me'),\\n self._create_mock_cube('me_neither')\\n ],\\n short_name='short_name',\\n project='CMIP6',\\n dataset='model',\\n mip='mip',\\n )\",\n \"def test_27(self):\\n assert 'False' == Api.requestBlock('test-27')\",\n \"def test_field_errors(self):\\n # For username field\\n response = self.client.post(reverse('users:login'), data={\\n 'username': 'username_that_not_exist',\\n 'password': '11111111',\\n })\\n error = BeautifulSoup(response.content, 'html.parser').find('p', 'username-error').text\\n\\n self.assertEqual(error, 'User with this username doesn\\\\'t exist.')\\n\\n # For password field\\n response = self.client.post(reverse('users:login'), data={\\n 'username': 'temp1',\\n 'password': '11111111',\\n })\\n error = BeautifulSoup(response.content, 'html.parser').find('p', 'non-field-error').text\\n\\n self.assertEqual(error, 'Enter correct password.')\",\n \"def test_field_id_exact(self):\\n field = '6'\\n ref_idx = [1]\\n self.res=self.run_task(infile=self.rawfile,field=field,calmode=self.calmode,outfile=self.outname,outform='ASAP')\\n self.assertEqual(self.res,None,\\n msg='Any error occurred during calibration')\\n self._compare_with_analytic(self.outname, self.line, self.baseline, ref_idx)\",\n \"def test_entities__Entity__getField__2(entity):\\n assert IDummy['dummy2'] == entity.getField('dummy2')\",\n \"def check_grue(self, tile):\\n if tile[2] == 'grue':\\n if self.lab.inventory > 0:\\n self.lab.fire()\\n print 'Lighted match'\",\n \"def test_fields(self):\\n form = self._get_form(data=None)\\n self.assertEquals(len(form.fields), 4)\\n self.assertTrue('tests_url' in form.fields)\\n self.assertTrue('repo_url' in form.fields)\\n self.assertTrue('pkg_type' in form.fields)\\n self.assertTrue('tags' in form.fields)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67638075","0.6552739","0.6286361","0.6170494","0.6125492","0.5995649","0.59449685","0.5715474","0.5527284","0.5455693","0.5430143","0.54134613","0.530795","0.530067","0.5265416","0.5247163","0.52226955","0.5134902","0.5128405","0.51222634","0.5118506","0.507991","0.5075934","0.50527847","0.5018151","0.50139004","0.50080955","0.5004106","0.49996462","0.49810272","0.49631077","0.49490714","0.49488705","0.49436623","0.49411398","0.4933822","0.49048606","0.4903577","0.4901436","0.48565638","0.48545098","0.4847694","0.4844615","0.4840407","0.48328698","0.48232615","0.48063648","0.4801461","0.47966552","0.47862187","0.47787786","0.477527","0.47694856","0.4769171","0.47661033","0.4760826","0.47604647","0.47596452","0.4757198","0.47549513","0.47540453","0.4751612","0.47429374","0.474126","0.474126","0.47311273","0.47303915","0.4725758","0.4721384","0.47154784","0.4711148","0.47098354","0.4702116","0.4690037","0.46880516","0.46824446","0.4680683","0.46739206","0.4670181","0.46625304","0.46610245","0.46421143","0.46420065","0.46413144","0.46402544","0.46368027","0.46341586","0.46294355","0.4628066","0.46272087","0.46271235","0.46258572","0.46227115","0.46120226","0.46105298","0.46054244","0.4604083","0.4601052","0.4600611","0.45975533"],"string":"[\n \"0.67638075\",\n \"0.6552739\",\n \"0.6286361\",\n \"0.6170494\",\n \"0.6125492\",\n \"0.5995649\",\n \"0.59449685\",\n \"0.5715474\",\n \"0.5527284\",\n \"0.5455693\",\n \"0.5430143\",\n \"0.54134613\",\n \"0.530795\",\n \"0.530067\",\n \"0.5265416\",\n \"0.5247163\",\n \"0.52226955\",\n \"0.5134902\",\n \"0.5128405\",\n \"0.51222634\",\n \"0.5118506\",\n \"0.507991\",\n \"0.5075934\",\n \"0.50527847\",\n \"0.5018151\",\n \"0.50139004\",\n \"0.50080955\",\n \"0.5004106\",\n \"0.49996462\",\n \"0.49810272\",\n \"0.49631077\",\n \"0.49490714\",\n \"0.49488705\",\n \"0.49436623\",\n \"0.49411398\",\n \"0.4933822\",\n \"0.49048606\",\n \"0.4903577\",\n \"0.4901436\",\n \"0.48565638\",\n \"0.48545098\",\n \"0.4847694\",\n \"0.4844615\",\n \"0.4840407\",\n \"0.48328698\",\n \"0.48232615\",\n \"0.48063648\",\n \"0.4801461\",\n \"0.47966552\",\n \"0.47862187\",\n \"0.47787786\",\n \"0.477527\",\n \"0.47694856\",\n \"0.4769171\",\n \"0.47661033\",\n \"0.4760826\",\n \"0.47604647\",\n \"0.47596452\",\n \"0.4757198\",\n \"0.47549513\",\n \"0.47540453\",\n \"0.4751612\",\n \"0.47429374\",\n \"0.474126\",\n \"0.474126\",\n \"0.47311273\",\n \"0.47303915\",\n \"0.4725758\",\n \"0.4721384\",\n \"0.47154784\",\n \"0.4711148\",\n \"0.47098354\",\n \"0.4702116\",\n \"0.4690037\",\n \"0.46880516\",\n \"0.46824446\",\n \"0.4680683\",\n \"0.46739206\",\n \"0.4670181\",\n \"0.46625304\",\n \"0.46610245\",\n \"0.46421143\",\n \"0.46420065\",\n \"0.46413144\",\n \"0.46402544\",\n \"0.46368027\",\n \"0.46341586\",\n \"0.46294355\",\n \"0.4628066\",\n \"0.46272087\",\n \"0.46271235\",\n \"0.46258572\",\n \"0.46227115\",\n \"0.46120226\",\n \"0.46105298\",\n \"0.46054244\",\n \"0.4604083\",\n \"0.4601052\",\n \"0.4600611\",\n \"0.45975533\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7532309"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":493,"cells":{"query":{"kind":"string","value":"Helper for boss science tests"},"document":{"kind":"string","value":"def _do_boss_science(self, nCall, nInfo, nWarn, nErr, nExp=1):\n self._update_cart(11, 'BOSS')\n cmdState = self.actorState.doBossScience\n cmdState.reinitialize(self.cmd)\n cmdState.nExp = nExp\n masterThread.do_boss_science(self.cmd, cmdState, myGlobals.actorState)\n self._check_cmd(2, nInfo, nWarn, nErr, True)"},"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 testBeliefs1sk(self):","def test_apply_endorsements(self):","def test_theft_and_stealing(self):","def healthcare():","def testBeliefs2sk(self):","def test_T01():","def test_alien_data(self):","def test_households_in_admin_unit(self):","def unitary_test():","def test_get_waivers(league):\n pass","def _test(self):","def _test(self):","def _test(self):","def _test(self):","def _test(self):","def test_art_from_taste_space(self):","def tests():","def test_let(self):","def test_bed(self):\n #TODO write bed tests","def test(self):\n pass","def test_get_boat(self):\n pass","def _test(self):\n pass","def _test(self):\n pass","def _test(self):\n pass","def test():","def test():","def test_observatory(lasco):\n assert lasco.observatory == \"SOHO\"","def test_dummy():","def exercise_b2_70():\r\n pass","def test_4_4_1_1(self):\n pass","def test_create_unexpected_problem(self):\n pass","def test_4():","def test_get_insumo(self):","def sth():","def test_title(names):","def exercise_b2_106():\r\n pass","def test_rules():","def exercise_b2_53():\r\n pass","def test(self):","def test(self):","def test_get_scenario(self):\n pass","def exercise_b2_52():\r\n pass","def test_subsystems(self):\n pass","def test_get_goal(self):\n pass","def test(self):\n raise NotImplementedError","def test_03_visit_special(self):","def test_T2():","def test_T2():","def test_T3():","def test_T3():","def test_T4():","def test_T4():","def exercise_b2_69():\r\n pass","def exercise_b2_107():\r\n pass","def test_5():","def test_get_solution(self):\n pass","def test():\n pass","def test_do_boss_science(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['boss_science'])\n nExp = 2\n self._do_boss_science(nExp, 35, 0, 0, nExp=nExp)","def test_get_game(self):\n pass","def test_submit_for_endorsement(self):","def getTestResults():","def test_guess_nutrition_by_dish_name(self):\n pass","def exercise_b2_56():\r\n pass","def test_something():","def test_T1():","def test_T1():","def test_quick_answer(self):\n pass","def test_observatory(eit_map):\n assert eit_map.observatory == \"SOHO\"","def test_get_by_name2(self):\n pass","def test_get_details7(self):\n pass","def exercise_b2_98():\r\n pass","def test_arc_smear(self):","def exercise_b2_95():\r\n pass","def test_3():","def test_T0():","def test_get_by_name1(self):\n pass","def test_kyc_get_legal(self):\n pass","def test_predictor():","def exercise_b2_27():\r\n pass","def test_get_scenarios(self):\n pass","def test_basic_execution(self):","def test_get_systems(self):\n pass","def test_initialization_of_homework_result_homework():\n assert result_1.homework == oop_hw","def test_initialization_of_homework_result_solution():\n assert result_1.solution == \"I have done this hw\"","def exercise_b2_113():\r\n pass","def test_create_system_entire(self):\n pass","def test_01_lighting(self):","def test_get1(self):\n pass","def describe():","def test_create_from_pear(self):\n pass","def test_create_boat(self):\n pass","def testNSESanityChecks(self):\n self.assertEqual(100, self.c.get_species_richness())\n self.assertEqual(67, self.c2.get_species_richness())","def test_gtf(self):\n #TODO write bed tests","def runtest(self):","def test_initialization_of_homework_result_author():\n assert result_1.author == good_student","def inner_test():\n pass","def inner_test():\n pass","def test_get_game_boxscore(self):\n pass","def test_get_run(self):\n pass","def test_if(self):","def test_require():"],"string":"[\n \"def testBeliefs1sk(self):\",\n \"def test_apply_endorsements(self):\",\n \"def test_theft_and_stealing(self):\",\n \"def healthcare():\",\n \"def testBeliefs2sk(self):\",\n \"def test_T01():\",\n \"def test_alien_data(self):\",\n \"def test_households_in_admin_unit(self):\",\n \"def unitary_test():\",\n \"def test_get_waivers(league):\\n pass\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def test_art_from_taste_space(self):\",\n \"def tests():\",\n \"def test_let(self):\",\n \"def test_bed(self):\\n #TODO write bed tests\",\n \"def test(self):\\n pass\",\n \"def test_get_boat(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def test():\",\n \"def test():\",\n \"def test_observatory(lasco):\\n assert lasco.observatory == \\\"SOHO\\\"\",\n \"def test_dummy():\",\n \"def exercise_b2_70():\\r\\n pass\",\n \"def test_4_4_1_1(self):\\n pass\",\n \"def test_create_unexpected_problem(self):\\n pass\",\n \"def test_4():\",\n \"def test_get_insumo(self):\",\n \"def sth():\",\n \"def test_title(names):\",\n \"def exercise_b2_106():\\r\\n pass\",\n \"def test_rules():\",\n \"def exercise_b2_53():\\r\\n pass\",\n \"def test(self):\",\n \"def test(self):\",\n \"def test_get_scenario(self):\\n pass\",\n \"def exercise_b2_52():\\r\\n pass\",\n \"def test_subsystems(self):\\n pass\",\n \"def test_get_goal(self):\\n pass\",\n \"def test(self):\\n raise NotImplementedError\",\n \"def test_03_visit_special(self):\",\n \"def test_T2():\",\n \"def test_T2():\",\n \"def test_T3():\",\n \"def test_T3():\",\n \"def test_T4():\",\n \"def test_T4():\",\n \"def exercise_b2_69():\\r\\n pass\",\n \"def exercise_b2_107():\\r\\n pass\",\n \"def test_5():\",\n \"def test_get_solution(self):\\n pass\",\n \"def test():\\n pass\",\n \"def test_do_boss_science(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['boss_science'])\\n nExp = 2\\n self._do_boss_science(nExp, 35, 0, 0, nExp=nExp)\",\n \"def test_get_game(self):\\n pass\",\n \"def test_submit_for_endorsement(self):\",\n \"def getTestResults():\",\n \"def test_guess_nutrition_by_dish_name(self):\\n pass\",\n \"def exercise_b2_56():\\r\\n pass\",\n \"def test_something():\",\n \"def test_T1():\",\n \"def test_T1():\",\n \"def test_quick_answer(self):\\n pass\",\n \"def test_observatory(eit_map):\\n assert eit_map.observatory == \\\"SOHO\\\"\",\n \"def test_get_by_name2(self):\\n pass\",\n \"def test_get_details7(self):\\n pass\",\n \"def exercise_b2_98():\\r\\n pass\",\n \"def test_arc_smear(self):\",\n \"def exercise_b2_95():\\r\\n pass\",\n \"def test_3():\",\n \"def test_T0():\",\n \"def test_get_by_name1(self):\\n pass\",\n \"def test_kyc_get_legal(self):\\n pass\",\n \"def test_predictor():\",\n \"def exercise_b2_27():\\r\\n pass\",\n \"def test_get_scenarios(self):\\n pass\",\n \"def test_basic_execution(self):\",\n \"def test_get_systems(self):\\n pass\",\n \"def test_initialization_of_homework_result_homework():\\n assert result_1.homework == oop_hw\",\n \"def test_initialization_of_homework_result_solution():\\n assert result_1.solution == \\\"I have done this hw\\\"\",\n \"def exercise_b2_113():\\r\\n pass\",\n \"def test_create_system_entire(self):\\n pass\",\n \"def test_01_lighting(self):\",\n \"def test_get1(self):\\n pass\",\n \"def describe():\",\n \"def test_create_from_pear(self):\\n pass\",\n \"def test_create_boat(self):\\n pass\",\n \"def testNSESanityChecks(self):\\n self.assertEqual(100, self.c.get_species_richness())\\n self.assertEqual(67, self.c2.get_species_richness())\",\n \"def test_gtf(self):\\n #TODO write bed tests\",\n \"def runtest(self):\",\n \"def test_initialization_of_homework_result_author():\\n assert result_1.author == good_student\",\n \"def inner_test():\\n pass\",\n \"def inner_test():\\n pass\",\n \"def test_get_game_boxscore(self):\\n pass\",\n \"def test_get_run(self):\\n pass\",\n \"def test_if(self):\",\n \"def test_require():\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6812872","0.6686834","0.6662029","0.66596895","0.6609597","0.655939","0.6549792","0.6543334","0.65167713","0.6514505","0.6439195","0.6439195","0.6439195","0.6439195","0.6439195","0.64386874","0.63926923","0.6362536","0.632096","0.6316661","0.6280583","0.62787473","0.62787473","0.62787473","0.6250387","0.6250387","0.6239162","0.62319994","0.62277293","0.62227726","0.6182341","0.61744124","0.6174265","0.6170803","0.6145204","0.6141071","0.6135324","0.6134568","0.61317664","0.61317664","0.61289835","0.6128308","0.6122706","0.61205626","0.6111555","0.60926104","0.6090884","0.6090884","0.6090731","0.6090731","0.6079427","0.6079427","0.60735434","0.6072674","0.6068866","0.6065172","0.6060398","0.6054843","0.60480833","0.6043743","0.60152835","0.60117936","0.6011772","0.6001377","0.5985093","0.5985093","0.5969813","0.59656733","0.5951016","0.59473294","0.5946892","0.5941503","0.5936585","0.5926208","0.59256935","0.59243804","0.591835","0.5904382","0.5899195","0.5892244","0.5885949","0.5884395","0.58831674","0.5878359","0.5873925","0.5871371","0.58698547","0.58581173","0.5856655","0.5848433","0.5845336","0.58447963","0.58409107","0.58359194","0.5834048","0.58330595","0.58330595","0.5828992","0.58145076","0.58131313","0.58125865"],"string":"[\n \"0.6812872\",\n \"0.6686834\",\n \"0.6662029\",\n \"0.66596895\",\n \"0.6609597\",\n \"0.655939\",\n \"0.6549792\",\n \"0.6543334\",\n \"0.65167713\",\n \"0.6514505\",\n \"0.6439195\",\n \"0.6439195\",\n \"0.6439195\",\n \"0.6439195\",\n \"0.6439195\",\n \"0.64386874\",\n \"0.63926923\",\n \"0.6362536\",\n \"0.632096\",\n \"0.6316661\",\n \"0.6280583\",\n \"0.62787473\",\n \"0.62787473\",\n \"0.62787473\",\n \"0.6250387\",\n \"0.6250387\",\n \"0.6239162\",\n \"0.62319994\",\n \"0.62277293\",\n \"0.62227726\",\n \"0.6182341\",\n \"0.61744124\",\n \"0.6174265\",\n \"0.6170803\",\n \"0.6145204\",\n \"0.6141071\",\n \"0.6135324\",\n \"0.6134568\",\n \"0.61317664\",\n \"0.61317664\",\n \"0.61289835\",\n \"0.6128308\",\n \"0.6122706\",\n \"0.61205626\",\n \"0.6111555\",\n \"0.60926104\",\n \"0.6090884\",\n \"0.6090884\",\n \"0.6090731\",\n \"0.6090731\",\n \"0.6079427\",\n \"0.6079427\",\n \"0.60735434\",\n \"0.6072674\",\n \"0.6068866\",\n \"0.6065172\",\n \"0.6060398\",\n \"0.6054843\",\n \"0.60480833\",\n \"0.6043743\",\n \"0.60152835\",\n \"0.60117936\",\n \"0.6011772\",\n \"0.6001377\",\n \"0.5985093\",\n \"0.5985093\",\n \"0.5969813\",\n \"0.59656733\",\n \"0.5951016\",\n \"0.59473294\",\n \"0.5946892\",\n \"0.5941503\",\n \"0.5936585\",\n \"0.5926208\",\n \"0.59256935\",\n \"0.59243804\",\n \"0.591835\",\n \"0.5904382\",\n \"0.5899195\",\n \"0.5892244\",\n \"0.5885949\",\n \"0.5884395\",\n \"0.58831674\",\n \"0.5878359\",\n \"0.5873925\",\n \"0.5871371\",\n \"0.58698547\",\n \"0.58581173\",\n \"0.5856655\",\n \"0.5848433\",\n \"0.5845336\",\n \"0.58447963\",\n \"0.58409107\",\n \"0.58359194\",\n \"0.5834048\",\n \"0.58330595\",\n \"0.58330595\",\n \"0.5828992\",\n \"0.58145076\",\n \"0.58131313\",\n \"0.58125865\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":494,"cells":{"query":{"kind":"string","value":"One call per requested exposure"},"document":{"kind":"string","value":"def test_do_boss_science(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['boss_science'])\n nExp = 2\n self._do_boss_science(nExp, 35, 0, 0, nExp=nExp)"},"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 endexposureloop(self):\n self.max_exposures = self.current_exposure","def observeField(target, exposure):\n\n status = 2\n real_exposure = exposure + np.random.normal(0.0, 20.0)\n realSN2 = target['DESsn2'] + np.random.uniform(0.0, 1.0)\n\n return status, real_exposure, realSN2","def expose(self):\n\n ## Determine type of exposure (exp, series, stack)\n exptype = str(self.exptypeComboBox.currentText())\n mode = self.modedict[exptype]\n\n ## Get exposure parameters\n if mode == \"bias\":\n exptime = 0.0\n else:\n exptime = self.exptimeSpinBox.value()\n imcount = self.imstackSpinBox.value()\n seqnum = self.imnumSpinBox.value()\n mintime = self.minexpSpinBox.value()\n maxtime = self.maxexpSpinBox.value()\n step = self.tstepSpinBox.value()\n\n ## Determine filter kwargs\n if self.filterToggleButton.isChecked():\n kwargs = {'filter_name' : str(self.filterComboBox.currentText())}\n else:\n kwargs = {'monowl' : self.monoSpinBox.value()}\n\n if self.testimCheckBox.isChecked():\n title = 'test'\n else:\n title = str(self.imtitleLineEdit.text())\n\n ## Build filepath\n filepath = os.path.join(str(self.imfilenameLineEdit.text()),title)\n \n ## Check if single exposure\n if exptype in [\"Exposure\", \"Dark\", \"Bias\"]:\n\n ## Perform exposure\n self.logger.info(\"Starting {0}s {1} image.\".format(exptime, exptype))\n self.image_start.emit(1)\n\n try:\n filename = exposure.im_acq(mode, filepath, exptime, seqnum, **kwargs)\n self.image_taken.emit(1)\n except subprocess.CalledProcessError:\n self.logger.exception(\"Error in executable {0}_acq. Image not taken.\".format(mode))\n except OSError:\n self.logger.exception(\"Executable {0}_acq not found. Image not taken\".format(mode))\n except IOError:\n self.logger.exception(\"File already exits. Image not taken.\")\n else:\n self.logger.info(\"Exposure {0} finished successfully.\".format(filename))\n self.seqnum_inc.emit(seqnum)\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename,\n '-zoom', 'to', 'fit', '-cmap', 'b'])\n\n ## Check if a stack of exposures of same type\n elif exptype in [\"Exposure Stack\", \"Dark Stack\", \"Bias Stack\"]:\n\n total = seqnum + imcount\n self.logger.info(\"Starting {0}s {1} stack.\".format(exptime, exptype))\n self.image_start.emit(imcount)\n\n try:\n for i in range(seqnum, total):\n self.logger.info(\"Starting image {0} of {1}.\".format(i+1-seqnum, imcount))\n filename = exposure.im_acq(mode, filepath, exptime, i, **kwargs)\n self.logger.info(\"Exposure {0} finished successfully.\".format(filename))\n self.image_taken.emit(i+1-seqnum)\n self.seqnum_inc.emit(i)\n except subprocess.CalledProcessError:\n self.logger.exception(\"Error in executable {0}_acq. Image not taken.\".format(mode))\n except OSError:\n self.logger.exception(\"Executable {0}_acq not found. Image not taken.\".format(mode))\n except IOError:\n self.logger.exception(\"File already exists. Image not taken.\")\n else:\n self.logger.info(\"Exposure stack finished successfully.\")\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename, '-zoom', 'to', 'fit', '-cmap', 'b'])\n \n ## Check if a series of exposures of increase exposure time\n elif exptype in [\"Exposure Series\", \"Dark Series\"]:\n\n ## Parameter checks\n if mintime > maxtime:\n self.logger.warning(\"Minimum time must be less than Maximum time. Series not started.\")\n return\n elif step <= 0:\n self.logger.warning(\"Time step must be greater than 0. Series not started.\")\n return\n\n ## Construct array of exposure times\n t = mintime\n time_array = []\n while t <= maxtime:\n time_array.append(t)\n t += step\n \n ## Perform series\n self.logger.info(\"Starting {0} series with mintime {1}, maxtime {2}, and step {3}.\".format(exptype, mintime, maxtime, step))\n self.image_start.emit(len(time_array))\n \n try:\n for i, time in enumerate(time_array):\n self.logger.info(\"Starting {0}s {1} image.\".format(time, mode))\n filename = exposure.im_acq(mode, filepath, time, seqnum, **kwargs)\n self.logger.info(\"Exposure {0} finished successfully.\".format(filename))\n self.image_taken.emit(i+1)\n except subprocess.CalledProcessError:\n self.logger.exception(\"Error in executable {0}_acq. Image not taken.\".format(mode))\n except OSError:\n self.logger.exception(\"Executable {0}_acq not found. Image not taken.\".format(mode))\n except IOError:\n self.logger.exception(\"File already exists. Image not taken.\")\n else:\n self.logger.info(\"Exposure series finished successfully.\")\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename, '-zoom', 'to', 'fit', '-cmap', 'b'])\n self.seqnum_inc.emit(seqnum)","def exp(self, exposure_time):\n print(f\"exp: {exposure_time}\")\n self.device_control.exposure = exposure_time\n yield","def expose(self, cmd, expTime, expType):\n\n if not expType:\n expType = 'test'\n if cmd:\n cmd.inform('exposureState=\"exposing\"')\n if expType not in ('bias', 'test') and expTime > 0:\n time.sleep(expTime + self._exposureOverheadTime())\n\n if cmd:\n cmd.inform('exposureState=\"reading\"')\n\n f = pyfits.open('/home/chyan/mhs/data/mcs/schmidt_fiber_snr400_rmod71.fits')\n image = f[0].data\n # image = numpy.random.normal(self.biasLevel,\n # scale=self.readNoise,\n # size=self.imageSize).astype('u2')\n\n if expType != 'test':\n time.sleep(self._readoutTime())\n return image","def exposure(frameType, expTime):\n\n blobEvent.clear() \n\n # set the specified frame type\n if frameType.lower() == 'light':\n ccd_frame[0].s = PyIndi.ISS_ON\n ccd_frame[1].s = PyIndi.ISS_OFF\n ccd_frame[2].s = PyIndi.ISS_OFF\n ccd_frame[3].s = PyIndi.ISS_OFF \n indiclient.sendNewSwitch(ccd_frame)\n elif frameType.lower() == 'bias':\n ccd_frame[0].s = PyIndi.ISS_OFF\n ccd_frame[1].s = PyIndi.ISS_ON\n ccd_frame[2].s = PyIndi.ISS_OFF\n ccd_frame[3].s = PyIndi.ISS_OFF \n indiclient.sendNewSwitch(ccd_frame)\n elif frameType.lower() == 'dark':\n ccd_frame[0].s = PyIndi.ISS_OFF\n ccd_frame[1].s = PyIndi.ISS_OFF\n ccd_frame[2].s = PyIndi.ISS_ON\n ccd_frame[3].s = PyIndi.ISS_OFF \n indiclient.sendNewSwitch(ccd_frame)\n elif frameType.lower() == 'flat':\n ccd_frame[0].s = PyIndi.ISS_OFF\n ccd_frame[1].s = PyIndi.ISS_OFF\n ccd_frame[2].s = PyIndi.ISS_OFF\n ccd_frame[3].s = PyIndi.ISS_ON \n indiclient.sendNewSwitch(ccd_frame)\n\n # set the value for the next exposure\n ccd_exposure[0].value=expTime\n\n indiclient.sendNewNumber(ccd_exposure)\n\n # wait for the exposure\n blobEvent.wait()\n\n for blob in ccd_ccd1:\n # pyindi-client adds a getblobdata() method to IBLOB item\n # for accessing the contents of the blob, which is a bytearray in Python\n image_data=blob.getblobdata()\n\n # write the byte array out to a FITS file\n global imgNum\n global imgName\n imgNum += 1\n fileName = fileDir+'raw-'+str(imgNum).zfill(8)+'.fits'\n f = open(fileName, 'wb')\n f.write(image_data)\n f.close()\n imgName = fileName\n \n return fileName","def runPass(self, exposure_range, rate):\n r = rospy.Rate(rate)\n for i, exposure in enumerate(exposure_range):\n if rospy.is_shutdown():\n break\n\n self.current_exposure = exposure\n self.client.update_configuration(\n {\"exposure\": self.current_exposure})\n r.sleep()\n\n finished = (i >= (len(exposure_range)-1))\n if finished:\n optimal_exposure = max(self.scores, key=self.scores.get)\n self.reset()\n return optimal_exposure # an optimal exposure has been found\n else:\n return -1","def call(self):","def get_exposure(exposure_id,b_mean,b_sd,c_mean,c_sd,non_rate,dist_type,mortalities):#id in db\n\te_id \t\t= int(long(exposure_id))\n\texposure_outcomes = DBHelper.exposure_outcome\n\toutcome_ids \t= DBHelper.exposure_outcome.get(e_id)\n\n\tsamples_rr \t= DBHelper.samples_rr.get(e_id)\n\tsamples_pop \t= DBHelper.samples_pop.get(e_id)\n\trisks \t\t= DBHelper.risks.get(e_id)\n\tmeasure \t= DBHelper.measures.get(e_id)\n\tdist_type \t= get_dist_type(e_id)\n\n\t#get population distribution \n\tpopDistribution = PopDistribution(DBHelper.age_group_num,non_rate,b_mean,b_sd,c_mean,c_sd,samples_pop,dist_type)\n\n\t#get outcomes\n\toutcomes = []\n\tfor o_id in outcome_ids:\n\t\t# mortality\n\t\tm_mortality = mortalities.get(2*o_id)\n\t\tf_mortality = mortalities.get(2*o_id+1)\n\t\t# risks\n\t\tm_risks = risks.get(2*o_id)\n\t\tf_risks = risks.get(2*o_id+1)\n\t\t# outcome name\n\t\tname = DBHelper.get_outcome_name(o_id)\n\t\t# limit estimates\n\t\tlle = DBHelper.exposure_outcome.get(e_id).get(o_id)[0]\n\t\tule = DBHelper.exposure_outcome.get(e_id).get(o_id)[1]\n\t\t# outcome\n\t\toutcome = PrimeOutcome(name,o_id,m_mortality,f_mortality,samples_rr,m_risks,f_risks,lle,ule,measure,e_id) \n\t\toutcomes.append(outcome)\n\n\texposure = PrimeExposure(mortalities,outcome_ids,samples_rr,samples_pop,outcomes,popDistribution)\n\treturn exposure","def hit(self):","def _generate_exposure(self, expstart, number):\n\n index_number = number - 1 # for zero indexing\n\n filename = '{:04d}_raw.fits'.format(number)\n\n exp_gen = ExposureGenerator(self.detector, self.grism, self.NSAMP,\n self.SAMPSEQ, self.SUBARRAY,\n self.planet, filename, expstart)\n\n if not self.spatial_scan:\n self.sample_rate = 1 * u.year # high number reverts to read times\n\n _, sample_mid_points, sample_durations, read_index = \\\n exp_gen._gen_scanning_sample_times(self.sample_rate)\n\n time_array = (sample_mid_points + expstart).to(u.day)\n\n if self.transmission_spectroscopy:\n star_norm_flux = self.generate_lightcurves(time_array)\n planet_depths = 1 - star_norm_flux\n else:\n planet_depths = None\n\n # x shifts - linear shift with exposure, second exposure shifted by\n # x_shifts, direct image and first exp will match.\n x_ref = self._try_index(self.x_ref, index_number)\n y_ref = self._try_index(self.y_ref, index_number)\n sky_background = self._try_index(self.sky_background, index_number)\n\n # X and Y Shifts\n x_ref += self.x_shifts * index_number\n y_ref += self.y_shifts * index_number\n x_jitter = self.x_jitter\n y_jitter = self.y_jitter\n\n if self._visit_trend:\n scale_factor = self._visit_trend.get_scale_factor(index_number)\n else:\n scale_factor = None\n\n if self.spatial_scan:\n exp_frame = exp_gen.scanning_frame(\n x_ref, y_ref, x_jitter, y_jitter,\n self.wl, self.stellar_flux, planet_depths,\n self.scan_speed, self.sample_rate, sample_mid_points,\n sample_durations, read_index, ssv_generator=self.ssv_gen,\n noise_mean=self.noise_mean, noise_std=self.noise_std,\n add_flat=self.add_flat, add_dark=self.add_dark,\n scale_factor=scale_factor, sky_background=sky_background,\n cosmic_rate=self.cosmic_rate,\n add_gain_variations=self.add_gain_variations,\n add_non_linear=self.add_non_linear,\n clip_values_det_limits=self.clip_values_det_limits,\n add_read_noise=self.add_read_noise,\n add_stellar_noise=self.add_stellar_noise,\n add_initial_bias=self.add_initial_bias,\n progress_bar=self.progess,\n threads=self.threads\n )\n else:\n exp_frame = exp_gen.staring_frame(\n x_ref, y_ref, x_jitter, y_jitter,\n self.wl, self.stellar_flux, planet_depths,\n sample_mid_points, sample_durations, read_index,\n noise_mean=self.noise_mean, noise_std=self.noise_std,\n add_flat=self.add_flat, add_dark=self.add_dark,\n scale_factor=scale_factor, sky_background=sky_background,\n cosmic_rate=self.cosmic_rate,\n add_gain_variations=self.add_gain_variations,\n add_non_linear=self.add_non_linear,\n clip_values_det_limits=self.clip_values_det_limits,\n add_read_noise=self.add_read_noise,\n add_stellar_noise=self.add_stellar_noise,\n add_initial_bias=self.add_initial_bias,\n progress_bar=self.progess,\n threads=self.threads\n )\n\n exp_frame.generate_fits(self.outdir, filename, ldcoeffs=self.ldcoeffs)\n\n return exp_frame","def tcs_exposure_request(image_type, duration = 0, number = 1):\n\n\tvalid_types = ['THERMAL','DARK', 'BIAS', 'FLAT','OBJECT']\n\tvalid = image_type in valid_types\n\n\tif valid:\n\t\timage_type = image_type.lower()\n\t\tif image_type == 'dark':\n\t\t\timage_type = 'thermal'\n\n\t\tif number < 1:\n\t\t\tlogger.error('Invalid number of exposures requested')\n\t\t\trespond = set_err_codes.STATUS_CODE_EXPOSURE_NOT_STARTED\n\t\t\treturn respond\n\n\t\tif duration <0:\n\t\t\tlogger.error('Invalid exposure time requested')\n\t\t\trespond = set_err_codes.STATUS_CODE_EXPOSURE_NOT_STARTED\n\t\t\treturn respond\n\n\t\tcommand_str = 'expose ' + image_type\n\t\tif number != 1:\n\t\t\tcommand_str += ' '+str(number)\n\t\tif image_type != 'bias':\n\t\t\tcommand_str += ' ' + str(duration)\n\t\t\n\t\ttry:\n\t\t\ttcs_respond = send_command(command_str)\n\t\t\n\t\texcept:\n\t\t\trespond = set_err_codes.STATUS_CODE_EXPOSURE_NOT_STARTED\n\t\telse:\n\t\t\t\n\t\t\tcam_temp = get_camera_status()[2]\n\t\t\t#if good_response and cam_temp>-20:\n\t\t\tif float(cam_temp)>-20:\n\t\t\t\trespond = set_err_codes.STATUS_CODE_CCD_WARM\n\t\n\t\t\telse:\n\t\t\t\trespond = set_err_codes.STATUS_CODE_OK\n\t\t\t\n\t\treturn respond\n\n\telse:\n\t\tlogger.error('Invalid image type provided to exposure request '+str(\n\t\t\t\timage_type))\n\t\tprint('Invalid image type provided to exposure request'+str(\n\t\t\timage_type))","def run_observation(self):\n\n self._generate_direct_image() # to calibrate x_ref and y_ref\n\n num_frames = len(self.exp_start_times)\n progress = Progress(num_frames)\n self.progess = progress\n\n progress_line = 'Generating frames 0/{} done'.format(num_frames)\n progress.print_status_line(progress_line)\n progress.progress_line = progress_line\n\n for i, start_time in enumerate(self.exp_start_times):\n filenum = i + 1\n self._generate_exposure(start_time, filenum)\n\n progress.increment()\n progress_line = 'Generating frames {}/{} done'.format(filenum,\n num_frames)\n progress.print_status_line(progress_line)\n\n # so it can be retreived by exposure_generator\n progress.progress_line = progress_line","def exposureCallback(self, config):\n rospy.loginfo('Set exposure: {}'.format(config['exposure']))","def exposure(cls, *args):\n return cls.path_finder('exposure', *args)","def exposure(cls, *args):\n return cls.path_finder('exposure', *args)","def _do_expose_loop(self, fitsfile, seconds):\n log.debug(f\"Starting expose loop with {self.max_exposures} exposures\")\n while (self.current_exposure is not None and \n self.current_exposure < self.max_exposures):\n self.current_exposure += 1\n self.Expose(fitsfile, seconds)\n while self.process and self.process.poll() is None:\n sleep(5)\n if not self.process or self.process.returncode != 0:\n break\n \n self.current_exposure = None\n self.max_exposures = None","def exposure():\n def r(x):\n return x/6e4\n\n def w(x):\n return int(x*6e4)\n return r, w","def exposure(self):\n\n # define a range of declination to evaluate the\n # exposure at\n self.declination = np.linspace(-np.pi/2, np.pi/2, self.num_points)\n\n m = np.asarray([m_dec(d, self.params) for d in self.declination])\n \n # normalise to a maximum at 1\n self.exposure_factor = (m / m_dec(-np.pi/2, self.params))\n\n # find the point at which the exposure factor is 0\n self.limiting_dec = Angle((self.declination[m == 0])[0], 'rad')","def select_exposure(self):\n exp1_selected = self.exp1_radio.isChecked()\n\n if self.recording_sequence:\n self.record_sequence() # stop current recording\n\n if exp1_selected: # then exp1\n ifi_ndx = self.exp1_ifi_select.currentIndex()\n self.camera.set_exposure(self.exp1_select.currentIndex(), ifi_ndx)\n else:\n ifi_ndx = self.exp2_ifi_select.currentIndex()\n self.camera.set_exposure(self.exp2_select.currentIndex(), ifi_ndx)\n\n temp = list(self.dpar.iwindow_toggle_save)\n self.dpar.iwindow_toggle_save = list(self.dpar.iwindow[0])\n self.dpar.iwindow[0] = temp\n self._update_scrollbars()\n\n self.rec_seq_button.setEnabled(ifi_ndx > 0)\n\n et = np.int(np.round(self.camera.actual_exposure_time_ms))\n self.write_to_log('Exposure %d ms' % et)","def apply(self):","def access():","def selectOptimalExposureCallback(self):\n rospy.loginfo('Starting automatic exposure selection algorithm')\n\n # Start searching for the optimal exposure\n best_exp_pass1 = self.runPass(range(100, 27100, 3000), rate=self.rate)\n # first pass, find coarse exposure\n if best_exp_pass1 > 0:\n rospy.loginfo('First pass: success!')\n rospy.loginfo(\n 'Best exposure in first pass: {}'.format(best_exp_pass1))\n\n # second pass, refine the exposure\n exp_range = [int(exp) for exp in np.linspace(\n 0.9*best_exp_pass1, 1.1*best_exp_pass1, 10)]\n best_exp_pass2 = self.runPass(exp_range, rate=self.rate)\n\n if best_exp_pass2 > 0:\n rospy.loginfo('Second pass: success!')\n rospy.loginfo(\n 'Best exposure in second pass: {}'.format(best_exp_pass2))\n optimal_exposure = best_exp_pass2\n else:\n rospy.logerr(\n 'Second pass: failure\\nSetting the best exposure found in first pass')\n optimal_exposure = best_exp_pass1\n\n self.client.update_configuration({\"exposure\": optimal_exposure})\n self.reset()\n\n else:\n rospy.logerr(\n 'First pass: failure\\nCould not auto-set the exposure')","def expose(self, cmd):\n\n expType = cmd.cmd.keywords[0].name\n if expType in ('bias', 'test'):\n expTime = 0.0\n else:\n expTime = cmd.cmd.keywords[\"expTime\"].values[0]\n\n filename, image = self._doExpose(cmd, expTime, expType)\n cmd.finish('exposureState=done')","def request_access(self):\n pass","def exp_scan(self, exposure_time_list):\n self.generic_scan(self.exp, exposure_time_list)","def __call__(self):\n if grinder.runNumber == 0: self.initialSleep()\n (param1, param2) = self.getParam()\n self.request1(param1, param2)","def set_exposure(self, exposure):\n self.logger.info(f'Setting exposure to {exposure}')\n self._driver.ExposureTime.SetValue(exposure)","def __call__(self,sensation,reward=None):\n raise NYI","def apply(self):\r\n return","def apply(self):\r\n return","def apply(self):\r\n return","def apply(self):\r\n return","def apply(self):\r\n return","def explore_action():\n # def get_action(o, noise_scale):\n # a = ac.act(torch.as_tensor(o, dtype=torch.float32))\n # a += noise_scale * np.random.randn(act_dim)\n # return np.clip(a, -act_limit, act_limit)\n raise NotImplementedError","def toggle_exposure(self):\n\n checked1 = self.exp1_radio.isChecked()\n if checked1:\n self.exp2_radio.setChecked(True)\n else:\n self.exp1_radio.setChecked(True)\n self.select_exposure()","def apply(self) -> None:","def apply(self) -> None:","def expose(self):\n if self.camera is None: # test mode -- immediately return test image\n print(\"NO SPECTRAL CAMERA FOUND -- USING TEST DATA\")\n self.filename = \"example_fits_files/Mooi\"\n return\n\n exposure_time = self.time.get()\n try:\n self.exposure_time = float(exposure_time)\n except:\n message = \"Exposure time \\\"{0}\\\" cannot be converted to floating point number\".format(exposure_time)\n messagebox.showerror(\"Error\", message)\n raise ValueError(message)\n filename = \"spectra/{0}\".format(timestamp())\n self.camera.spectrum(self.exposure_time, filename)\n self.filename = filename","def run(self, exposure, sources):\n with self.distortionContext(exposure, sources) as bbox:\n results = self.astrometry(exposure, sources, bbox=bbox)\n\n if results.matches:\n self.refitWcs(exposure, sources, results.matches)\n\n return results","def __call__(self, frame_num):\n # propagate and set the density\n self.img.set_array(\n np.abs(self.quant_sys.propagate(10)) ** 2\n )\n return self.img,","def on_start(self):\r\n self.start_whole_exposure()","def apply(self):\n pass","def apply(self):\n pass","def falcon():","def apply(self, request):\n raise NotImplementedError(u\"%s: Method not implemented\",\n self.__class__.__name__)","def experiment(self) -> Any:","def _step(self, action):\n \n obs, reward, done, info = self.env.step(action)\n\n \n advice=self.generateAdvice()[1]\n\n obs = {\n \"image\": obs,\n \"advice\": advice\n }\n\n\n \n\n\n\n return obs, reward, done, info","def collect_data(self,sensation,action,reward,next_sensation):\n pass","async def expose(obj, exptime, outfile, overwrite):\n\n async with obj['camera_system'] as fli:\n\n log.debug('starting camera exposures ... ')\n exposures = await asyncio.gather(*[camera.expose(exptime)\n for camera in fli.cameras],\n return_exceptions=False)\n\n log.debug('writing images to disk ... ')\n writers = []\n for exposure in exposures:\n if outfile:\n outfile = outfile.format(camera=exposure.camera)\n writers.append(exposure.write(filename=outfile,\n overwrite=overwrite))\n else:\n writers.append(exposure.write(overwrite=overwrite))\n\n await asyncio.gather(*writers, return_exceptions=True)","def next_point(self):\n if self.verbose:\n print(\"Computing acquisition function...\")\n if self.acquisition_function == 'cb':\n acq, pred = acqfunc.confidence_bound(\n self.surrogate_model, self.X_full,\n alpha=self.alpha, beta=self.beta)\n elif self.acquisition_function == 'ei':\n acq, pred = acqfunc.expected_improvement(\n self.surrogate_model, self.X_full,\n self.X_sparse, xi=self.xi)\n elif self.acquisition_function == 'poi':\n acq, pred = acqfunc.probability_of_improvement(\n self.surrogate_model, self.X_full,\n self.X_sparse, xi=self.xi)\n elif isinstance(self.acquisition_function, types.FunctionType):\n acq, pred = self.acquisition_function(\n self.surrogate_model, self.X_full, self.X_sparse)\n else:\n raise NotImplementedError(\n \"Choose between 'cb', 'ei', and 'poi' acquisition functions or define your own\")\n self.gp_predictions.append(pred)\n if self.mask is None:\n indices_list = np.unravel_index(np.argsort(acq.ravel()), acq.shape)\n vals_list = acq[indices_list][::-1][:self.batch_size].tolist()\n indices_list = np.dstack(indices_list)[0][::-1][:self.batch_size].tolist()\n else:\n acq = self.mask*acq\n indices_list = np.unravel_index(np.argsort(acq.ravel()), acq.shape)\n vals_list = acq[indices_list]\n vals_list = vals_list[~np.isnan(vals_list)][::-1]\n indices_list = np.dstack(indices_list)[0]\n indices_list = indices_list[:len(vals_list)][::-1]\n vals_list = vals_list[:self.batch_size].tolist()\n indices_list = indices_list[:self.batch_size].tolist()\n if not self.batch_update:\n return vals_list, indices_list\n if self.batch_dscale is None:\n batch_dscale_ = self.surrogate_model.model.kernel.lengthscale.mean().item()\n else:\n batch_dscale_ = self.batch_dscale\n vals_list, indices_list = self.update_points(\n vals_list, indices_list, batch_dscale_)\n return vals_list, indices_list","def factor_exposure(asset: Asset, risk_model_id: str, factor_name: str, *,\n source: str = None, real_time: bool = False, request_id: Optional[str] = None) -> pd.Series:\n risk_model = RiskModel(risk_model_id)\n factor = Factor(risk_model_id, factor_name)\n if factor.factor is None or risk_model_id != factor.risk_model_id:\n raise MqValueError('Requested factor not available in requested risk model')\n\n asset_gsid = asset.get_identifiers().get('GSID')\n\n # Establish date interval for data query\n dates = risk_model.get_dates()\n start_date = dt.datetime.strptime(min(dates), \"%Y-%m-%d\").date() if dates else None\n end_date = dt.datetime.strptime(max(dates), \"%Y-%m-%d\").date() if dates else None\n\n # Query data and append pull requested factor exposure\n all_exposures = []\n query_results = risk_model.get_data(\n measures=[Measure.Factor_Name, Measure.Universe_Factor_Exposure, Measure.Asset_Universe],\n start_date=start_date,\n end_date=end_date,\n assets=DataAssetsRequest(identifier=AssetUniverseIdentifier.gsid, universe=[asset_gsid])).get('results', [])\n for result in query_results:\n if result.get('date') in dates:\n exposures = result.get('assetData', {}).get('factorExposure', [])\n if exposures:\n all_exposures.append(\n {'date': result['date'],\n 'factorExposure': exposures[0].get(factor.factor.identifier)})\n\n # Create and return timeseries\n df = pd.DataFrame(all_exposures)\n df.set_index('date', inplace=True)\n df.index = pd.to_datetime(df.index)\n return _extract_series_from_df(df, QueryType.FACTOR_EXPOSURE)","def _doExpose(self, cmd, expTime, expType):\n \n image = self.actor.camera.expose(cmd, expTime, expType)\n filename = self.getNextFilename(cmd)\n pyfits.writeto(filename, image, checksum=False, clobber=True)\n cmd.inform(\"filename=%s\" % (qstr(filename)))\n \n return filename, image","def refresh_index_page_filter_by(request, exposure_sequence):","def continue_with_exposure(self):\r\n # Allocate space to give to scan_until_abort, and name the two\r\n # rows appropriately.\r\n self.data_pair = self.cam.get_new_array(n_images=2)\r\n self.pump_probe_data = self.data_pair[0]\r\n self.probe_only_data = self.data_pair[1]\r\n # Keep track of which image will be updated next\r\n self.next_data_has_pump = True\r\n\r\n # Tell self.thread what to do when the camera has new images\r\n self.cam.new_images.connect(self.send_new_images)\r\n\r\n # Get the current array of wavelengths from cam\r\n self.wavelen_arr = self.cam.get_wavelen_array()\r\n\r\n # Queue a call to cam.scan_until_abort\r\n self.startAcq.emit(self.data_pair)\r\n\r\n # Tell listeners (plotting widgets) to start displaying data too\r\n self.startDisplay.emit()","def any_image(self, index):\n self.__accessed_image[index] = True\n return self.__image(index)","def __exp1_changed_callback(self, ndx):\n if self.recording_sequence:\n self.record_sequence()\n self.exp1_radio.setChecked(True)\n self.exp1_ifi_select.setCurrentIndex(0)\n self.camera.set_exposure(ndx, 0)\n self.rec_seq_button.setEnabled(False)\n et = np.int(np.round(self.camera.actual_exposure_time_ms))\n self.write_to_log('Exposure %d ms' % et)","async def integrate(self, exposure_time=1):\n if not self.status == ControllerStatus.IDLE:\n raise ArchonError(\"Status must be IDLE to start integrating.\")\n\n await self.set_param(\"IntMS\", int(exposure_time * 1000))\n await self.set_param(\"Exposures\", 1)\n\n self.status = ControllerStatus.EXPOSING","def _apphot_one(args):\n return apphot_one(*args)","def run(self):\n self.cause_dispatch() # generate one dispatch before temporarily disabling CENTRAL_DISPATCH\n settings.DISPATCH_ENABLED = False\n bare_specdata_list = self._compute_bare_specdata_sweep()\n dressed_specdata = self._compute_dressed_specdata_sweep(bare_specdata_list)\n self._lookup = spec_lookup.SpectrumLookup(self, dressed_specdata, bare_specdata_list)\n settings.DISPATCH_ENABLED = True","def __init__(self, exposure = -1):\n self.cam = None\n self.exposure = exposure\n\n self._set_camera()","def single_step(self, *args):\n e = args[0]\n if self.verbose:\n print(\"\\nExploration step {} / {}\".format(\n e+1, self.exploration_steps))\n # train with seeded data\n if e == 0:\n self.surrogate_model.train()\n # calculate acquisition function and get next query points\n vals, inds = self.next_point()\n if not self.batch_update:\n inds, vals = self.checkvalues(inds, vals)\n # evaluate function\n self.evaluate_function(inds)\n # update posterior\n self.update_posterior()\n # store indices and values\n if isinstance(vals, float):\n self.indices_all.append(inds)\n self.vals_all.append(vals)\n else:\n self.indices_all.extend(inds)\n self.vals_all.extend(vals)\n return","def __call__(self):\n return self.shoot()","def run(self) -> None:\n self.cause_dispatch() # one dispatch before temp. disabling CENTRAL_DISPATCH\n settings.DISPATCH_ENABLED = False\n bare_specdata_list = self._compute_bare_specdata_sweep()\n dressed_specdata = self._compute_dressed_specdata_sweep(bare_specdata_list)\n self._lookup = spec_lookup.SpectrumLookup(\n self, dressed_specdata, bare_specdata_list\n )\n settings.DISPATCH_ENABLED = True","def run_single_camera(cam):\n\n try:\n # Retrieve TL device nodemap and print device information\n #nodemap_tldevice = cam.GetTLDeviceNodeMap()\n\n #result &= print_device_info(nodemap_tldevice)\n\n # Initialize camera\n cam.Init()\n\n # Retrieve GenICam nodemap\n nodemap = cam.GetNodeMap()\n exposures=[2000,4000,8000,16000]\n index=0\n if cam.ExposureAuto.GetAccessMode() != PySpin.RW:\n print(\"Unable to disable automatic exposure. Aborting...\")\n return False\n node_acquisition_mode = PySpin.CEnumerationPtr(nodemap.GetNode(\"AcquisitionMode\"))\n if not PySpin.IsAvailable(node_acquisition_mode) or not PySpin.IsWritable(node_acquisition_mode):\n print(\"Unable to set acquisition mode to continuous (enum retrieval). Aborting...\")\n return False\n\n # Retrieve entry node from enumeration node\n node_acquisition_mode_continuous = node_acquisition_mode.GetEntryByName(\"Continuous\")\n if not PySpin.IsAvailable(node_acquisition_mode_continuous) or not PySpin.IsReadable(node_acquisition_mode_continuous):\n print(\"Unable to set acquisition mode to continuous (entry retrieval). Aborting...\")\n return False\n\n acquisition_mode_continuous = node_acquisition_mode_continuous.GetValue()\n\n node_acquisition_mode.SetIntValue(acquisition_mode_continuous)\n\n print(\"Acquisition mode set to continuous...\")\n\n cam.ExposureAuto.SetValue(PySpin.ExposureAuto_Off)\n '''\n # Set maximum width\n #\n # *** NOTES ***\n # Other nodes, such as those corresponding to image width and height,\n # might have an increment other than 1. In these cases, it can be\n # important to check that the desired value is a multiple of the\n # increment.\n #\n # This is often the case for width and height nodes. However, because\n # these nodes are being set to their maximums, there is no real reason\n # to check against the increment.\n if cam.Width.GetAccessMode() == PySpin.RW and cam.Width.GetInc() != 0 and cam.Width.GetMax != 0:\n cam.Width.SetValue(FRAME_WIDTH)\n print(\"Width set to %i...\" % cam.Width.GetValue())\n\n else:\n print(\"Width not available...\")\n result = False\n\n # Set maximum height\n #\n # *** NOTES ***\n # A maximum is retrieved with the method GetMax(). A node's minimum and\n # maximum should always be a multiple of its increment.\n if cam.Height.GetAccessMode() == PySpin.RW and cam.Height.GetInc() != 0 and cam.Height.GetMax != 0:\n cam.Height.SetValue(FRAME_HEIGHT)\n print(\"Height set to %i...\" % cam.Height.GetValue())\n\n else:\n print(\"Height not available...\")\n result = False\n '''\n print(\"Automatic exposure disabled...\")\n #node_acquisition_framerate = PySpin.CFloatPtr(nodemap.GetNode(\"AcquisitionFrameRate\"))\n\n # if not PySpin.IsAvailable(node_acquisition_framerate) and not PySpin.IsReadable(node_acquisition_framerate):\n # print(\"Unable to retrieve frame rate. Aborting...\")\n # return False\n\n # framerate_to_set = node_acquisition_framerate.GetValue()\n\n # print(\"Frame rate to be set to %d...\" % framerate_to_set)\n canvas=np.zeros((FRAME_HEIGHT*2,FRAME_WIDTH*2,3), np.uint8)\n while True:\n exposure=exposures[index]\n \n configure_exposure(cam, exposure)\n # Acquire images\n err, img,width,height = acquire_images(cam, nodemap)\n if err < 0:\n return err\n\n \n img = img.GetData().reshape(height,width,3)\n\n half_height = int(height/2)\n half_width = int(width/2)\n half_frame_height = int(FRAME_HEIGHT/2)\n half_frame_width = int(FRAME_WIDTH/2)\n \n img = img[half_height-half_frame_height:half_height+half_frame_height,half_width-half_frame_width:half_width+half_frame_width]\n #smallimg=cv2.resize(img,(int(FRAME_WIDTH/2),int(FRAME_HEIGHT/2)))\n if index==0:\n #top left\n canvas[0:FRAME_HEIGHT,0:FRAME_WIDTH]=img\n elif index==1:\n #top right\n canvas[0:FRAME_HEIGHT,FRAME_WIDTH:FRAME_WIDTH*2]=img\n elif index==2:\n #bot left\n canvas[FRAME_HEIGHT:FRAME_HEIGHT*2,0:FRAME_WIDTH]=img\n else:\n #bot right\n canvas[FRAME_HEIGHT:FRAME_HEIGHT*2,FRAME_WIDTH:FRAME_WIDTH*2]=img\n index+=1\n if index>=len(exposures):\n index=0\n\n cv2.imshow(\"frame\",canvas)\n if cv2.waitKey(1) &0xff ==ord('q'):\n #stop the feed the 'q'\n break\n cv2.destroyAllWindows()\n # Deinitialize camera\n cam.DeInit()\n\n except PySpin.SpinnakerException as ex:\n print(\"Error: %s\" % ex)\n result = False","def one(self):","def perform(self):\n pass","def refresh_counterfactual_url_json(request, is_json):\t\n\tif is_json != 'json':\n\t\treturn\n\n #json_file = '/home/zhou/Downloads/jsons/only/json_7.json'\n json_file = '/home/zhou/Downloads/jsons/compound/json_9.json'\n\t#json_file = '/Users/jiaozi/Downloads/jsons/compound/json_2.json' #json file address\n exposure_sequence = read_json(json_file)#list of exposures{mean,sd,non_rate}, read json content into memory\n\n\tprimeCoordinator.get_counterfactual_compound_exposures(exposure_sequence)\n\t\n\n\t'''\n\t\tFor interface output data format, please refer to refresh_output_counterfactual_mortality. When a user clicks on age/gender/outcome, he can view mortalities in different formats\n It refreshes final compound mortality for output, it should be the counterfactual mortality of the final exposure.\n In order to show mortality by age/outcome/gender, there should be three lists.\n 1. Show by age/population_subset \n All information to present on a webpage is stored in variable 'output_all_mortality_exposure_age', the format of this variable is [{'population_subset_id':1,'age_group':'15-19','b_mortality_sum_db':757,'c_mrtality_sum':341}] \n 2. Show by outcome \n All information to present on a webpage is stored in variable 'output_all_mortality_exposure_outcome', the format of this variable is [{'o_id':1,'name':'Stroke','b_mortality_sum_db':24757,'c_mrtality_sum':23415}] \n 3. Show by gender \n All information to present on a webpage is stored in variable 'output_all_mortality_exposure_gender', the format of this variable is [{'gender':'male','b_mortality_sum_db':24757,'c_mrtality_sum':415}] \n\n\t'''\n\t#filter_by\t= request.POST['filter-by'] \n\tfilter_by\t= request.GET\n\tby\t\t= request.POST\n\tprint filter_by\n\tprint by\n\n\t# get the data in the interface\n\tb_output_mortality \t= primeCoordinator.output_baseline_mortality\n\tb_output_mortality_num \t= primeCoordinator.output_baseline_mortality_num\n\tb_total_mortality \t= primeCoordinator.output_baseline_mortality_total\n\tc_output_mortality \t= primeCoordinator.output_counterfactual_mortality\n\tc_output_mortality_num \t= primeCoordinator.output_counterfactual_mortality_num\n\tc_total_mortality \t= primeCoordinator.output_counterfactual_mortality_total\n\ttotal_population\t= primeCoordinator.output_total_population\n\ttotal_death_averted\t= str(int(round(primeCoordinator.output_total_death_averted))) # int\n\t#total_death_averted\t= str(primeCoordinator.output_total_death_averted) # decimale\n\ttotal_death_baseline\t= str(primeCoordinator.output_total_death_baseline)\n\n\t'''\n\t\tThis is the outputs when user click outcome\n\t'''\n\tall_mortality_exposure\t= primeCoordinator.output_all_mortality_exposure_outcome # [{'outcome_id':outcome_id,'name':outcome name,'baseline_death':100, 'counterfactual_death':20},{}] \n\n\t'''\n\t\tThis is the output when user click age\n\t'''\n\tall_mortality_age\t= primeCoordinator.output_all_mortality_age # [{'age_group_id':age_group_id,'age_group':age_group,'baseline_death':100, 'counterfactual_death':20},{}] \n\n\t'''\n\t\tThis is the outputs when user click gender \n\t'''\n\tall_mortality_gender\t= primeCoordinator.output_all_mortality_gender# [{'gender':'male','baseline_death':100, 'counterfactual_death':20},{'gender':'female','baseline_death':100, 'counterfactual_death':20}] \n\n\n\t#transmit the parameters\n\ttemplate = loader.get_template('primemodel/index.html')\n\tpara_view = {\n\t\t\t'b_output_mortality_num':\tb_output_mortality_num,\n\t\t\t'b_total_mortality':\t\tb_total_mortality,\n\t\t\t'c_output_mortality_num':\tc_output_mortality_num,\n\t\t\t'c_total_mortality':\t\tc_total_mortality,\n\t\t\t'total_population':\t\ttotal_population,\n\t\t\t'total_death_averted':\t\ttotal_death_averted,\n\t\t\t'total_death_baseline':\t\ttotal_death_baseline,\n\t\t\t'all_mortality_exposure':\tall_mortality_exposure\n\t\t\t}\n\n\t#context to transmit the parameters to show\n\tcontext = Context(para_view)\n\tresponse = template.render(context)\n\treturn HttpResponse(response)","def process(self):","def process(self):","def process(self):","def run():\n return estimate(0,1,0)","def _request_and_measure(self, count):\n for i in range(count):\n self.rate_measurer.update_rate()\n\n def handle_request_error(result):\n self.rate_measurer.request_failed(result)\n write_failure(result)\n\n for i in range(self.request_rate):\n d = self.control_service.move_dataset(self.dataset_node.uuid,\n self.dataset_id)\n self.rate_measurer.request_sent()\n d.addCallbacks(self.rate_measurer.response_received,\n errback=handle_request_error)","def pick_action(self):\n if self.exploration_mode == 'time':\n self.acq_func.exploration_rate = self.exploration_rate(self.duration + 1)\n elif self.exploration_mode == 'samples':\n self.acq_func.exploration_rate = self.exploration_rate(len(self.rounds) + 1)\n\n fid, x = optim.pick_acquisition_mf(acq_func=self.acq_func,\n optimizer=self.aux_optimizer,\n gammas=self.gammas,\n x_init=self.aux_x_init)\n rmean, rsd = self.acq_func.predict_mf(fid=fid, x=x)\n\n # Undo negation of objective function so as to not confuse user\n if self.mode == 'min':\n rmean = -rmean\n\n rospy.loginfo('Next sample (%d, %s) with beta %f and predicted reward %f +- %f',\n fid,\n str(x), self.acq_func.exploration_rate,\n rmean,\n rsd)\n return fid, x","def run(self):\n\n # TODO: Logic to get data, enforce request limits, and filter out duplicates","def _process(self, activity):","def fire(self):","def callee(calls):\n calls.append(1)","def __init__(self):\n self.state = Idle\n self.currExposure = Exposure(None, None, None)\n self.expTimer = Timer()\n self.readTimer = Timer()\n self.expBegin = None\n self.expAccumulated = None\n self.setConfig(CameraConfig())\n self._expName = \"\"\n self.failExposure = False # for unittesting","def autoExposure(this, **kargs):\n\t\t\n\t\t# Arguments\n\t\tframes = kargs.get('frames', 4)\n\t\tstart = kargs.get('start', -10)\n\t\tend = kargs.get('start', -3)\n\t\t\n\t\tmax = 0\n\t\tv = start\n\t\tprint 'Auto Exposition starting...'\n\t\t\n\t\tfor i in range(start, end):\n\t\t\tthis.setProp('exposure', i)\n\t\t\tfor j in range(frames): this.getFrame()\n\t\t\t\n\t\t\te = imEntropy(this.frame)\n\t\t\tif e > max:\n\t\t\t\tmax = e\n\t\t\t\tv = i\n\t\t\n\t\tthis.setProp('exposure', v)\n\t\tfor j in range(frames): this.getFrame()\n\t\tprint 'Exposure Calibrated: %i / Entropy: %.4f' % (v, max)","def set_exposure(self, expo):\n if expo == 0:\n self.exposure = 0\n elif expo == 1:\n self.exposure = min(9, self.exposure+1)\n elif expo == -1:\n self.exposure = max(-9, self.exposure-1)\n self.drone.set_exposure(self.exposure)\n log.info(f\"EXPOSURE {self.exposure}\")","def expose_test(self):\n with self.lock:\n self.dark = 1\n self.tstart = time.time()\n self.timestamp = time.strftime(\"%Y-%m-%dT%H:%M:%S\", time.localtime(self.tstart))\n imagesize = (self.expArea[3] - self.expArea[1],\n self.expArea[2] - self.expArea[0])\n self.data = np.ones(shape=imagesize, dtype=np.uint16)\n self.tend = time.time()","def perform(self):\n return","def perform(self):\n return","def __call__(self, population, context):\n pass","def __call__():","def __call__():","def __call__():","def __call__():","def __call__():","def process_exposure_product(self, exp_product, pool_name=\" \", asn_file=\" \"):\n # Find all the member types in the product\n members_by_type = defaultdict(list)\n for member in exp_product[\"members\"]:\n members_by_type[member[\"exptype\"].lower()].append(member[\"expname\"])\n\n # Get the science member. Technically there should only be\n # one. We'll just get the first one found.\n science = members_by_type[\"science\"]\n if len(science) != 1:\n self.log.warning(\n \"Wrong number of science files found in {}\".format(exp_product[\"name\"])\n )\n self.log.warning(\" Using only first one.\")\n science = science[0]\n\n self.log.info(\"Working on input %s ...\", science)\n if isinstance(science, datamodels.DataModel):\n input = science\n else:\n input = datamodels.open(science)\n\n # Record ASN pool and table names in output\n input.meta.asn.pool_name = pool_name\n input.meta.asn.table_name = asn_file\n\n input = self.dark_current(input)\n input = self.normalize(input)\n\n self.log.info(\"Finished processing product {}\".format(exp_product[\"name\"]))\n return input","def capture(self) -> int:","def run(self, req):\n\n if(self.isROS):\n featureList = []\n self.fov = self.geoPathToGPD(req.fov)\n else:\n self.fov = self.pickleToGPD(req)\n\n\n \n response = []\n \n featuresInView = gpd.sjoin(self.featureDataframe, self.fov, op='within') \n for index, feature in featuresInView.iterrows():\n if(self.isROS):\n response.append(enc_feature_msg(feature[\"name\"], feature[\"longitude\"],feature[\"latitude\"], feature[\"fid\"]))\n else:\n response.append((feature[\"name\"], feature[\"longitude\"],feature[\"latitude\"], feature[\"fid\"]))\n if(self.isROS):\n return enc_query_srvResponse(response)\n return response","def call(self, *args, **kwargs):","def get_exposure_value():\n validate(request.json, 'exposureValueRequestSchema', 'swagger/getExposureValue.yml')\n logging.info(\"get_exposure_value({0})\".format(request.json))\n return database.get_exposure_value(loc=request.json['loc'],\n stime=ExposureUtil.to_timestamp(request.json['stime']),\n etime=ExposureUtil.to_timestamp(request.json['etime']),\n tres=request.json['tres'],\n tstat=request.json['tstat'])","def exposuretime(self):\n _, = self.exposuretimes\n return _","def _generate_direct_image(self):\n filename = '0000_flt.fits'\n\n di_start_JD = (self.exp_start_times[0] - 1 * u.min).to(u.day)\n di_exp_gen = ExposureGenerator(self.detector, self.grism, self.NSAMP,\n self.SAMPSEQ, self.SUBARRAY,\n self.planet, filename, di_start_JD)\n\n try: # assume that its a list not a single value\n x_ref = self.x_ref[0]\n except TypeError:\n x_ref = self.x_ref\n\n try: # assume that its a list not a single value\n y_ref = self.y_ref[0]\n except TypeError:\n y_ref = self.y_ref\n\n exp = di_exp_gen.direct_image(x_ref, y_ref)\n exp.generate_fits(self.outdir, '0000_flt.fits')","def healthcare():","def command(self, value):\n for ii in range(0, len(exposure_mode_names)):\n if value == exposure_mode_names[ii]: break\n self.tcp_comms.tcp_params.exposureMode = ii\n self.tcp_comms.send_exposure_mode(self.tcp_comms.tcp_params.exposureMode)","def ExposeLoop(self, nexposures, fitsfile, seconds=5):\n if self.process and self.process.poll() is None:\n raise RuntimeError(\"A process is already running\")\n if self.exposethread and self.exposethread.is_alive():\n raise RuntimeError(\"An exposure loop is already running\")\n\n self.current_exposure = 0\n self.max_exposures = nexposures\n self.exposethread = Thread(target=self._do_expose_loop,\n args=(fitsfile, seconds))\n self.exposethread.start()","def _get_one(self,url):\n pass"],"string":"[\n \"def endexposureloop(self):\\n self.max_exposures = self.current_exposure\",\n \"def observeField(target, exposure):\\n\\n status = 2\\n real_exposure = exposure + np.random.normal(0.0, 20.0)\\n realSN2 = target['DESsn2'] + np.random.uniform(0.0, 1.0)\\n\\n return status, real_exposure, realSN2\",\n \"def expose(self):\\n\\n ## Determine type of exposure (exp, series, stack)\\n exptype = str(self.exptypeComboBox.currentText())\\n mode = self.modedict[exptype]\\n\\n ## Get exposure parameters\\n if mode == \\\"bias\\\":\\n exptime = 0.0\\n else:\\n exptime = self.exptimeSpinBox.value()\\n imcount = self.imstackSpinBox.value()\\n seqnum = self.imnumSpinBox.value()\\n mintime = self.minexpSpinBox.value()\\n maxtime = self.maxexpSpinBox.value()\\n step = self.tstepSpinBox.value()\\n\\n ## Determine filter kwargs\\n if self.filterToggleButton.isChecked():\\n kwargs = {'filter_name' : str(self.filterComboBox.currentText())}\\n else:\\n kwargs = {'monowl' : self.monoSpinBox.value()}\\n\\n if self.testimCheckBox.isChecked():\\n title = 'test'\\n else:\\n title = str(self.imtitleLineEdit.text())\\n\\n ## Build filepath\\n filepath = os.path.join(str(self.imfilenameLineEdit.text()),title)\\n \\n ## Check if single exposure\\n if exptype in [\\\"Exposure\\\", \\\"Dark\\\", \\\"Bias\\\"]:\\n\\n ## Perform exposure\\n self.logger.info(\\\"Starting {0}s {1} image.\\\".format(exptime, exptype))\\n self.image_start.emit(1)\\n\\n try:\\n filename = exposure.im_acq(mode, filepath, exptime, seqnum, **kwargs)\\n self.image_taken.emit(1)\\n except subprocess.CalledProcessError:\\n self.logger.exception(\\\"Error in executable {0}_acq. Image not taken.\\\".format(mode))\\n except OSError:\\n self.logger.exception(\\\"Executable {0}_acq not found. Image not taken\\\".format(mode))\\n except IOError:\\n self.logger.exception(\\\"File already exits. Image not taken.\\\")\\n else:\\n self.logger.info(\\\"Exposure {0} finished successfully.\\\".format(filename))\\n self.seqnum_inc.emit(seqnum)\\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename,\\n '-zoom', 'to', 'fit', '-cmap', 'b'])\\n\\n ## Check if a stack of exposures of same type\\n elif exptype in [\\\"Exposure Stack\\\", \\\"Dark Stack\\\", \\\"Bias Stack\\\"]:\\n\\n total = seqnum + imcount\\n self.logger.info(\\\"Starting {0}s {1} stack.\\\".format(exptime, exptype))\\n self.image_start.emit(imcount)\\n\\n try:\\n for i in range(seqnum, total):\\n self.logger.info(\\\"Starting image {0} of {1}.\\\".format(i+1-seqnum, imcount))\\n filename = exposure.im_acq(mode, filepath, exptime, i, **kwargs)\\n self.logger.info(\\\"Exposure {0} finished successfully.\\\".format(filename))\\n self.image_taken.emit(i+1-seqnum)\\n self.seqnum_inc.emit(i)\\n except subprocess.CalledProcessError:\\n self.logger.exception(\\\"Error in executable {0}_acq. Image not taken.\\\".format(mode))\\n except OSError:\\n self.logger.exception(\\\"Executable {0}_acq not found. Image not taken.\\\".format(mode))\\n except IOError:\\n self.logger.exception(\\\"File already exists. Image not taken.\\\")\\n else:\\n self.logger.info(\\\"Exposure stack finished successfully.\\\")\\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename, '-zoom', 'to', 'fit', '-cmap', 'b'])\\n \\n ## Check if a series of exposures of increase exposure time\\n elif exptype in [\\\"Exposure Series\\\", \\\"Dark Series\\\"]:\\n\\n ## Parameter checks\\n if mintime > maxtime:\\n self.logger.warning(\\\"Minimum time must be less than Maximum time. Series not started.\\\")\\n return\\n elif step <= 0:\\n self.logger.warning(\\\"Time step must be greater than 0. Series not started.\\\")\\n return\\n\\n ## Construct array of exposure times\\n t = mintime\\n time_array = []\\n while t <= maxtime:\\n time_array.append(t)\\n t += step\\n \\n ## Perform series\\n self.logger.info(\\\"Starting {0} series with mintime {1}, maxtime {2}, and step {3}.\\\".format(exptype, mintime, maxtime, step))\\n self.image_start.emit(len(time_array))\\n \\n try:\\n for i, time in enumerate(time_array):\\n self.logger.info(\\\"Starting {0}s {1} image.\\\".format(time, mode))\\n filename = exposure.im_acq(mode, filepath, time, seqnum, **kwargs)\\n self.logger.info(\\\"Exposure {0} finished successfully.\\\".format(filename))\\n self.image_taken.emit(i+1)\\n except subprocess.CalledProcessError:\\n self.logger.exception(\\\"Error in executable {0}_acq. Image not taken.\\\".format(mode))\\n except OSError:\\n self.logger.exception(\\\"Executable {0}_acq not found. Image not taken.\\\".format(mode))\\n except IOError:\\n self.logger.exception(\\\"File already exists. Image not taken.\\\")\\n else:\\n self.logger.info(\\\"Exposure series finished successfully.\\\")\\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename, '-zoom', 'to', 'fit', '-cmap', 'b'])\\n self.seqnum_inc.emit(seqnum)\",\n \"def exp(self, exposure_time):\\n print(f\\\"exp: {exposure_time}\\\")\\n self.device_control.exposure = exposure_time\\n yield\",\n \"def expose(self, cmd, expTime, expType):\\n\\n if not expType:\\n expType = 'test'\\n if cmd:\\n cmd.inform('exposureState=\\\"exposing\\\"')\\n if expType not in ('bias', 'test') and expTime > 0:\\n time.sleep(expTime + self._exposureOverheadTime())\\n\\n if cmd:\\n cmd.inform('exposureState=\\\"reading\\\"')\\n\\n f = pyfits.open('/home/chyan/mhs/data/mcs/schmidt_fiber_snr400_rmod71.fits')\\n image = f[0].data\\n # image = numpy.random.normal(self.biasLevel,\\n # scale=self.readNoise,\\n # size=self.imageSize).astype('u2')\\n\\n if expType != 'test':\\n time.sleep(self._readoutTime())\\n return image\",\n \"def exposure(frameType, expTime):\\n\\n blobEvent.clear() \\n\\n # set the specified frame type\\n if frameType.lower() == 'light':\\n ccd_frame[0].s = PyIndi.ISS_ON\\n ccd_frame[1].s = PyIndi.ISS_OFF\\n ccd_frame[2].s = PyIndi.ISS_OFF\\n ccd_frame[3].s = PyIndi.ISS_OFF \\n indiclient.sendNewSwitch(ccd_frame)\\n elif frameType.lower() == 'bias':\\n ccd_frame[0].s = PyIndi.ISS_OFF\\n ccd_frame[1].s = PyIndi.ISS_ON\\n ccd_frame[2].s = PyIndi.ISS_OFF\\n ccd_frame[3].s = PyIndi.ISS_OFF \\n indiclient.sendNewSwitch(ccd_frame)\\n elif frameType.lower() == 'dark':\\n ccd_frame[0].s = PyIndi.ISS_OFF\\n ccd_frame[1].s = PyIndi.ISS_OFF\\n ccd_frame[2].s = PyIndi.ISS_ON\\n ccd_frame[3].s = PyIndi.ISS_OFF \\n indiclient.sendNewSwitch(ccd_frame)\\n elif frameType.lower() == 'flat':\\n ccd_frame[0].s = PyIndi.ISS_OFF\\n ccd_frame[1].s = PyIndi.ISS_OFF\\n ccd_frame[2].s = PyIndi.ISS_OFF\\n ccd_frame[3].s = PyIndi.ISS_ON \\n indiclient.sendNewSwitch(ccd_frame)\\n\\n # set the value for the next exposure\\n ccd_exposure[0].value=expTime\\n\\n indiclient.sendNewNumber(ccd_exposure)\\n\\n # wait for the exposure\\n blobEvent.wait()\\n\\n for blob in ccd_ccd1:\\n # pyindi-client adds a getblobdata() method to IBLOB item\\n # for accessing the contents of the blob, which is a bytearray in Python\\n image_data=blob.getblobdata()\\n\\n # write the byte array out to a FITS file\\n global imgNum\\n global imgName\\n imgNum += 1\\n fileName = fileDir+'raw-'+str(imgNum).zfill(8)+'.fits'\\n f = open(fileName, 'wb')\\n f.write(image_data)\\n f.close()\\n imgName = fileName\\n \\n return fileName\",\n \"def runPass(self, exposure_range, rate):\\n r = rospy.Rate(rate)\\n for i, exposure in enumerate(exposure_range):\\n if rospy.is_shutdown():\\n break\\n\\n self.current_exposure = exposure\\n self.client.update_configuration(\\n {\\\"exposure\\\": self.current_exposure})\\n r.sleep()\\n\\n finished = (i >= (len(exposure_range)-1))\\n if finished:\\n optimal_exposure = max(self.scores, key=self.scores.get)\\n self.reset()\\n return optimal_exposure # an optimal exposure has been found\\n else:\\n return -1\",\n \"def call(self):\",\n \"def get_exposure(exposure_id,b_mean,b_sd,c_mean,c_sd,non_rate,dist_type,mortalities):#id in db\\n\\te_id \\t\\t= int(long(exposure_id))\\n\\texposure_outcomes = DBHelper.exposure_outcome\\n\\toutcome_ids \\t= DBHelper.exposure_outcome.get(e_id)\\n\\n\\tsamples_rr \\t= DBHelper.samples_rr.get(e_id)\\n\\tsamples_pop \\t= DBHelper.samples_pop.get(e_id)\\n\\trisks \\t\\t= DBHelper.risks.get(e_id)\\n\\tmeasure \\t= DBHelper.measures.get(e_id)\\n\\tdist_type \\t= get_dist_type(e_id)\\n\\n\\t#get population distribution \\n\\tpopDistribution = PopDistribution(DBHelper.age_group_num,non_rate,b_mean,b_sd,c_mean,c_sd,samples_pop,dist_type)\\n\\n\\t#get outcomes\\n\\toutcomes = []\\n\\tfor o_id in outcome_ids:\\n\\t\\t# mortality\\n\\t\\tm_mortality = mortalities.get(2*o_id)\\n\\t\\tf_mortality = mortalities.get(2*o_id+1)\\n\\t\\t# risks\\n\\t\\tm_risks = risks.get(2*o_id)\\n\\t\\tf_risks = risks.get(2*o_id+1)\\n\\t\\t# outcome name\\n\\t\\tname = DBHelper.get_outcome_name(o_id)\\n\\t\\t# limit estimates\\n\\t\\tlle = DBHelper.exposure_outcome.get(e_id).get(o_id)[0]\\n\\t\\tule = DBHelper.exposure_outcome.get(e_id).get(o_id)[1]\\n\\t\\t# outcome\\n\\t\\toutcome = PrimeOutcome(name,o_id,m_mortality,f_mortality,samples_rr,m_risks,f_risks,lle,ule,measure,e_id) \\n\\t\\toutcomes.append(outcome)\\n\\n\\texposure = PrimeExposure(mortalities,outcome_ids,samples_rr,samples_pop,outcomes,popDistribution)\\n\\treturn exposure\",\n \"def hit(self):\",\n \"def _generate_exposure(self, expstart, number):\\n\\n index_number = number - 1 # for zero indexing\\n\\n filename = '{:04d}_raw.fits'.format(number)\\n\\n exp_gen = ExposureGenerator(self.detector, self.grism, self.NSAMP,\\n self.SAMPSEQ, self.SUBARRAY,\\n self.planet, filename, expstart)\\n\\n if not self.spatial_scan:\\n self.sample_rate = 1 * u.year # high number reverts to read times\\n\\n _, sample_mid_points, sample_durations, read_index = \\\\\\n exp_gen._gen_scanning_sample_times(self.sample_rate)\\n\\n time_array = (sample_mid_points + expstart).to(u.day)\\n\\n if self.transmission_spectroscopy:\\n star_norm_flux = self.generate_lightcurves(time_array)\\n planet_depths = 1 - star_norm_flux\\n else:\\n planet_depths = None\\n\\n # x shifts - linear shift with exposure, second exposure shifted by\\n # x_shifts, direct image and first exp will match.\\n x_ref = self._try_index(self.x_ref, index_number)\\n y_ref = self._try_index(self.y_ref, index_number)\\n sky_background = self._try_index(self.sky_background, index_number)\\n\\n # X and Y Shifts\\n x_ref += self.x_shifts * index_number\\n y_ref += self.y_shifts * index_number\\n x_jitter = self.x_jitter\\n y_jitter = self.y_jitter\\n\\n if self._visit_trend:\\n scale_factor = self._visit_trend.get_scale_factor(index_number)\\n else:\\n scale_factor = None\\n\\n if self.spatial_scan:\\n exp_frame = exp_gen.scanning_frame(\\n x_ref, y_ref, x_jitter, y_jitter,\\n self.wl, self.stellar_flux, planet_depths,\\n self.scan_speed, self.sample_rate, sample_mid_points,\\n sample_durations, read_index, ssv_generator=self.ssv_gen,\\n noise_mean=self.noise_mean, noise_std=self.noise_std,\\n add_flat=self.add_flat, add_dark=self.add_dark,\\n scale_factor=scale_factor, sky_background=sky_background,\\n cosmic_rate=self.cosmic_rate,\\n add_gain_variations=self.add_gain_variations,\\n add_non_linear=self.add_non_linear,\\n clip_values_det_limits=self.clip_values_det_limits,\\n add_read_noise=self.add_read_noise,\\n add_stellar_noise=self.add_stellar_noise,\\n add_initial_bias=self.add_initial_bias,\\n progress_bar=self.progess,\\n threads=self.threads\\n )\\n else:\\n exp_frame = exp_gen.staring_frame(\\n x_ref, y_ref, x_jitter, y_jitter,\\n self.wl, self.stellar_flux, planet_depths,\\n sample_mid_points, sample_durations, read_index,\\n noise_mean=self.noise_mean, noise_std=self.noise_std,\\n add_flat=self.add_flat, add_dark=self.add_dark,\\n scale_factor=scale_factor, sky_background=sky_background,\\n cosmic_rate=self.cosmic_rate,\\n add_gain_variations=self.add_gain_variations,\\n add_non_linear=self.add_non_linear,\\n clip_values_det_limits=self.clip_values_det_limits,\\n add_read_noise=self.add_read_noise,\\n add_stellar_noise=self.add_stellar_noise,\\n add_initial_bias=self.add_initial_bias,\\n progress_bar=self.progess,\\n threads=self.threads\\n )\\n\\n exp_frame.generate_fits(self.outdir, filename, ldcoeffs=self.ldcoeffs)\\n\\n return exp_frame\",\n \"def tcs_exposure_request(image_type, duration = 0, number = 1):\\n\\n\\tvalid_types = ['THERMAL','DARK', 'BIAS', 'FLAT','OBJECT']\\n\\tvalid = image_type in valid_types\\n\\n\\tif valid:\\n\\t\\timage_type = image_type.lower()\\n\\t\\tif image_type == 'dark':\\n\\t\\t\\timage_type = 'thermal'\\n\\n\\t\\tif number < 1:\\n\\t\\t\\tlogger.error('Invalid number of exposures requested')\\n\\t\\t\\trespond = set_err_codes.STATUS_CODE_EXPOSURE_NOT_STARTED\\n\\t\\t\\treturn respond\\n\\n\\t\\tif duration <0:\\n\\t\\t\\tlogger.error('Invalid exposure time requested')\\n\\t\\t\\trespond = set_err_codes.STATUS_CODE_EXPOSURE_NOT_STARTED\\n\\t\\t\\treturn respond\\n\\n\\t\\tcommand_str = 'expose ' + image_type\\n\\t\\tif number != 1:\\n\\t\\t\\tcommand_str += ' '+str(number)\\n\\t\\tif image_type != 'bias':\\n\\t\\t\\tcommand_str += ' ' + str(duration)\\n\\t\\t\\n\\t\\ttry:\\n\\t\\t\\ttcs_respond = send_command(command_str)\\n\\t\\t\\n\\t\\texcept:\\n\\t\\t\\trespond = set_err_codes.STATUS_CODE_EXPOSURE_NOT_STARTED\\n\\t\\telse:\\n\\t\\t\\t\\n\\t\\t\\tcam_temp = get_camera_status()[2]\\n\\t\\t\\t#if good_response and cam_temp>-20:\\n\\t\\t\\tif float(cam_temp)>-20:\\n\\t\\t\\t\\trespond = set_err_codes.STATUS_CODE_CCD_WARM\\n\\t\\n\\t\\t\\telse:\\n\\t\\t\\t\\trespond = set_err_codes.STATUS_CODE_OK\\n\\t\\t\\t\\n\\t\\treturn respond\\n\\n\\telse:\\n\\t\\tlogger.error('Invalid image type provided to exposure request '+str(\\n\\t\\t\\t\\timage_type))\\n\\t\\tprint('Invalid image type provided to exposure request'+str(\\n\\t\\t\\timage_type))\",\n \"def run_observation(self):\\n\\n self._generate_direct_image() # to calibrate x_ref and y_ref\\n\\n num_frames = len(self.exp_start_times)\\n progress = Progress(num_frames)\\n self.progess = progress\\n\\n progress_line = 'Generating frames 0/{} done'.format(num_frames)\\n progress.print_status_line(progress_line)\\n progress.progress_line = progress_line\\n\\n for i, start_time in enumerate(self.exp_start_times):\\n filenum = i + 1\\n self._generate_exposure(start_time, filenum)\\n\\n progress.increment()\\n progress_line = 'Generating frames {}/{} done'.format(filenum,\\n num_frames)\\n progress.print_status_line(progress_line)\\n\\n # so it can be retreived by exposure_generator\\n progress.progress_line = progress_line\",\n \"def exposureCallback(self, config):\\n rospy.loginfo('Set exposure: {}'.format(config['exposure']))\",\n \"def exposure(cls, *args):\\n return cls.path_finder('exposure', *args)\",\n \"def exposure(cls, *args):\\n return cls.path_finder('exposure', *args)\",\n \"def _do_expose_loop(self, fitsfile, seconds):\\n log.debug(f\\\"Starting expose loop with {self.max_exposures} exposures\\\")\\n while (self.current_exposure is not None and \\n self.current_exposure < self.max_exposures):\\n self.current_exposure += 1\\n self.Expose(fitsfile, seconds)\\n while self.process and self.process.poll() is None:\\n sleep(5)\\n if not self.process or self.process.returncode != 0:\\n break\\n \\n self.current_exposure = None\\n self.max_exposures = None\",\n \"def exposure():\\n def r(x):\\n return x/6e4\\n\\n def w(x):\\n return int(x*6e4)\\n return r, w\",\n \"def exposure(self):\\n\\n # define a range of declination to evaluate the\\n # exposure at\\n self.declination = np.linspace(-np.pi/2, np.pi/2, self.num_points)\\n\\n m = np.asarray([m_dec(d, self.params) for d in self.declination])\\n \\n # normalise to a maximum at 1\\n self.exposure_factor = (m / m_dec(-np.pi/2, self.params))\\n\\n # find the point at which the exposure factor is 0\\n self.limiting_dec = Angle((self.declination[m == 0])[0], 'rad')\",\n \"def select_exposure(self):\\n exp1_selected = self.exp1_radio.isChecked()\\n\\n if self.recording_sequence:\\n self.record_sequence() # stop current recording\\n\\n if exp1_selected: # then exp1\\n ifi_ndx = self.exp1_ifi_select.currentIndex()\\n self.camera.set_exposure(self.exp1_select.currentIndex(), ifi_ndx)\\n else:\\n ifi_ndx = self.exp2_ifi_select.currentIndex()\\n self.camera.set_exposure(self.exp2_select.currentIndex(), ifi_ndx)\\n\\n temp = list(self.dpar.iwindow_toggle_save)\\n self.dpar.iwindow_toggle_save = list(self.dpar.iwindow[0])\\n self.dpar.iwindow[0] = temp\\n self._update_scrollbars()\\n\\n self.rec_seq_button.setEnabled(ifi_ndx > 0)\\n\\n et = np.int(np.round(self.camera.actual_exposure_time_ms))\\n self.write_to_log('Exposure %d ms' % et)\",\n \"def apply(self):\",\n \"def access():\",\n \"def selectOptimalExposureCallback(self):\\n rospy.loginfo('Starting automatic exposure selection algorithm')\\n\\n # Start searching for the optimal exposure\\n best_exp_pass1 = self.runPass(range(100, 27100, 3000), rate=self.rate)\\n # first pass, find coarse exposure\\n if best_exp_pass1 > 0:\\n rospy.loginfo('First pass: success!')\\n rospy.loginfo(\\n 'Best exposure in first pass: {}'.format(best_exp_pass1))\\n\\n # second pass, refine the exposure\\n exp_range = [int(exp) for exp in np.linspace(\\n 0.9*best_exp_pass1, 1.1*best_exp_pass1, 10)]\\n best_exp_pass2 = self.runPass(exp_range, rate=self.rate)\\n\\n if best_exp_pass2 > 0:\\n rospy.loginfo('Second pass: success!')\\n rospy.loginfo(\\n 'Best exposure in second pass: {}'.format(best_exp_pass2))\\n optimal_exposure = best_exp_pass2\\n else:\\n rospy.logerr(\\n 'Second pass: failure\\\\nSetting the best exposure found in first pass')\\n optimal_exposure = best_exp_pass1\\n\\n self.client.update_configuration({\\\"exposure\\\": optimal_exposure})\\n self.reset()\\n\\n else:\\n rospy.logerr(\\n 'First pass: failure\\\\nCould not auto-set the exposure')\",\n \"def expose(self, cmd):\\n\\n expType = cmd.cmd.keywords[0].name\\n if expType in ('bias', 'test'):\\n expTime = 0.0\\n else:\\n expTime = cmd.cmd.keywords[\\\"expTime\\\"].values[0]\\n\\n filename, image = self._doExpose(cmd, expTime, expType)\\n cmd.finish('exposureState=done')\",\n \"def request_access(self):\\n pass\",\n \"def exp_scan(self, exposure_time_list):\\n self.generic_scan(self.exp, exposure_time_list)\",\n \"def __call__(self):\\n if grinder.runNumber == 0: self.initialSleep()\\n (param1, param2) = self.getParam()\\n self.request1(param1, param2)\",\n \"def set_exposure(self, exposure):\\n self.logger.info(f'Setting exposure to {exposure}')\\n self._driver.ExposureTime.SetValue(exposure)\",\n \"def __call__(self,sensation,reward=None):\\n raise NYI\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def explore_action():\\n # def get_action(o, noise_scale):\\n # a = ac.act(torch.as_tensor(o, dtype=torch.float32))\\n # a += noise_scale * np.random.randn(act_dim)\\n # return np.clip(a, -act_limit, act_limit)\\n raise NotImplementedError\",\n \"def toggle_exposure(self):\\n\\n checked1 = self.exp1_radio.isChecked()\\n if checked1:\\n self.exp2_radio.setChecked(True)\\n else:\\n self.exp1_radio.setChecked(True)\\n self.select_exposure()\",\n \"def apply(self) -> None:\",\n \"def apply(self) -> None:\",\n \"def expose(self):\\n if self.camera is None: # test mode -- immediately return test image\\n print(\\\"NO SPECTRAL CAMERA FOUND -- USING TEST DATA\\\")\\n self.filename = \\\"example_fits_files/Mooi\\\"\\n return\\n\\n exposure_time = self.time.get()\\n try:\\n self.exposure_time = float(exposure_time)\\n except:\\n message = \\\"Exposure time \\\\\\\"{0}\\\\\\\" cannot be converted to floating point number\\\".format(exposure_time)\\n messagebox.showerror(\\\"Error\\\", message)\\n raise ValueError(message)\\n filename = \\\"spectra/{0}\\\".format(timestamp())\\n self.camera.spectrum(self.exposure_time, filename)\\n self.filename = filename\",\n \"def run(self, exposure, sources):\\n with self.distortionContext(exposure, sources) as bbox:\\n results = self.astrometry(exposure, sources, bbox=bbox)\\n\\n if results.matches:\\n self.refitWcs(exposure, sources, results.matches)\\n\\n return results\",\n \"def __call__(self, frame_num):\\n # propagate and set the density\\n self.img.set_array(\\n np.abs(self.quant_sys.propagate(10)) ** 2\\n )\\n return self.img,\",\n \"def on_start(self):\\r\\n self.start_whole_exposure()\",\n \"def apply(self):\\n pass\",\n \"def apply(self):\\n pass\",\n \"def falcon():\",\n \"def apply(self, request):\\n raise NotImplementedError(u\\\"%s: Method not implemented\\\",\\n self.__class__.__name__)\",\n \"def experiment(self) -> Any:\",\n \"def _step(self, action):\\n \\n obs, reward, done, info = self.env.step(action)\\n\\n \\n advice=self.generateAdvice()[1]\\n\\n obs = {\\n \\\"image\\\": obs,\\n \\\"advice\\\": advice\\n }\\n\\n\\n \\n\\n\\n\\n return obs, reward, done, info\",\n \"def collect_data(self,sensation,action,reward,next_sensation):\\n pass\",\n \"async def expose(obj, exptime, outfile, overwrite):\\n\\n async with obj['camera_system'] as fli:\\n\\n log.debug('starting camera exposures ... ')\\n exposures = await asyncio.gather(*[camera.expose(exptime)\\n for camera in fli.cameras],\\n return_exceptions=False)\\n\\n log.debug('writing images to disk ... ')\\n writers = []\\n for exposure in exposures:\\n if outfile:\\n outfile = outfile.format(camera=exposure.camera)\\n writers.append(exposure.write(filename=outfile,\\n overwrite=overwrite))\\n else:\\n writers.append(exposure.write(overwrite=overwrite))\\n\\n await asyncio.gather(*writers, return_exceptions=True)\",\n \"def next_point(self):\\n if self.verbose:\\n print(\\\"Computing acquisition function...\\\")\\n if self.acquisition_function == 'cb':\\n acq, pred = acqfunc.confidence_bound(\\n self.surrogate_model, self.X_full,\\n alpha=self.alpha, beta=self.beta)\\n elif self.acquisition_function == 'ei':\\n acq, pred = acqfunc.expected_improvement(\\n self.surrogate_model, self.X_full,\\n self.X_sparse, xi=self.xi)\\n elif self.acquisition_function == 'poi':\\n acq, pred = acqfunc.probability_of_improvement(\\n self.surrogate_model, self.X_full,\\n self.X_sparse, xi=self.xi)\\n elif isinstance(self.acquisition_function, types.FunctionType):\\n acq, pred = self.acquisition_function(\\n self.surrogate_model, self.X_full, self.X_sparse)\\n else:\\n raise NotImplementedError(\\n \\\"Choose between 'cb', 'ei', and 'poi' acquisition functions or define your own\\\")\\n self.gp_predictions.append(pred)\\n if self.mask is None:\\n indices_list = np.unravel_index(np.argsort(acq.ravel()), acq.shape)\\n vals_list = acq[indices_list][::-1][:self.batch_size].tolist()\\n indices_list = np.dstack(indices_list)[0][::-1][:self.batch_size].tolist()\\n else:\\n acq = self.mask*acq\\n indices_list = np.unravel_index(np.argsort(acq.ravel()), acq.shape)\\n vals_list = acq[indices_list]\\n vals_list = vals_list[~np.isnan(vals_list)][::-1]\\n indices_list = np.dstack(indices_list)[0]\\n indices_list = indices_list[:len(vals_list)][::-1]\\n vals_list = vals_list[:self.batch_size].tolist()\\n indices_list = indices_list[:self.batch_size].tolist()\\n if not self.batch_update:\\n return vals_list, indices_list\\n if self.batch_dscale is None:\\n batch_dscale_ = self.surrogate_model.model.kernel.lengthscale.mean().item()\\n else:\\n batch_dscale_ = self.batch_dscale\\n vals_list, indices_list = self.update_points(\\n vals_list, indices_list, batch_dscale_)\\n return vals_list, indices_list\",\n \"def factor_exposure(asset: Asset, risk_model_id: str, factor_name: str, *,\\n source: str = None, real_time: bool = False, request_id: Optional[str] = None) -> pd.Series:\\n risk_model = RiskModel(risk_model_id)\\n factor = Factor(risk_model_id, factor_name)\\n if factor.factor is None or risk_model_id != factor.risk_model_id:\\n raise MqValueError('Requested factor not available in requested risk model')\\n\\n asset_gsid = asset.get_identifiers().get('GSID')\\n\\n # Establish date interval for data query\\n dates = risk_model.get_dates()\\n start_date = dt.datetime.strptime(min(dates), \\\"%Y-%m-%d\\\").date() if dates else None\\n end_date = dt.datetime.strptime(max(dates), \\\"%Y-%m-%d\\\").date() if dates else None\\n\\n # Query data and append pull requested factor exposure\\n all_exposures = []\\n query_results = risk_model.get_data(\\n measures=[Measure.Factor_Name, Measure.Universe_Factor_Exposure, Measure.Asset_Universe],\\n start_date=start_date,\\n end_date=end_date,\\n assets=DataAssetsRequest(identifier=AssetUniverseIdentifier.gsid, universe=[asset_gsid])).get('results', [])\\n for result in query_results:\\n if result.get('date') in dates:\\n exposures = result.get('assetData', {}).get('factorExposure', [])\\n if exposures:\\n all_exposures.append(\\n {'date': result['date'],\\n 'factorExposure': exposures[0].get(factor.factor.identifier)})\\n\\n # Create and return timeseries\\n df = pd.DataFrame(all_exposures)\\n df.set_index('date', inplace=True)\\n df.index = pd.to_datetime(df.index)\\n return _extract_series_from_df(df, QueryType.FACTOR_EXPOSURE)\",\n \"def _doExpose(self, cmd, expTime, expType):\\n \\n image = self.actor.camera.expose(cmd, expTime, expType)\\n filename = self.getNextFilename(cmd)\\n pyfits.writeto(filename, image, checksum=False, clobber=True)\\n cmd.inform(\\\"filename=%s\\\" % (qstr(filename)))\\n \\n return filename, image\",\n \"def refresh_index_page_filter_by(request, exposure_sequence):\",\n \"def continue_with_exposure(self):\\r\\n # Allocate space to give to scan_until_abort, and name the two\\r\\n # rows appropriately.\\r\\n self.data_pair = self.cam.get_new_array(n_images=2)\\r\\n self.pump_probe_data = self.data_pair[0]\\r\\n self.probe_only_data = self.data_pair[1]\\r\\n # Keep track of which image will be updated next\\r\\n self.next_data_has_pump = True\\r\\n\\r\\n # Tell self.thread what to do when the camera has new images\\r\\n self.cam.new_images.connect(self.send_new_images)\\r\\n\\r\\n # Get the current array of wavelengths from cam\\r\\n self.wavelen_arr = self.cam.get_wavelen_array()\\r\\n\\r\\n # Queue a call to cam.scan_until_abort\\r\\n self.startAcq.emit(self.data_pair)\\r\\n\\r\\n # Tell listeners (plotting widgets) to start displaying data too\\r\\n self.startDisplay.emit()\",\n \"def any_image(self, index):\\n self.__accessed_image[index] = True\\n return self.__image(index)\",\n \"def __exp1_changed_callback(self, ndx):\\n if self.recording_sequence:\\n self.record_sequence()\\n self.exp1_radio.setChecked(True)\\n self.exp1_ifi_select.setCurrentIndex(0)\\n self.camera.set_exposure(ndx, 0)\\n self.rec_seq_button.setEnabled(False)\\n et = np.int(np.round(self.camera.actual_exposure_time_ms))\\n self.write_to_log('Exposure %d ms' % et)\",\n \"async def integrate(self, exposure_time=1):\\n if not self.status == ControllerStatus.IDLE:\\n raise ArchonError(\\\"Status must be IDLE to start integrating.\\\")\\n\\n await self.set_param(\\\"IntMS\\\", int(exposure_time * 1000))\\n await self.set_param(\\\"Exposures\\\", 1)\\n\\n self.status = ControllerStatus.EXPOSING\",\n \"def _apphot_one(args):\\n return apphot_one(*args)\",\n \"def run(self):\\n self.cause_dispatch() # generate one dispatch before temporarily disabling CENTRAL_DISPATCH\\n settings.DISPATCH_ENABLED = False\\n bare_specdata_list = self._compute_bare_specdata_sweep()\\n dressed_specdata = self._compute_dressed_specdata_sweep(bare_specdata_list)\\n self._lookup = spec_lookup.SpectrumLookup(self, dressed_specdata, bare_specdata_list)\\n settings.DISPATCH_ENABLED = True\",\n \"def __init__(self, exposure = -1):\\n self.cam = None\\n self.exposure = exposure\\n\\n self._set_camera()\",\n \"def single_step(self, *args):\\n e = args[0]\\n if self.verbose:\\n print(\\\"\\\\nExploration step {} / {}\\\".format(\\n e+1, self.exploration_steps))\\n # train with seeded data\\n if e == 0:\\n self.surrogate_model.train()\\n # calculate acquisition function and get next query points\\n vals, inds = self.next_point()\\n if not self.batch_update:\\n inds, vals = self.checkvalues(inds, vals)\\n # evaluate function\\n self.evaluate_function(inds)\\n # update posterior\\n self.update_posterior()\\n # store indices and values\\n if isinstance(vals, float):\\n self.indices_all.append(inds)\\n self.vals_all.append(vals)\\n else:\\n self.indices_all.extend(inds)\\n self.vals_all.extend(vals)\\n return\",\n \"def __call__(self):\\n return self.shoot()\",\n \"def run(self) -> None:\\n self.cause_dispatch() # one dispatch before temp. disabling CENTRAL_DISPATCH\\n settings.DISPATCH_ENABLED = False\\n bare_specdata_list = self._compute_bare_specdata_sweep()\\n dressed_specdata = self._compute_dressed_specdata_sweep(bare_specdata_list)\\n self._lookup = spec_lookup.SpectrumLookup(\\n self, dressed_specdata, bare_specdata_list\\n )\\n settings.DISPATCH_ENABLED = True\",\n \"def run_single_camera(cam):\\n\\n try:\\n # Retrieve TL device nodemap and print device information\\n #nodemap_tldevice = cam.GetTLDeviceNodeMap()\\n\\n #result &= print_device_info(nodemap_tldevice)\\n\\n # Initialize camera\\n cam.Init()\\n\\n # Retrieve GenICam nodemap\\n nodemap = cam.GetNodeMap()\\n exposures=[2000,4000,8000,16000]\\n index=0\\n if cam.ExposureAuto.GetAccessMode() != PySpin.RW:\\n print(\\\"Unable to disable automatic exposure. Aborting...\\\")\\n return False\\n node_acquisition_mode = PySpin.CEnumerationPtr(nodemap.GetNode(\\\"AcquisitionMode\\\"))\\n if not PySpin.IsAvailable(node_acquisition_mode) or not PySpin.IsWritable(node_acquisition_mode):\\n print(\\\"Unable to set acquisition mode to continuous (enum retrieval). Aborting...\\\")\\n return False\\n\\n # Retrieve entry node from enumeration node\\n node_acquisition_mode_continuous = node_acquisition_mode.GetEntryByName(\\\"Continuous\\\")\\n if not PySpin.IsAvailable(node_acquisition_mode_continuous) or not PySpin.IsReadable(node_acquisition_mode_continuous):\\n print(\\\"Unable to set acquisition mode to continuous (entry retrieval). Aborting...\\\")\\n return False\\n\\n acquisition_mode_continuous = node_acquisition_mode_continuous.GetValue()\\n\\n node_acquisition_mode.SetIntValue(acquisition_mode_continuous)\\n\\n print(\\\"Acquisition mode set to continuous...\\\")\\n\\n cam.ExposureAuto.SetValue(PySpin.ExposureAuto_Off)\\n '''\\n # Set maximum width\\n #\\n # *** NOTES ***\\n # Other nodes, such as those corresponding to image width and height,\\n # might have an increment other than 1. In these cases, it can be\\n # important to check that the desired value is a multiple of the\\n # increment.\\n #\\n # This is often the case for width and height nodes. However, because\\n # these nodes are being set to their maximums, there is no real reason\\n # to check against the increment.\\n if cam.Width.GetAccessMode() == PySpin.RW and cam.Width.GetInc() != 0 and cam.Width.GetMax != 0:\\n cam.Width.SetValue(FRAME_WIDTH)\\n print(\\\"Width set to %i...\\\" % cam.Width.GetValue())\\n\\n else:\\n print(\\\"Width not available...\\\")\\n result = False\\n\\n # Set maximum height\\n #\\n # *** NOTES ***\\n # A maximum is retrieved with the method GetMax(). A node's minimum and\\n # maximum should always be a multiple of its increment.\\n if cam.Height.GetAccessMode() == PySpin.RW and cam.Height.GetInc() != 0 and cam.Height.GetMax != 0:\\n cam.Height.SetValue(FRAME_HEIGHT)\\n print(\\\"Height set to %i...\\\" % cam.Height.GetValue())\\n\\n else:\\n print(\\\"Height not available...\\\")\\n result = False\\n '''\\n print(\\\"Automatic exposure disabled...\\\")\\n #node_acquisition_framerate = PySpin.CFloatPtr(nodemap.GetNode(\\\"AcquisitionFrameRate\\\"))\\n\\n # if not PySpin.IsAvailable(node_acquisition_framerate) and not PySpin.IsReadable(node_acquisition_framerate):\\n # print(\\\"Unable to retrieve frame rate. Aborting...\\\")\\n # return False\\n\\n # framerate_to_set = node_acquisition_framerate.GetValue()\\n\\n # print(\\\"Frame rate to be set to %d...\\\" % framerate_to_set)\\n canvas=np.zeros((FRAME_HEIGHT*2,FRAME_WIDTH*2,3), np.uint8)\\n while True:\\n exposure=exposures[index]\\n \\n configure_exposure(cam, exposure)\\n # Acquire images\\n err, img,width,height = acquire_images(cam, nodemap)\\n if err < 0:\\n return err\\n\\n \\n img = img.GetData().reshape(height,width,3)\\n\\n half_height = int(height/2)\\n half_width = int(width/2)\\n half_frame_height = int(FRAME_HEIGHT/2)\\n half_frame_width = int(FRAME_WIDTH/2)\\n \\n img = img[half_height-half_frame_height:half_height+half_frame_height,half_width-half_frame_width:half_width+half_frame_width]\\n #smallimg=cv2.resize(img,(int(FRAME_WIDTH/2),int(FRAME_HEIGHT/2)))\\n if index==0:\\n #top left\\n canvas[0:FRAME_HEIGHT,0:FRAME_WIDTH]=img\\n elif index==1:\\n #top right\\n canvas[0:FRAME_HEIGHT,FRAME_WIDTH:FRAME_WIDTH*2]=img\\n elif index==2:\\n #bot left\\n canvas[FRAME_HEIGHT:FRAME_HEIGHT*2,0:FRAME_WIDTH]=img\\n else:\\n #bot right\\n canvas[FRAME_HEIGHT:FRAME_HEIGHT*2,FRAME_WIDTH:FRAME_WIDTH*2]=img\\n index+=1\\n if index>=len(exposures):\\n index=0\\n\\n cv2.imshow(\\\"frame\\\",canvas)\\n if cv2.waitKey(1) &0xff ==ord('q'):\\n #stop the feed the 'q'\\n break\\n cv2.destroyAllWindows()\\n # Deinitialize camera\\n cam.DeInit()\\n\\n except PySpin.SpinnakerException as ex:\\n print(\\\"Error: %s\\\" % ex)\\n result = False\",\n \"def one(self):\",\n \"def perform(self):\\n pass\",\n \"def refresh_counterfactual_url_json(request, is_json):\\t\\n\\tif is_json != 'json':\\n\\t\\treturn\\n\\n #json_file = '/home/zhou/Downloads/jsons/only/json_7.json'\\n json_file = '/home/zhou/Downloads/jsons/compound/json_9.json'\\n\\t#json_file = '/Users/jiaozi/Downloads/jsons/compound/json_2.json' #json file address\\n exposure_sequence = read_json(json_file)#list of exposures{mean,sd,non_rate}, read json content into memory\\n\\n\\tprimeCoordinator.get_counterfactual_compound_exposures(exposure_sequence)\\n\\t\\n\\n\\t'''\\n\\t\\tFor interface output data format, please refer to refresh_output_counterfactual_mortality. When a user clicks on age/gender/outcome, he can view mortalities in different formats\\n It refreshes final compound mortality for output, it should be the counterfactual mortality of the final exposure.\\n In order to show mortality by age/outcome/gender, there should be three lists.\\n 1. Show by age/population_subset \\n All information to present on a webpage is stored in variable 'output_all_mortality_exposure_age', the format of this variable is [{'population_subset_id':1,'age_group':'15-19','b_mortality_sum_db':757,'c_mrtality_sum':341}] \\n 2. Show by outcome \\n All information to present on a webpage is stored in variable 'output_all_mortality_exposure_outcome', the format of this variable is [{'o_id':1,'name':'Stroke','b_mortality_sum_db':24757,'c_mrtality_sum':23415}] \\n 3. Show by gender \\n All information to present on a webpage is stored in variable 'output_all_mortality_exposure_gender', the format of this variable is [{'gender':'male','b_mortality_sum_db':24757,'c_mrtality_sum':415}] \\n\\n\\t'''\\n\\t#filter_by\\t= request.POST['filter-by'] \\n\\tfilter_by\\t= request.GET\\n\\tby\\t\\t= request.POST\\n\\tprint filter_by\\n\\tprint by\\n\\n\\t# get the data in the interface\\n\\tb_output_mortality \\t= primeCoordinator.output_baseline_mortality\\n\\tb_output_mortality_num \\t= primeCoordinator.output_baseline_mortality_num\\n\\tb_total_mortality \\t= primeCoordinator.output_baseline_mortality_total\\n\\tc_output_mortality \\t= primeCoordinator.output_counterfactual_mortality\\n\\tc_output_mortality_num \\t= primeCoordinator.output_counterfactual_mortality_num\\n\\tc_total_mortality \\t= primeCoordinator.output_counterfactual_mortality_total\\n\\ttotal_population\\t= primeCoordinator.output_total_population\\n\\ttotal_death_averted\\t= str(int(round(primeCoordinator.output_total_death_averted))) # int\\n\\t#total_death_averted\\t= str(primeCoordinator.output_total_death_averted) # decimale\\n\\ttotal_death_baseline\\t= str(primeCoordinator.output_total_death_baseline)\\n\\n\\t'''\\n\\t\\tThis is the outputs when user click outcome\\n\\t'''\\n\\tall_mortality_exposure\\t= primeCoordinator.output_all_mortality_exposure_outcome # [{'outcome_id':outcome_id,'name':outcome name,'baseline_death':100, 'counterfactual_death':20},{}] \\n\\n\\t'''\\n\\t\\tThis is the output when user click age\\n\\t'''\\n\\tall_mortality_age\\t= primeCoordinator.output_all_mortality_age # [{'age_group_id':age_group_id,'age_group':age_group,'baseline_death':100, 'counterfactual_death':20},{}] \\n\\n\\t'''\\n\\t\\tThis is the outputs when user click gender \\n\\t'''\\n\\tall_mortality_gender\\t= primeCoordinator.output_all_mortality_gender# [{'gender':'male','baseline_death':100, 'counterfactual_death':20},{'gender':'female','baseline_death':100, 'counterfactual_death':20}] \\n\\n\\n\\t#transmit the parameters\\n\\ttemplate = loader.get_template('primemodel/index.html')\\n\\tpara_view = {\\n\\t\\t\\t'b_output_mortality_num':\\tb_output_mortality_num,\\n\\t\\t\\t'b_total_mortality':\\t\\tb_total_mortality,\\n\\t\\t\\t'c_output_mortality_num':\\tc_output_mortality_num,\\n\\t\\t\\t'c_total_mortality':\\t\\tc_total_mortality,\\n\\t\\t\\t'total_population':\\t\\ttotal_population,\\n\\t\\t\\t'total_death_averted':\\t\\ttotal_death_averted,\\n\\t\\t\\t'total_death_baseline':\\t\\ttotal_death_baseline,\\n\\t\\t\\t'all_mortality_exposure':\\tall_mortality_exposure\\n\\t\\t\\t}\\n\\n\\t#context to transmit the parameters to show\\n\\tcontext = Context(para_view)\\n\\tresponse = template.render(context)\\n\\treturn HttpResponse(response)\",\n \"def process(self):\",\n \"def process(self):\",\n \"def process(self):\",\n \"def run():\\n return estimate(0,1,0)\",\n \"def _request_and_measure(self, count):\\n for i in range(count):\\n self.rate_measurer.update_rate()\\n\\n def handle_request_error(result):\\n self.rate_measurer.request_failed(result)\\n write_failure(result)\\n\\n for i in range(self.request_rate):\\n d = self.control_service.move_dataset(self.dataset_node.uuid,\\n self.dataset_id)\\n self.rate_measurer.request_sent()\\n d.addCallbacks(self.rate_measurer.response_received,\\n errback=handle_request_error)\",\n \"def pick_action(self):\\n if self.exploration_mode == 'time':\\n self.acq_func.exploration_rate = self.exploration_rate(self.duration + 1)\\n elif self.exploration_mode == 'samples':\\n self.acq_func.exploration_rate = self.exploration_rate(len(self.rounds) + 1)\\n\\n fid, x = optim.pick_acquisition_mf(acq_func=self.acq_func,\\n optimizer=self.aux_optimizer,\\n gammas=self.gammas,\\n x_init=self.aux_x_init)\\n rmean, rsd = self.acq_func.predict_mf(fid=fid, x=x)\\n\\n # Undo negation of objective function so as to not confuse user\\n if self.mode == 'min':\\n rmean = -rmean\\n\\n rospy.loginfo('Next sample (%d, %s) with beta %f and predicted reward %f +- %f',\\n fid,\\n str(x), self.acq_func.exploration_rate,\\n rmean,\\n rsd)\\n return fid, x\",\n \"def run(self):\\n\\n # TODO: Logic to get data, enforce request limits, and filter out duplicates\",\n \"def _process(self, activity):\",\n \"def fire(self):\",\n \"def callee(calls):\\n calls.append(1)\",\n \"def __init__(self):\\n self.state = Idle\\n self.currExposure = Exposure(None, None, None)\\n self.expTimer = Timer()\\n self.readTimer = Timer()\\n self.expBegin = None\\n self.expAccumulated = None\\n self.setConfig(CameraConfig())\\n self._expName = \\\"\\\"\\n self.failExposure = False # for unittesting\",\n \"def autoExposure(this, **kargs):\\n\\t\\t\\n\\t\\t# Arguments\\n\\t\\tframes = kargs.get('frames', 4)\\n\\t\\tstart = kargs.get('start', -10)\\n\\t\\tend = kargs.get('start', -3)\\n\\t\\t\\n\\t\\tmax = 0\\n\\t\\tv = start\\n\\t\\tprint 'Auto Exposition starting...'\\n\\t\\t\\n\\t\\tfor i in range(start, end):\\n\\t\\t\\tthis.setProp('exposure', i)\\n\\t\\t\\tfor j in range(frames): this.getFrame()\\n\\t\\t\\t\\n\\t\\t\\te = imEntropy(this.frame)\\n\\t\\t\\tif e > max:\\n\\t\\t\\t\\tmax = e\\n\\t\\t\\t\\tv = i\\n\\t\\t\\n\\t\\tthis.setProp('exposure', v)\\n\\t\\tfor j in range(frames): this.getFrame()\\n\\t\\tprint 'Exposure Calibrated: %i / Entropy: %.4f' % (v, max)\",\n \"def set_exposure(self, expo):\\n if expo == 0:\\n self.exposure = 0\\n elif expo == 1:\\n self.exposure = min(9, self.exposure+1)\\n elif expo == -1:\\n self.exposure = max(-9, self.exposure-1)\\n self.drone.set_exposure(self.exposure)\\n log.info(f\\\"EXPOSURE {self.exposure}\\\")\",\n \"def expose_test(self):\\n with self.lock:\\n self.dark = 1\\n self.tstart = time.time()\\n self.timestamp = time.strftime(\\\"%Y-%m-%dT%H:%M:%S\\\", time.localtime(self.tstart))\\n imagesize = (self.expArea[3] - self.expArea[1],\\n self.expArea[2] - self.expArea[0])\\n self.data = np.ones(shape=imagesize, dtype=np.uint16)\\n self.tend = time.time()\",\n \"def perform(self):\\n return\",\n \"def perform(self):\\n return\",\n \"def __call__(self, population, context):\\n pass\",\n \"def __call__():\",\n \"def __call__():\",\n \"def __call__():\",\n \"def __call__():\",\n \"def __call__():\",\n \"def process_exposure_product(self, exp_product, pool_name=\\\" \\\", asn_file=\\\" \\\"):\\n # Find all the member types in the product\\n members_by_type = defaultdict(list)\\n for member in exp_product[\\\"members\\\"]:\\n members_by_type[member[\\\"exptype\\\"].lower()].append(member[\\\"expname\\\"])\\n\\n # Get the science member. Technically there should only be\\n # one. We'll just get the first one found.\\n science = members_by_type[\\\"science\\\"]\\n if len(science) != 1:\\n self.log.warning(\\n \\\"Wrong number of science files found in {}\\\".format(exp_product[\\\"name\\\"])\\n )\\n self.log.warning(\\\" Using only first one.\\\")\\n science = science[0]\\n\\n self.log.info(\\\"Working on input %s ...\\\", science)\\n if isinstance(science, datamodels.DataModel):\\n input = science\\n else:\\n input = datamodels.open(science)\\n\\n # Record ASN pool and table names in output\\n input.meta.asn.pool_name = pool_name\\n input.meta.asn.table_name = asn_file\\n\\n input = self.dark_current(input)\\n input = self.normalize(input)\\n\\n self.log.info(\\\"Finished processing product {}\\\".format(exp_product[\\\"name\\\"]))\\n return input\",\n \"def capture(self) -> int:\",\n \"def run(self, req):\\n\\n if(self.isROS):\\n featureList = []\\n self.fov = self.geoPathToGPD(req.fov)\\n else:\\n self.fov = self.pickleToGPD(req)\\n\\n\\n \\n response = []\\n \\n featuresInView = gpd.sjoin(self.featureDataframe, self.fov, op='within') \\n for index, feature in featuresInView.iterrows():\\n if(self.isROS):\\n response.append(enc_feature_msg(feature[\\\"name\\\"], feature[\\\"longitude\\\"],feature[\\\"latitude\\\"], feature[\\\"fid\\\"]))\\n else:\\n response.append((feature[\\\"name\\\"], feature[\\\"longitude\\\"],feature[\\\"latitude\\\"], feature[\\\"fid\\\"]))\\n if(self.isROS):\\n return enc_query_srvResponse(response)\\n return response\",\n \"def call(self, *args, **kwargs):\",\n \"def get_exposure_value():\\n validate(request.json, 'exposureValueRequestSchema', 'swagger/getExposureValue.yml')\\n logging.info(\\\"get_exposure_value({0})\\\".format(request.json))\\n return database.get_exposure_value(loc=request.json['loc'],\\n stime=ExposureUtil.to_timestamp(request.json['stime']),\\n etime=ExposureUtil.to_timestamp(request.json['etime']),\\n tres=request.json['tres'],\\n tstat=request.json['tstat'])\",\n \"def exposuretime(self):\\n _, = self.exposuretimes\\n return _\",\n \"def _generate_direct_image(self):\\n filename = '0000_flt.fits'\\n\\n di_start_JD = (self.exp_start_times[0] - 1 * u.min).to(u.day)\\n di_exp_gen = ExposureGenerator(self.detector, self.grism, self.NSAMP,\\n self.SAMPSEQ, self.SUBARRAY,\\n self.planet, filename, di_start_JD)\\n\\n try: # assume that its a list not a single value\\n x_ref = self.x_ref[0]\\n except TypeError:\\n x_ref = self.x_ref\\n\\n try: # assume that its a list not a single value\\n y_ref = self.y_ref[0]\\n except TypeError:\\n y_ref = self.y_ref\\n\\n exp = di_exp_gen.direct_image(x_ref, y_ref)\\n exp.generate_fits(self.outdir, '0000_flt.fits')\",\n \"def healthcare():\",\n \"def command(self, value):\\n for ii in range(0, len(exposure_mode_names)):\\n if value == exposure_mode_names[ii]: break\\n self.tcp_comms.tcp_params.exposureMode = ii\\n self.tcp_comms.send_exposure_mode(self.tcp_comms.tcp_params.exposureMode)\",\n \"def ExposeLoop(self, nexposures, fitsfile, seconds=5):\\n if self.process and self.process.poll() is None:\\n raise RuntimeError(\\\"A process is already running\\\")\\n if self.exposethread and self.exposethread.is_alive():\\n raise RuntimeError(\\\"An exposure loop is already running\\\")\\n\\n self.current_exposure = 0\\n self.max_exposures = nexposures\\n self.exposethread = Thread(target=self._do_expose_loop,\\n args=(fitsfile, seconds))\\n self.exposethread.start()\",\n \"def _get_one(self,url):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6202363","0.5730469","0.5720542","0.5674125","0.5648648","0.56126845","0.55802995","0.5563538","0.55593634","0.5544014","0.5505167","0.5467155","0.54338604","0.5406679","0.53846276","0.53846276","0.53756344","0.531871","0.5311451","0.5309933","0.5305943","0.5292303","0.5289628","0.5213631","0.5211134","0.52088344","0.5206163","0.51909417","0.5164779","0.5163428","0.5163428","0.5163428","0.5163428","0.5163428","0.5157655","0.51499236","0.5139993","0.5139993","0.51379657","0.51303023","0.5121835","0.51122135","0.51093787","0.51093787","0.508679","0.5080306","0.5057563","0.50528455","0.50525856","0.5040895","0.50380754","0.5034372","0.50332034","0.5030125","0.5027548","0.5016878","0.5010914","0.49993348","0.49954835","0.4983248","0.49682274","0.49614328","0.49602866","0.49552783","0.49537838","0.4952609","0.4948855","0.4910469","0.4884281","0.4884281","0.4884281","0.4872846","0.4870585","0.4864314","0.48594034","0.4857065","0.48569065","0.48536173","0.48495597","0.48374608","0.48334485","0.4833361","0.48126543","0.48126543","0.48125893","0.48073483","0.48073483","0.48073483","0.48073483","0.48073483","0.4795321","0.4791037","0.47902206","0.47769552","0.4776758","0.47711435","0.47647318","0.4761584","0.47576076","0.47557303","0.47480124"],"string":"[\n \"0.6202363\",\n \"0.5730469\",\n \"0.5720542\",\n \"0.5674125\",\n \"0.5648648\",\n \"0.56126845\",\n \"0.55802995\",\n \"0.5563538\",\n \"0.55593634\",\n \"0.5544014\",\n \"0.5505167\",\n \"0.5467155\",\n \"0.54338604\",\n \"0.5406679\",\n \"0.53846276\",\n \"0.53846276\",\n \"0.53756344\",\n \"0.531871\",\n \"0.5311451\",\n \"0.5309933\",\n \"0.5305943\",\n \"0.5292303\",\n \"0.5289628\",\n \"0.5213631\",\n \"0.5211134\",\n \"0.52088344\",\n \"0.5206163\",\n \"0.51909417\",\n \"0.5164779\",\n \"0.5163428\",\n \"0.5163428\",\n \"0.5163428\",\n \"0.5163428\",\n \"0.5163428\",\n \"0.5157655\",\n \"0.51499236\",\n \"0.5139993\",\n \"0.5139993\",\n \"0.51379657\",\n \"0.51303023\",\n \"0.5121835\",\n \"0.51122135\",\n \"0.51093787\",\n \"0.51093787\",\n \"0.508679\",\n \"0.5080306\",\n \"0.5057563\",\n \"0.50528455\",\n \"0.50525856\",\n \"0.5040895\",\n \"0.50380754\",\n \"0.5034372\",\n \"0.50332034\",\n \"0.5030125\",\n \"0.5027548\",\n \"0.5016878\",\n \"0.5010914\",\n \"0.49993348\",\n \"0.49954835\",\n \"0.4983248\",\n \"0.49682274\",\n \"0.49614328\",\n \"0.49602866\",\n \"0.49552783\",\n \"0.49537838\",\n \"0.4952609\",\n \"0.4948855\",\n \"0.4910469\",\n \"0.4884281\",\n \"0.4884281\",\n \"0.4884281\",\n \"0.4872846\",\n \"0.4870585\",\n \"0.4864314\",\n \"0.48594034\",\n \"0.4857065\",\n \"0.48569065\",\n \"0.48536173\",\n \"0.48495597\",\n \"0.48374608\",\n \"0.48334485\",\n \"0.4833361\",\n \"0.48126543\",\n \"0.48126543\",\n \"0.48125893\",\n \"0.48073483\",\n \"0.48073483\",\n \"0.48073483\",\n \"0.48073483\",\n \"0.48073483\",\n \"0.4795321\",\n \"0.4791037\",\n \"0.47902206\",\n \"0.47769552\",\n \"0.4776758\",\n \"0.47711435\",\n \"0.47647318\",\n \"0.4761584\",\n \"0.47576076\",\n \"0.47557303\",\n \"0.47480124\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":495,"cells":{"query":{"kind":"string","value":"Helper for apogee science tests"},"document":{"kind":"string","value":"def _do_apogee_science(self, nCall, nInfo, nWarn, nErr, ditherPairs=4):\n self._update_cart(1, 'APOGEE')\n cmdState = self.actorState.doApogeeScience\n cmdState.reinitialize(self.cmd)\n cmdState.ditherPairs = ditherPairs\n masterThread.do_apogee_science(self.cmd, cmdState, myGlobals.actorState)\n self._check_cmd(nCall, nInfo, nWarn, nErr, True)"},"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 testBeliefs1sk(self):","def test_alien_data(self):","def test_art_from_taste_space(self):","def test_theft_and_stealing(self):","def test_T01():","def testBeliefs2sk(self):","def _test(self):","def _test(self):","def _test(self):","def _test(self):","def _test(self):","def tests():","def test_predictor():","def test_T3():","def test_T3():","def unitary_test():","def test_T4():","def test_T4():","def test_quick_answer(self):\n pass","def test(self):\n pass","def test_4():","def test():","def test():","def test_let(self):","def test_4_4_1_1(self):\n pass","def _test(self):\n pass","def _test(self):\n pass","def _test(self):\n pass","def getTestResults():","def test_01_lighting(self):","def test_get_art_info(self):\n pass","def test_get_insumo(self):","def test_households_in_admin_unit(self):","def test(self):","def test(self):","def test_arc_smear(self):","def test_T2():","def test_T2():","def test_T0():","def test_apply_endorsements(self):","def test_create_unexpected_problem(self):\n pass","def substantiate():","def test_5():","def test_dummy():","def test_T1():","def test_T1():","def test_get_solution(self):\n pass","def test():\n pass","def test_get_waivers(league):\n pass","def test_something():","def test_3():","def test_g_asignar_rol(self):","def test_03_visit_special(self):","def test_analytical_vs_numerical():\n pass","def test_rules():","def test_training(self):\n\t\tpass","def test_get_details7(self):\n pass","def exercise_b2_70():\r\n pass","def test_get_goal(self):\n pass","def test_basic_execution(self):","def exercise_b2_53():\r\n pass","def test_single_issue():\n pass","def test_if(self):","def test_get_game_boxscore(self):\n pass","def exercise_b2_106():\r\n pass","def runtest(self):","def test_kyc_get_legal(self):\n pass","def test_gtf(self):\n #TODO write bed tests","def exercise_b2_69():\r\n pass","def test_machine_learning():","def test(self):\n raise NotImplementedError","def exercise_b2_107():\r\n pass","def healthcare():","def exercise_b2_113():\r\n pass","def test_active_inference_SPM_1b(self):","def test_get_game(self):\n pass","def test_get1(self):\n pass","def test_title(names):","def exercise_b2_56():\r\n pass","def test_1():","def test_get_food(self):\n pass","def test_convert():","def exercise_b2_52():\r\n pass","def test_initialization_of_homework_result_solution():\n assert result_1.solution == \"I have done this hw\"","def test_nothing(self):","def test_get_scenario(self):\n pass","def test(self):\n # -- Test --\n\n # (1)\n\n # (2)\n\n # (3)\n\n # (4)\n # -- Test --","def test_generate_all_testing(self):\n pass","def test_get2(self):\n pass","def test_visualize_recipe_nutrition(self):\n pass","def test_01_visit(self):","def test_kyc_post_legal(self):\n pass","def test_get_run(self):\n pass","def test_2():","def inner_test():\n pass","def inner_test():\n pass","def test_get_scenarios(self):\n pass","def test_observatory(lasco):\n assert lasco.observatory == \"SOHO\"","def test_uparforvarg(self):","def test_outE_traverals(self):\r\n results = self.blake.outE()\r\n assert len(results) == 1\r\n assert self.blake_in_theoretics in results","def test_testing():\n Pendulum = pu.Pendulum()\n ans = Pendulum.dummytest()\n assert ans"],"string":"[\n \"def testBeliefs1sk(self):\",\n \"def test_alien_data(self):\",\n \"def test_art_from_taste_space(self):\",\n \"def test_theft_and_stealing(self):\",\n \"def test_T01():\",\n \"def testBeliefs2sk(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def tests():\",\n \"def test_predictor():\",\n \"def test_T3():\",\n \"def test_T3():\",\n \"def unitary_test():\",\n \"def test_T4():\",\n \"def test_T4():\",\n \"def test_quick_answer(self):\\n pass\",\n \"def test(self):\\n pass\",\n \"def test_4():\",\n \"def test():\",\n \"def test():\",\n \"def test_let(self):\",\n \"def test_4_4_1_1(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def getTestResults():\",\n \"def test_01_lighting(self):\",\n \"def test_get_art_info(self):\\n pass\",\n \"def test_get_insumo(self):\",\n \"def test_households_in_admin_unit(self):\",\n \"def test(self):\",\n \"def test(self):\",\n \"def test_arc_smear(self):\",\n \"def test_T2():\",\n \"def test_T2():\",\n \"def test_T0():\",\n \"def test_apply_endorsements(self):\",\n \"def test_create_unexpected_problem(self):\\n pass\",\n \"def substantiate():\",\n \"def test_5():\",\n \"def test_dummy():\",\n \"def test_T1():\",\n \"def test_T1():\",\n \"def test_get_solution(self):\\n pass\",\n \"def test():\\n pass\",\n \"def test_get_waivers(league):\\n pass\",\n \"def test_something():\",\n \"def test_3():\",\n \"def test_g_asignar_rol(self):\",\n \"def test_03_visit_special(self):\",\n \"def test_analytical_vs_numerical():\\n pass\",\n \"def test_rules():\",\n \"def test_training(self):\\n\\t\\tpass\",\n \"def test_get_details7(self):\\n pass\",\n \"def exercise_b2_70():\\r\\n pass\",\n \"def test_get_goal(self):\\n pass\",\n \"def test_basic_execution(self):\",\n \"def exercise_b2_53():\\r\\n pass\",\n \"def test_single_issue():\\n pass\",\n \"def test_if(self):\",\n \"def test_get_game_boxscore(self):\\n pass\",\n \"def exercise_b2_106():\\r\\n pass\",\n \"def runtest(self):\",\n \"def test_kyc_get_legal(self):\\n pass\",\n \"def test_gtf(self):\\n #TODO write bed tests\",\n \"def exercise_b2_69():\\r\\n pass\",\n \"def test_machine_learning():\",\n \"def test(self):\\n raise NotImplementedError\",\n \"def exercise_b2_107():\\r\\n pass\",\n \"def healthcare():\",\n \"def exercise_b2_113():\\r\\n pass\",\n \"def test_active_inference_SPM_1b(self):\",\n \"def test_get_game(self):\\n pass\",\n \"def test_get1(self):\\n pass\",\n \"def test_title(names):\",\n \"def exercise_b2_56():\\r\\n pass\",\n \"def test_1():\",\n \"def test_get_food(self):\\n pass\",\n \"def test_convert():\",\n \"def exercise_b2_52():\\r\\n pass\",\n \"def test_initialization_of_homework_result_solution():\\n assert result_1.solution == \\\"I have done this hw\\\"\",\n \"def test_nothing(self):\",\n \"def test_get_scenario(self):\\n pass\",\n \"def test(self):\\n # -- Test --\\n\\n # (1)\\n\\n # (2)\\n\\n # (3)\\n\\n # (4)\\n # -- Test --\",\n \"def test_generate_all_testing(self):\\n pass\",\n \"def test_get2(self):\\n pass\",\n \"def test_visualize_recipe_nutrition(self):\\n pass\",\n \"def test_01_visit(self):\",\n \"def test_kyc_post_legal(self):\\n pass\",\n \"def test_get_run(self):\\n pass\",\n \"def test_2():\",\n \"def inner_test():\\n pass\",\n \"def inner_test():\\n pass\",\n \"def test_get_scenarios(self):\\n pass\",\n \"def test_observatory(lasco):\\n assert lasco.observatory == \\\"SOHO\\\"\",\n \"def test_uparforvarg(self):\",\n \"def test_outE_traverals(self):\\r\\n results = self.blake.outE()\\r\\n assert len(results) == 1\\r\\n assert self.blake_in_theoretics in results\",\n \"def test_testing():\\n Pendulum = pu.Pendulum()\\n ans = Pendulum.dummytest()\\n assert ans\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6974807","0.6933129","0.6889396","0.6887534","0.6827801","0.67861944","0.67435616","0.67435616","0.67435616","0.67435616","0.67435616","0.6690207","0.6631977","0.66018003","0.66018003","0.6595975","0.6593147","0.6593147","0.65639585","0.65451413","0.65322465","0.6526747","0.6526747","0.6505568","0.6486779","0.64841115","0.64841115","0.64841115","0.6458555","0.64535874","0.6450602","0.64448696","0.64370126","0.643546","0.643546","0.6431869","0.6430605","0.6430605","0.6421754","0.6408224","0.63703156","0.63650006","0.6356629","0.63480633","0.6340758","0.6340758","0.6338208","0.63330495","0.63233906","0.63228166","0.6317575","0.6311631","0.6307398","0.6287377","0.6282867","0.6281507","0.6232615","0.62198275","0.6190656","0.61890864","0.6187388","0.6172596","0.61634064","0.6159596","0.6157667","0.6153323","0.61480534","0.6139105","0.61278695","0.61247754","0.60998374","0.60986453","0.6091511","0.60884005","0.6080704","0.60776824","0.60678023","0.60564125","0.60494256","0.604927","0.6047783","0.60473233","0.60296744","0.60250133","0.6023721","0.60179156","0.6017413","0.59969765","0.5994655","0.599352","0.5988078","0.59868515","0.59751683","0.5962426","0.59601253","0.59601253","0.59584135","0.5953797","0.5951116","0.59443325","0.59189427"],"string":"[\n \"0.6974807\",\n \"0.6933129\",\n \"0.6889396\",\n \"0.6887534\",\n \"0.6827801\",\n \"0.67861944\",\n \"0.67435616\",\n \"0.67435616\",\n \"0.67435616\",\n \"0.67435616\",\n \"0.67435616\",\n \"0.6690207\",\n \"0.6631977\",\n \"0.66018003\",\n \"0.66018003\",\n \"0.6595975\",\n \"0.6593147\",\n \"0.6593147\",\n \"0.65639585\",\n \"0.65451413\",\n \"0.65322465\",\n \"0.6526747\",\n \"0.6526747\",\n \"0.6505568\",\n \"0.6486779\",\n \"0.64841115\",\n \"0.64841115\",\n \"0.64841115\",\n \"0.6458555\",\n \"0.64535874\",\n \"0.6450602\",\n \"0.64448696\",\n \"0.64370126\",\n \"0.643546\",\n \"0.643546\",\n \"0.6431869\",\n \"0.6430605\",\n \"0.6430605\",\n \"0.6421754\",\n \"0.6408224\",\n \"0.63703156\",\n \"0.63650006\",\n \"0.6356629\",\n \"0.63480633\",\n \"0.6340758\",\n \"0.6340758\",\n \"0.6338208\",\n \"0.63330495\",\n \"0.63233906\",\n \"0.63228166\",\n \"0.6317575\",\n \"0.6311631\",\n \"0.6307398\",\n \"0.6287377\",\n \"0.6282867\",\n \"0.6281507\",\n \"0.6232615\",\n \"0.62198275\",\n \"0.6190656\",\n \"0.61890864\",\n \"0.6187388\",\n \"0.6172596\",\n \"0.61634064\",\n \"0.6159596\",\n \"0.6157667\",\n \"0.6153323\",\n \"0.61480534\",\n \"0.6139105\",\n \"0.61278695\",\n \"0.61247754\",\n \"0.60998374\",\n \"0.60986453\",\n \"0.6091511\",\n \"0.60884005\",\n \"0.6080704\",\n \"0.60776824\",\n \"0.60678023\",\n \"0.60564125\",\n \"0.60494256\",\n \"0.604927\",\n \"0.6047783\",\n \"0.60473233\",\n \"0.60296744\",\n \"0.60250133\",\n \"0.6023721\",\n \"0.60179156\",\n \"0.6017413\",\n \"0.59969765\",\n \"0.5994655\",\n \"0.599352\",\n \"0.5988078\",\n \"0.59868515\",\n \"0.59751683\",\n \"0.5962426\",\n \"0.59601253\",\n \"0.59601253\",\n \"0.59584135\",\n \"0.5953797\",\n \"0.5951116\",\n \"0.59443325\",\n \"0.59189427\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":496,"cells":{"query":{"kind":"string","value":"open shutter, one call per exposure/dither moves"},"document":{"kind":"string","value":"def test_do_apogee_science_4_pair_A_closed(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['apogee_science'])\n sopTester.updateModel('apogee', TestHelper.apogeeState['A_closed'])\n self._do_apogee_science(13, 72, 0, 0, ditherPairs=4)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def do_line_scan_shutter_closed(self):\n scan = self.scan\n laser = self.devices[scan['laser']['name']]\n shutter = self.scan['shutter']\n ni_daq = self.devices['NI-DAQ']\n ni_daq.driver.digital_output(shutter['port'], False)\n if not isinstance(shutter['delay'], Q_):\n delay = Q_(shutter['delay'])\n else:\n delay = shutter['delay']\n delay = delay.m_as('s')\n if delay > 0:\n time.sleep(delay)\n ni_daq.driver.digital_output(shutter['port'], True)\n print('Pumped Scan')\n laser.driver.execute_sweep()\n approx_time_to_scan = (laser.params['stop_wavelength'] - laser.params['start_wavelength']) / laser.params['wavelength_speed']*laser.params['wavelength_sweeps']\n\n while laser.driver.sweep_condition != 'Stop':\n sleep(approx_time_to_scan.m/config.monitor_read_scan)\n ni_daq.driver.digital_output(shutter['port'], False)\n laser.driver.wavelength = scan['laser']['params']['start_wavelength']\n \n # Repeat with shutter closed to get reference scan\n \n ni_daq.driver.digital_output(shutter['port'], False)\n if not isinstance(shutter['delay'], Q_):\n delay = Q_(shutter['delay'])\n else:\n delay = shutter['delay']\n delay = delay.m_as('s')\n if delay > 0:\n time.sleep(delay)\n print('Reference Scan')\n laser.driver.execute_sweep()\n approx_time_to_scan = (laser.params['stop_wavelength'] - laser.params['start_wavelength']) / laser.params['wavelength_speed']*laser.params['wavelength_sweeps']\n while laser.driver.sweep_condition != 'Stop':\n sleep(approx_time_to_scan.m/config.monitor_read_scan)\n laser.driver.wavelength = scan['laser']['params']['start_wavelength']\n \n return True","def sharpen_slide(self):\r\n std_input = self.horizontal.get() # Get the std defined by user\r\n c_input = self.vertical.get() # get the constant defined by the user\r\n img = self.master.images[-1] # Use the most recent displayed image for sharpening\r\n sharpened_image = sharpen.gaussian_unsharp_masking(img, std_input, c_input) # Apply unsharp masking on image\r\n self.master.display_image.display_image(img=sharpened_image) # display sharpened image\r\n self.master.images.append(sharpened_image) # Append the sharpened image on the stack\r","def run(self):\n openShutter = True\n actuateXed = False\n image_type = \"PPUMP\"\n\n wl = float(self.eo_config.get(\"PPUMP_WL\", 550))\n meas_flux = self.measured_flux(wl)\n seqno = 0\n for tokens in self.instructions:\n exptime = float(tokens[1])\n nframes = int(tokens[2])\n shifts = int(tokens[3])\n for iframe in range(nframes):\n self.image_clears()\n self.bias_image(seqno)\n self.take_image(seqno, exptime, openShutter, actuateXed,\n image_type)\n seqno += 1","def sync_shutter(self):\n shutter = self.scan['shutter']\n ni_daq = self.devices['NI-DAQ']\n ni_daq.driver.digital_output(shutter['port'], False)\n time.sleep(0.2)\n ni_daq.driver.digital_output(shutter['port'], True)\n time.sleep(0.2)\n ni_daq.driver.digital_output(shutter['port'], False)","def testSharpen (name = \"smokey.gif\", degree = 50, amount = 20):\n image = Image(name)\n print(\"Close the image window to see the transformation\")\n image.draw()\n image2 = sharpen(image, degree, amount)\n image2.draw()","def main():\n camera = picamera.PiCamera()\n camera.resolution = (RESOLUTIONX, RESOLUTIONY)\n camera.iso = 800\n time.sleep(2)\n while True:\n camera.capture('current-image.jpg')\n adapt_steering(navigation.get_xposition('current-image.jpg'))\n time.sleep(0.4)","def shutter_pulse(self, width):\n step_name = 'Shutter Pulse'\n self.shutter.settings['shutter_open'] = True\n self.db_poll(step_name)\n print('Shutter open')\n t0 = time.time()\n t_lastlog = t0\n while True:\n if self.interrupt_measurement_called:\n self.shutter.settings['shutter_open'] = False\n break\n if time.time()-t0 > width:\n break\n time.sleep(0.001)\n if time.time() - t_lastlog > 0.2:\n # do some logging\n self.db_poll(step_name)\n t_lastlog = time.time()\n \n self.shutter.settings['shutter_open'] = False\n self.settings['steps_taken'] += 1\n print('Shutter closed')","def measure_darks(det, shutter, quantity):\n yield from set_dark_frame()\n yield from bps.mv(shutter, \"close\")\n yield from _acquire_n_frames(det, quantity)","def shar():\n pass","def warmup():\n print camera.CoolerOFF()\n camera.status.update()","def shutter(self, state):\n if self.status != \"not connected\":\n m = self.serial\n m.write(\"shutter \" + str(state) + \"\\r\\n\")\n r = m.read(100)\n if state == 'O':\n st = \"open\"\n else:\n st = \"closed\"\n result = \"out.monochrom: Shutter is \" + st\n return result\n else:\n pass","def sample_damaging(image):\r\n return crease_image(blotch_image(image, 100, True), 10, False)","def expose(self):\n if self.camera is None: # test mode -- immediately return test image\n print(\"NO SPECTRAL CAMERA FOUND -- USING TEST DATA\")\n self.filename = \"example_fits_files/Mooi\"\n return\n\n exposure_time = self.time.get()\n try:\n self.exposure_time = float(exposure_time)\n except:\n message = \"Exposure time \\\"{0}\\\" cannot be converted to floating point number\".format(exposure_time)\n messagebox.showerror(\"Error\", message)\n raise ValueError(message)\n filename = \"spectra/{0}\".format(timestamp())\n self.camera.spectrum(self.exposure_time, filename)\n self.filename = filename","def setShutter( self, c, devChannel, state ):\n dev = 'shutter'\n self.validateDevChannel( dev, devChannel )\n self.validateInput( dev, state )\n channel = self.dcDict[dev]['devChannels'][devChannel]['channel']\n self.tryToSend( channel, state )","def skywalker(this, **kargs):\n\t\t\n\t\t# Arguments\n\t\tbin = kargs.get('bin', this._BINARY)\n\t\toffshore = kargs.get('offshore', 5)\n\t\tminSize = kargs.get('minSize', 3)\n\t\tblur = kargs.get('blur', False)\n\t\t\n\t\tif blur: # Flou de test\n\t\t\tkernel = np.ones((3, 3), np.float32)/9\n\t\t\tbin = cv2.filter2D(bin, -1, kernel)\n\t\t\n\t\t# On duplique l'image pour le rendu final\n\t\tscan = EmptyFrom(bin, 3)\n\t\tscan[:,:,0] = scan[:,:,1] = scan[:,:,2] = bin\n\t\tthis._SCAN = scan\n\t\t\n\t\tstep = 0 # Compteur de pas dans le vide\n\t\tstart, end = None, None\n\t\t\n\t\t# Dimensions de l'image à scanner\n\t\tsize = D2Point(width(bin), height(bin))\n\t\tratio = size if minSize < 1 else 1\n\t\t\n\t\t# Scan pixel par pixel, en partant du bas\n\t\tfor v in xrange(int(size.y)-1, -1, -1):\n\t\t\tfor u in xrange(int(size.x)):\n\t\t\t\n\t\t\t\tif bin.item((v, u)): # Si un pixel != 0:\n\t\t\t\t\tscan[v,u] = [0, 0, 255] # Rouge.\n\t\t\t\t\tstep = 0 # On reset le jump\n\t\t\t\t\t\n\t\t\t\t\t# Si c'est le premier\n\t\t\t\t\tif not start:\n\t\t\t\t\t\tstart = D2Point(u, v)\n\t\t\t\t\t\tend = D2Point(u, v)\n\t\t\t\t\telse: # On trace\n\t\t\t\t\t\tend.x, end.y = u, v\n\t\t\t\t\n\t\t\t\telif end:\n\t\t\t\t\tif step < offshore:\n\t\t\t\t\t\tscan[v,u] = [0, 255, 255] # Jaune\n\t\t\t\t\t\tstep += 1 # On continue\n\t\t\t\t\telif abs((start - end)/ratio) < minSize:\n\t\t\t\t\t\tstart, end = None, None\n\t\t\t\t\telse: break\n\t\t\t\t# elif end: break\n\t\t\t###\n\t\t\tif end: break\n\t\t###\n\t\t\n\t\tif end: # Si on a trouvé une fin\n\t\t\t\n\t\t\t# Point médian = doigt\n\t\t\tresult = start % end\n\t\t\t\n\t\t\t# Visuel\n\t\t\tscan[:,result.x,:] = [0, 255, 0] # On trace une bande verte\n\t\t\tscan[result.y,:,:] = [0, 127, 0] # On trace une autre bande verte\n\t\t\t\n\t\t\t# Reformatage\n\t\t\tresult /= size-1 # On remet en ratio d'image\n\t\t\tresult.x = 1 - result.x # On inverse le côté de mesure\n\t\t\t\n\t\t\t# Stockage\n\t\t\tthis._DETECTED = result # On stocke le point détecté\n\t\t\tthis._BOTTOM = result.y == 1 # On clic ou bien ?\n\t\t\n\t\t# Si rien\n\t\telse:\n\t\t\tresult = None\n\t\t\tthis._BOTTOM = False\n\t\t\n\t\t# Tchao\n\t\treturn result","def wfits(self, filename=None):\n with self.lock:\n dark = self.dark\n if not filename:\n if dark != 0:\n filename = self.getNextFilename(\"dark\")\n else:\n filename = self.getNextFilename(\"object\")\n with self.lock:\n if(self.data.size == 0):\n raise FliError(\"No image available\")\n hdu = pyfits.PrimaryHDU(self.data)\n hdr = hdu.header\n with self.lock:\n hdr.set('DATE', self.timestamp, 'exposure begin date')\n hdr.set('INSTRUME', self.devname, 'this instrument')\n hdr.set('SERIAL', self.devsn, 'serial number')\n hdr.set('EXPTIME', self.exptime, 'exposure time (ms)')\n hdr.set('VBIN', self.vbin, 'vertical binning')\n hdr.set('HBIN', self.hbin, 'horizontal binning')\n hdr.set('CCD-TEMP', self.temp, 'CCD temperature')\n if dark != 0:\n hdr.set('SHUTTER', 'CLOSE', 'shutter status')\n else:\n hdr.set('SHUTTER', 'OPEN', 'shutter status')\n hdr.set('CCDAREA', '[%d:%d,%d:%d]' % self.expArea, 'image area')\n hdu.writeto(filename, overwrite=True, checksum=True)\n with self.lock:\n self.filename = filename","def start(self):\n self.frame = 0\n self._init_level(1)\n self.reward = 0\n self.pcontinue = 1\n self.ghost_speed = self.ghost_speed_init\n return self._make_image(), self.reward, self.pcontinue","def __init__(\n self,\n win,\n outer_diam_pix,\n inner_diam_pix,\n bg_colour=(-1, -1, -1),\n line_colour=(+1, +1, +1),\n spot_colour=(-1, -1, -1),\n circle_edges=128,\n ):\n\n self._win = win\n self._outer_diam_pix = outer_diam_pix\n self._inner_diam_pix = inner_diam_pix\n self._circle_edges = circle_edges\n self._stim = {}\n\n self._stim[\"aperture\"] = psychopy.visual.Aperture(\n win=win,\n size=self._outer_diam_pix,\n nVert=self._circle_edges,\n shape=\"circle\",\n units=\"pix\",\n autoLog=False,\n )\n\n self._stim[\"aperture\"].enabled = False\n\n self._stim[\"bg\"] = psychopy.visual.Circle(\n win=self._win,\n radius=self._outer_diam_pix / 2.0,\n units=\"pix\",\n lineColor=None,\n fillColor=bg_colour,\n edges=self._circle_edges,\n autoLog=False,\n )\n\n self._stim[\"line\"] = psychopy.visual.Rect(\n win=self._win,\n size=(self._outer_diam_pix * 2, self._inner_diam_pix),\n units=\"pix\",\n lineWidth=0,\n lineColor=None,\n fillColor=line_colour,\n autoLog=False,\n )\n\n self._stim[\"spot\"] = psychopy.visual.Circle(\n win=self._win,\n radius=self._inner_diam_pix / 2.0,\n units=\"pix\",\n fillColor=spot_colour,\n edges=self._circle_edges,\n lineWidth=0,\n autoLog=False,\n )\n\n self.bg_colour = bg_colour\n self.line_colour = line_colour\n self.spot_colour = spot_colour","def _generate_exposure(self, expstart, number):\n\n index_number = number - 1 # for zero indexing\n\n filename = '{:04d}_raw.fits'.format(number)\n\n exp_gen = ExposureGenerator(self.detector, self.grism, self.NSAMP,\n self.SAMPSEQ, self.SUBARRAY,\n self.planet, filename, expstart)\n\n if not self.spatial_scan:\n self.sample_rate = 1 * u.year # high number reverts to read times\n\n _, sample_mid_points, sample_durations, read_index = \\\n exp_gen._gen_scanning_sample_times(self.sample_rate)\n\n time_array = (sample_mid_points + expstart).to(u.day)\n\n if self.transmission_spectroscopy:\n star_norm_flux = self.generate_lightcurves(time_array)\n planet_depths = 1 - star_norm_flux\n else:\n planet_depths = None\n\n # x shifts - linear shift with exposure, second exposure shifted by\n # x_shifts, direct image and first exp will match.\n x_ref = self._try_index(self.x_ref, index_number)\n y_ref = self._try_index(self.y_ref, index_number)\n sky_background = self._try_index(self.sky_background, index_number)\n\n # X and Y Shifts\n x_ref += self.x_shifts * index_number\n y_ref += self.y_shifts * index_number\n x_jitter = self.x_jitter\n y_jitter = self.y_jitter\n\n if self._visit_trend:\n scale_factor = self._visit_trend.get_scale_factor(index_number)\n else:\n scale_factor = None\n\n if self.spatial_scan:\n exp_frame = exp_gen.scanning_frame(\n x_ref, y_ref, x_jitter, y_jitter,\n self.wl, self.stellar_flux, planet_depths,\n self.scan_speed, self.sample_rate, sample_mid_points,\n sample_durations, read_index, ssv_generator=self.ssv_gen,\n noise_mean=self.noise_mean, noise_std=self.noise_std,\n add_flat=self.add_flat, add_dark=self.add_dark,\n scale_factor=scale_factor, sky_background=sky_background,\n cosmic_rate=self.cosmic_rate,\n add_gain_variations=self.add_gain_variations,\n add_non_linear=self.add_non_linear,\n clip_values_det_limits=self.clip_values_det_limits,\n add_read_noise=self.add_read_noise,\n add_stellar_noise=self.add_stellar_noise,\n add_initial_bias=self.add_initial_bias,\n progress_bar=self.progess,\n threads=self.threads\n )\n else:\n exp_frame = exp_gen.staring_frame(\n x_ref, y_ref, x_jitter, y_jitter,\n self.wl, self.stellar_flux, planet_depths,\n sample_mid_points, sample_durations, read_index,\n noise_mean=self.noise_mean, noise_std=self.noise_std,\n add_flat=self.add_flat, add_dark=self.add_dark,\n scale_factor=scale_factor, sky_background=sky_background,\n cosmic_rate=self.cosmic_rate,\n add_gain_variations=self.add_gain_variations,\n add_non_linear=self.add_non_linear,\n clip_values_det_limits=self.clip_values_det_limits,\n add_read_noise=self.add_read_noise,\n add_stellar_noise=self.add_stellar_noise,\n add_initial_bias=self.add_initial_bias,\n progress_bar=self.progess,\n threads=self.threads\n )\n\n exp_frame.generate_fits(self.outdir, filename, ldcoeffs=self.ldcoeffs)\n\n return exp_frame","def cmdMouse(self, dev):\n self.hitsMouses[dev] = False\n f = open(self.inputPath + dev, 'rb')\n while self.live:\n f.read(500) # 144 kan eigenlijk alles zijn, behalve absurbt hoge waarden..\n self.hitsMouses[dev] = True\n time.sleep(0.1)","def effect_spread(self, distance):\n self.load()\n return self._new(self.im.effect_spread(distance))","def go():\n ##########\n #\n # MB19284\n #\n ##########\n\n ##########\n # Kp-band reduction\n ##########\n\n target = 'mb19284'\n sci_files = ['i200822_a011{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\n sci_files += ['i200822_a012{0:03d}_flip'.format(ii) for ii in range(2, 25+1)]\n sky_files = ['i200822_a018{0:03d}_flip'.format(ii) for ii in range(2, 6+1)]\n refSrc = [917.75, 1033.5] # This is the target\n # Alternative star to try (bright star to bottom of target): [1015, 581.9]\n \n sky.makesky(sky_files, target, 'kp_tdOpen', instrument=osiris)\n data.clean(sci_files, target, 'kp_tdOpen', refSrc, refSrc, field=target, instrument=osiris)\n data.calcStrehl(sci_files, 'kp_tdOpen', field=target, instrument=osiris)\n data.combine(sci_files, 'kp_tdOpen', epoch, field=target,\n trim=0, weight='strehl', submaps=3, instrument=osiris)\n\n ##########\n #\n # KB200101\n #\n ##########\n\n ##########\n # Kp-band reduction\n ##########\n\n # -- If you have more than one position angle, make sure to\n # clean them seperatly.\n # -- Strehl and Ref src should be the pixel coordinates of a bright\n # (but non saturated) source in the first exposure of sci_files.\n # -- If you use the OSIRIS image, you must include the full filename in the list. \n target = 'kb200101'\n sci_files = ['i200822_a014{0:03d}_flip'.format(ii) for ii in range(2, 28+1)]\n sci_files += ['i200822_a015{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\n sci_files += ['i200822_a016{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\n sky_files = ['i200822_a017{0:03d}_flip'.format(ii) for ii in range(2, 6+1)]\n refSrc = [975, 1006] # This is the target\n # Alternative star to try (bright star to right of target): [1158, 994]\n \n sky.makesky(sky_files, target, 'kp_tdOpen', instrument=osiris)\n data.clean(sci_files, target, 'kp_tdOpen', refSrc, refSrc, field=target, instrument=osiris)\n data.calcStrehl(sci_files, 'kp_tdOpen', field=target, instrument=osiris)\n data.combine(sci_files, 'kp_tdOpen', epoch, field=target,\n trim=1, weight='strehl', submaps=3, instrument=osiris)","def main():\n\n with its.device.ItsSession() as cam:\n\n props = cam.get_camera_properties()\n its.caps.skip_unless(its.caps.raw16(props) and\n its.caps.manual_sensor(props) and\n its.caps.read_3a(props) and\n its.caps.per_frame_control(props) and\n not its.caps.mono_camera(props))\n debug = its.caps.debug_mode()\n\n # Expose for the scene with min sensitivity\n exp_min, exp_max = props[\"android.sensor.info.exposureTimeRange\"]\n sens_min, _ = props[\"android.sensor.info.sensitivityRange\"]\n # Digital gains might not be visible on RAW data\n sens_max = props[\"android.sensor.maxAnalogSensitivity\"]\n sens_step = (sens_max - sens_min) / NUM_ISO_STEPS\n white_level = float(props[\"android.sensor.info.whiteLevel\"])\n black_levels = [its.image.get_black_level(i,props) for i in range(4)]\n # Get the active array width and height.\n aax = props[\"android.sensor.info.activeArraySize\"][\"left\"]\n aay = props[\"android.sensor.info.activeArraySize\"][\"top\"]\n aaw = props[\"android.sensor.info.activeArraySize\"][\"right\"]-aax\n aah = props[\"android.sensor.info.activeArraySize\"][\"bottom\"]-aay\n raw_stat_fmt = {\"format\": \"rawStats\",\n \"gridWidth\": aaw/IMG_STATS_GRID,\n \"gridHeight\": aah/IMG_STATS_GRID}\n\n e_test = []\n mult = 1.0\n while exp_min*mult < exp_max:\n e_test.append(int(exp_min*mult))\n mult *= EXP_MULT\n if e_test[-1] < exp_max * INCREASING_THR:\n e_test.append(int(exp_max))\n e_test_ms = [e / 1000000.0 for e in e_test]\n\n for s in range(sens_min, sens_max, sens_step):\n means = []\n means.append(black_levels)\n reqs = [its.objects.manual_capture_request(s, e, 0) for e in e_test]\n # Capture raw in debug mode, rawStats otherwise\n caps = []\n for i in range(len(reqs) / SLICE_LEN):\n if debug:\n caps += cam.do_capture(reqs[i*SLICE_LEN:(i+1)*SLICE_LEN], cam.CAP_RAW)\n else:\n caps += cam.do_capture(reqs[i*SLICE_LEN:(i+1)*SLICE_LEN], raw_stat_fmt)\n last_n = len(reqs) % SLICE_LEN\n if last_n == 1:\n if debug:\n caps += [cam.do_capture(reqs[-last_n:], cam.CAP_RAW)]\n else:\n caps += [cam.do_capture(reqs[-last_n:], raw_stat_fmt)]\n elif last_n > 0:\n if debug:\n caps += cam.do_capture(reqs[-last_n:], cam.CAP_RAW)\n else:\n caps += cam.do_capture(reqs[-last_n:], raw_stat_fmt)\n\n # Measure the mean of each channel.\n # Each shot should be brighter (except underexposed/overexposed scene)\n for i,cap in enumerate(caps):\n if debug:\n planes = its.image.convert_capture_to_planes(cap, props)\n tiles = [its.image.get_image_patch(p, 0.445, 0.445, 0.11, 0.11) for p in planes]\n mean = [m * white_level for tile in tiles\n for m in its.image.compute_image_means(tile)]\n img = its.image.convert_capture_to_rgb_image(cap, props=props)\n its.image.write_image(img, \"%s_s=%d_e=%05d.jpg\" % (NAME, s, e_test))\n else:\n mean_image, _ = its.image.unpack_rawstats_capture(cap)\n mean = mean_image[IMG_STATS_GRID/2, IMG_STATS_GRID/2]\n\n print \"ISO=%d, exposure time=%.3fms, mean=%s\" % (\n s, e_test[i] / 1000000.0, str(mean))\n means.append(mean)\n\n\n # means[0] is black level value\n r = [m[0] for m in means[1:]]\n gr = [m[1] for m in means[1:]]\n gb = [m[2] for m in means[1:]]\n b = [m[3] for m in means[1:]]\n\n pylab.plot(e_test_ms, r, \"r.-\")\n pylab.plot(e_test_ms, b, \"b.-\")\n pylab.plot(e_test_ms, gr, \"g.-\")\n pylab.plot(e_test_ms, gb, \"k.-\")\n pylab.xscale('log')\n pylab.yscale('log')\n pylab.title(\"%s ISO=%d\" % (NAME, s))\n pylab.xlabel(\"Exposure time (ms)\")\n pylab.ylabel(\"Center patch pixel mean\")\n matplotlib.pyplot.savefig(\"%s_s=%d.png\" % (NAME, s))\n pylab.clf()\n\n allow_under_saturated = True\n for i in xrange(1, len(means)):\n prev_mean = means[i-1]\n mean = means[i]\n\n if np.isclose(max(mean), white_level, rtol=SATURATION_TOL):\n print \"Saturated: white_level %f, max_mean %f\"% (white_level, max(mean))\n break;\n\n if allow_under_saturated and np.allclose(mean, black_levels, rtol=BLK_LVL_TOL):\n # All channel means are close to black level\n continue\n\n allow_under_saturated = False\n # Check pixel means are increasing (with small tolerance)\n channels = [\"Red\", \"Gr\", \"Gb\", \"Blue\"]\n for chan in range(4):\n err_msg = \"ISO=%d, %s, exptime %3fms mean: %.2f, %s mean: %.2f, TOL=%.f%%\" % (\n s, channels[chan],\n e_test_ms[i-1], mean[chan],\n \"black level\" if i == 1 else \"exptime %3fms\"%e_test_ms[i-2],\n prev_mean[chan],\n INCREASING_THR*100)\n assert mean[chan] > prev_mean[chan] * INCREASING_THR, err_msg","def sharpen(im):\n kernel = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]])\n im = cv2.filter2D(im, -1, kernel)\n return im","def surf_bright(im, coord, minrad=3.):\n r = minrad\n slist = []\n while r < 80:\n aperture = CircularAperture(coord, r=r)\n phot_tab = aperture_photometry(im, aperture)\n s = phot_tab['aperture_sum']\n sb = s/(np.pi * r**2)\n print(sb)\n r += 1","def expose(self, cmd, expTime, expType):\n\n if not expType:\n expType = 'test'\n if cmd:\n cmd.inform('exposureState=\"exposing\"')\n if expType not in ('bias', 'test') and expTime > 0:\n time.sleep(expTime + self._exposureOverheadTime())\n\n if cmd:\n cmd.inform('exposureState=\"reading\"')\n\n f = pyfits.open('/home/chyan/mhs/data/mcs/schmidt_fiber_snr400_rmod71.fits')\n image = f[0].data\n # image = numpy.random.normal(self.biasLevel,\n # scale=self.readNoise,\n # size=self.imageSize).astype('u2')\n\n if expType != 'test':\n time.sleep(self._readoutTime())\n return image","def sharpen(image_path, factor=3):\n BasicTransform.convert_image(image_path)\n\n with Image.open(image_path) as img:\n filter = ImageEnhance.Sharpness(img)\n new_image = filter.enhance(factor)\n new_image.save(image_path)","def expand_slicer_aperture(system):\n\n # First of all, we need to find the Surface Number for the IMAGE SLICER\n N_surfaces = system.LDE.NumberOfSurfaces\n surface_names = {} # A dictionary of surface number -> surface comment\n for k in np.arange(1, N_surfaces):\n surface_names[k] = system.LDE.GetSurfaceAt(k).Comment\n # find the Slicer surface number\n try:\n # The naming convention for this surface has changed. Not the same for Nominal Design as Monte Carlos\n slicer_num = list(surface_names.keys())[list(surface_names.values()).index('Slicer Mirror')]\n except ValueError:\n slicer_num = list(surface_names.keys())[list(surface_names.values()).index('IFU ISA')]\n slicer = system.LDE.GetSurfaceAt(slicer_num)\n\n # Read Current Aperture Settings\n apt_type = slicer.ApertureData.CurrentType\n # print(\"Aperture type: \", apt_type)\n if apt_type == 4: # 4 is Rectangular aperture\n current_apt_sett = slicer.ApertureData.CurrentTypeSettings\n # print(\"Current Settings:\")\n x0 = current_apt_sett._S_RectangularAperture.XHalfWidth\n y0 = current_apt_sett._S_RectangularAperture.YHalfWidth\n # If the Y aperture hasn't been changed already, we change it here to 999 mm to get all rays through\n if y0 != 999:\n # Change Settings\n aperture_settings = slicer.ApertureData.CreateApertureTypeSettings(\n constants.SurfaceApertureTypes_RectangularAperture)\n aperture_settings._S_RectangularAperture.XHalfWidth = x0\n aperture_settings._S_RectangularAperture.YHalfWidth = 999\n slicer.ApertureData.ChangeApertureTypeSettings(aperture_settings)\n\n current_apt_sett = slicer.ApertureData.CurrentTypeSettings\n # Notify that we have successfully modified the aperture\n print(\"Changing aperture of surface: \", slicer.Comment)\n print(\"New Settings:\")\n print(\"X_HalfWidth = %.2f\" % current_apt_sett._S_RectangularAperture.XHalfWidth)\n print(\"Y_HalfWidth = %.2f\" % current_apt_sett._S_RectangularAperture.YHalfWidth)\n\n return","def apply_sharpening_on(image):\n # Create kernel\n kernel = np.array([[0, -1, 0],\n [-1, 5, -1],\n [0, -1, 0]])\n\n # Sharpen image\n sharp_image = cv2.filter2D(image, -1, kernel)\n return sharp_image","def on_run(self):\n self.set_illumination({'mode': 'breathe'})","def main():\n NAME = os.path.basename(__file__).split(\".\")[0]\n\n with its.device.ItsSession() as cam:\n\n props = cam.get_camera_properties()\n\n white_level = float(props['android.sensor.info.whiteLevel'])\n black_levels = props['android.sensor.blackLevelPattern']\n idxs = its.image.get_canonical_cfa_order(props)\n black_levels = [black_levels[i] for i in idxs]\n\n # Expose for the scene with min sensitivity\n sens_min, sens_max = props['android.sensor.info.sensitivityRange']\n s_ae,e_ae,awb_gains,awb_ccm,_ = cam.do_3a(get_results=True)\n s_e_prod = s_ae * e_ae\n\n # Make the image brighter since the script looks at linear Bayer\n # raw patches rather than gamma-encoded YUV patches (and the AE\n # probably under-exposes a little for this use-case).\n s_e_prod *= 2\n\n # Capture raw frames across the full sensitivity range.\n NUM_SENS_STEPS = 15\n sens_step = int((sens_max - sens_min - 1) / float(NUM_SENS_STEPS))\n reqs = []\n sens = []\n for s in range(sens_min, sens_max, sens_step):\n e = int(s_e_prod / float(s))\n req = its.objects.manual_capture_request(s, e)\n req[\"android.colorCorrection.transform\"] = \\\n its.objects.float_to_rational(awb_ccm)\n req[\"android.colorCorrection.gains\"] = awb_gains\n reqs.append(req)\n sens.append(s)\n\n caps = cam.do_capture(reqs, cam.CAP_RAW)\n\n # A list of the (x,y) coords of the center pixel of a collection of\n # patches of a color checker chart. Each patch should be uniform,\n # however the actual color doesn't matter. Note that the coords are\n # relative to the *converted* RGB image, which is 1/2 x 1/2 of the\n # full size; convert back to full.\n img = its.image.convert_capture_to_rgb_image(caps[0], props=props)\n patches = its.image.get_color_checker_chart_patches(img, NAME+\"_debug\")\n patches = [(2*x,2*y) for (x,y) in sum(patches,[])]\n\n lines = []\n for (s,cap) in zip(sens,caps):\n # For each capture, compute the mean value in each patch, for each\n # Bayer plane; discard patches where pixels are close to clamped.\n # Also compute the variance.\n CLAMP_THRESH = 0.2\n planes = its.image.convert_capture_to_planes(cap, props)\n points = []\n for i,plane in enumerate(planes):\n plane = (plane * white_level - black_levels[i]) / (\n white_level - black_levels[i])\n for j,(x,y) in enumerate(patches):\n tile = plane[y/2-16:y/2+16:,x/2-16:x/2+16:,::]\n mean = its.image.compute_image_means(tile)[0]\n var = its.image.compute_image_variances(tile)[0]\n if (mean > CLAMP_THRESH and mean < 1.0-CLAMP_THRESH):\n # Each point is a (mean,variance) tuple for a patch;\n # for a given ISO, there should be a linear\n # relationship between these values.\n points.append((mean,var))\n\n # Fit a line to the points, with a line equation: y = mx + b.\n # This line is the relationship between mean and variance (i.e.)\n # between signal level and noise, for this particular sensor.\n # In the DNG noise model, the gradient (m) is \"S\", and the offset\n # (b) is \"O\".\n points.sort()\n xs = [x for (x,y) in points]\n ys = [y for (x,y) in points]\n m,b = numpy.polyfit(xs, ys, 1)\n lines.append((s,m,b))\n print s, \"->\", m, b\n\n # TODO: Clean up these checks (which currently fail in some cases).\n # Some sanity checks:\n # * Noise levels should increase with brightness.\n # * Extrapolating to a black image, the noise should be positive.\n # Basically, the \"b\" value should correspnd to the read noise,\n # which is the noise level if the sensor was operating in zero\n # light.\n #assert(m > 0)\n #assert(b >= 0)\n\n # Draw a plot.\n pylab.plot(xs, ys, 'r')\n pylab.plot([0,xs[-1]],[b,m*xs[-1]+b],'b')\n matplotlib.pyplot.savefig(\"%s_plot_mean_vs_variance.png\" % (NAME))\n\n # Now fit a line across the (m,b) line parameters for each sensitivity.\n # The gradient (m) params are fit to the \"S\" line, and the offset (b)\n # params are fit to the \"O\" line, both as a function of sensitivity.\n gains = [d[0] for d in lines]\n Ss = [d[1] for d in lines]\n Os = [d[2] for d in lines]\n mS,bS = numpy.polyfit(gains, Ss, 1)\n mO,bO = numpy.polyfit(gains, Os, 1)\n\n # Plot curve \"O\" as 10x, so it fits in the same scale as curve \"S\".\n pylab.plot(gains, [10*o for o in Os], 'r')\n pylab.plot([gains[0],gains[-1]],\n [10*mO*gains[0]+10*bO, 10*mO*gains[-1]+10*bO], 'b')\n pylab.plot(gains, Ss, 'r')\n pylab.plot([gains[0],gains[-1]], [mS*gains[0]+bS, mS*gains[-1]+bS], 'b')\n matplotlib.pyplot.savefig(\"%s_plot_S_O.png\" % (NAME))\n\n print \"\"\"\n /* Generated test code to dump a table of data for external validation\n * of the noise model parameters.\n */\n #include <stdio.h>\n #include <assert.h>\n double compute_noise_model_entry_S(int sens);\n double compute_noise_model_entry_O(int sens);\n int main(void) {\n int sens;\n for (sens = %d; sens <= %d; sens += 100) {\n double o = compute_noise_model_entry_O(sens);\n double s = compute_noise_model_entry_S(sens);\n printf(\"%%d,%%lf,%%lf\\\\n\", sens, o, s);\n }\n return 0;\n }\n\n /* Generated functions to map a given sensitivity to the O and S noise\n * model parameters in the DNG noise model.\n */\n double compute_noise_model_entry_S(int sens) {\n double s = %e * sens + %e;\n return s < 0.0 ? 0.0 : s;\n }\n double compute_noise_model_entry_O(int sens) {\n double o = %e * sens + %e;\n return o < 0.0 ? 0.0 : o;\n }\n \"\"\"%(sens_min,sens_max,mS,bS,mO,bO)","def grass_drass():","def flat(s='flat'):\n s = s.strip()[:80] #truncate to 80 char to fit in FITS header\n print camera.SetShutter(0)\n camera.status.imgtype = 'FLAT'\n camera.status.object = s\n camera.status.update()","def __call__(self, frame_num):\n # propagate and set the density\n self.img.set_array(\n np.abs(self.quant_sys.propagate(10)) ** 2\n )\n return self.img,","def opd_dither(cfg):\n \n setpoint_new = pi.getINDI('PLC.UBCSettings.PLSetpoint')\n file_number = pi.getINDI('NOMIC.CamInfo.FIndex') # Get initial file number\n offsets = np.array(cfg['nomic_dither_opd_pattern']) * 5.0 * 180.0 / np.pi # input in rad at 11um, but commandet offsets in deg in K band\n pi.setINDI('NOMIC.EditFITS.Keyword=spdthpos;Value=0.0;Comment=setpoint dither position (offset from nominal setpoint) in rad')\n while True:\n for i_step in range(0, len(cfg['nomic_dither_opd_pattern'])):\n file_number = file_number + cfg['nomic_dither_opd_ndits'][i_step]\n try:\n pi.evalINDI ('\"NOMIC.CamInfo.FIndex\" >= %d' % file_number, timeout=900) # wait for cfg['nomic_dither_opd_ndits'][i] new files to arrive\n except:\n info('OPD dither offset timed out (more than 15 min since last offset)')\n print(' or was interrupted.')\n print(' Make sure to restart OPD dither pattern.')\n return()\n setpoint_old = pi.getINDI('PLC.UBCSettings.PLSetpoint') # ask for current setpoint\n if (setpoint_old - setpoint_new) > 2.9: # if expected setpoint is more than ~0.01 rad (at 11um) different from current setpoint\n info('Setpoint has changed between two dither positions.')\n setpoint_new = setpoint_old + offsets[i_step] # determine new setpoint\n pi.setINDI('NOMIC.EditFITS.Keyword=spdthpos;Value=' + str(np.sum(offsets[:i_step+1])) + ';Comment=setpoint dither position (offset from nominal setpoint) in rad')\n pi.setINDI('PLC.PLSetpoint.PLSetpoint=' + str(setpoint_new) + ';forNAC=0') # send a dither offset","def farm(w,h,status='harvest',loops=1):\n h1 = int(h/2) # var to get seeds from first half (or fewer) of rows\n food_key = 5 # hotbar key for food\n dirt_place_time = 4.5\n walk_time = 0.33\n wait_time = 0.7\n grow_time = 540 # time for plants to grow = 600s - (time to log out & in) \n \n ctrl.resetCamera('down')\n for loop in range(loops):\n for y in range(h):\n for x in range(w):\n # checks if char is hungry before moving, & eats food on food_key\n if img_obj.isHungry():\n ctrl.eatFood(key=food_key)\n if status == 'harvest':\n # picks up farm patch, loot seeds, places farm patch, continues \n if y < h1: \n ctrl.selectOption('down')\n time.sleep(dirt_place_time) # takes 3 sec + more time due to server lag\n ctrl.selectOption('right')\n ctrl.loot() \n \n ctrl.walk('down', walk_time * 2, jump=True)\n ctrl.selectOption('down')\n ctrl.clickLMB()\n time.sleep(dirt_place_time)\n \n ctrl.walk('up', walk_time, jump=True)\n \n else:\n ctrl.selectOption('right')\n for i in range(12): # takes 5 seconds to harvest, in 6 seconds, f key is pressed 12 times\n ctrl.loot()\n time.sleep(.5)\n \n time.sleep(wait_time) # delay to make sure it jumps to the next patch\n # plants seeds - assumes char is holding seeds\n ctrl.selectOption('right')\n for i in range(12): # takes 5 seconds to harvest, in 5.5 seconds, f key is pressed 11 times\n ctrl.loot()\n time.sleep(.5)\n time.sleep(wait_time)\n \n # moves char to next farm patch\n if x != (w-1): # if not on last farm patch of row\n if y % 2 == 0:\n direction = 'left'\n else:\n direction = 'right'\n ctrl.walk(direction, walk_time, jump=True)\n time.sleep(wait_time) # delay for server lag\n \n # moves char up to next row if not on last row\n if y != (h-1):\n ctrl.walk('up', walk_time, jump=True)\n \n # final loot loop to get remaining items\n # for i in range(10):\n # ctrl.loot()\n # time.sleep(.5)\n \n # returns char to bottom right farm patch\n if (h) % 2 != 0: # if height is odd, move char to right side\n for x in range(w-1):\n ctrl.walk('right', walk_time, jump=True)\n time.sleep(wait_time)\n for y in range(h-1):\n ctrl.walk('down', walk_time * 2, jump=True)\n time.sleep(wait_time)\n \n # returns to lobby, waits for plants to grow, logs in\n ctrl.returnToLobby()\n time.sleep(grow_time)\n ctrl.enterGame()\n # resets camera to be aligned facing North as camera will always be pointed North after logging in\n ctrl.walk('up', .1, jump=True) \n time.sleep(wait_time)\n ctrl.walk('down', .1, jump=True)\n \n ctrl.resetCamera('down')\n # when relogging, char is displaced sometimes, this checks if field is selected, if not it'll try to find it, if that fails the program exits\n if not (img_obj.checkObjTitle('field')):\n ctrl.walk('left', walk_time, jump=True)\n if not (img_obj.checkObjTitle('field')):\n ctrl.walk('up', walk_time, jump=True)\n if not (img_obj.checkObjTitle('field')):\n break","def expose(self):\n\n ## Determine type of exposure (exp, series, stack)\n exptype = str(self.exptypeComboBox.currentText())\n mode = self.modedict[exptype]\n\n ## Get exposure parameters\n if mode == \"bias\":\n exptime = 0.0\n else:\n exptime = self.exptimeSpinBox.value()\n imcount = self.imstackSpinBox.value()\n seqnum = self.imnumSpinBox.value()\n mintime = self.minexpSpinBox.value()\n maxtime = self.maxexpSpinBox.value()\n step = self.tstepSpinBox.value()\n\n ## Determine filter kwargs\n if self.filterToggleButton.isChecked():\n kwargs = {'filter_name' : str(self.filterComboBox.currentText())}\n else:\n kwargs = {'monowl' : self.monoSpinBox.value()}\n\n if self.testimCheckBox.isChecked():\n title = 'test'\n else:\n title = str(self.imtitleLineEdit.text())\n\n ## Build filepath\n filepath = os.path.join(str(self.imfilenameLineEdit.text()),title)\n \n ## Check if single exposure\n if exptype in [\"Exposure\", \"Dark\", \"Bias\"]:\n\n ## Perform exposure\n self.logger.info(\"Starting {0}s {1} image.\".format(exptime, exptype))\n self.image_start.emit(1)\n\n try:\n filename = exposure.im_acq(mode, filepath, exptime, seqnum, **kwargs)\n self.image_taken.emit(1)\n except subprocess.CalledProcessError:\n self.logger.exception(\"Error in executable {0}_acq. Image not taken.\".format(mode))\n except OSError:\n self.logger.exception(\"Executable {0}_acq not found. Image not taken\".format(mode))\n except IOError:\n self.logger.exception(\"File already exits. Image not taken.\")\n else:\n self.logger.info(\"Exposure {0} finished successfully.\".format(filename))\n self.seqnum_inc.emit(seqnum)\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename,\n '-zoom', 'to', 'fit', '-cmap', 'b'])\n\n ## Check if a stack of exposures of same type\n elif exptype in [\"Exposure Stack\", \"Dark Stack\", \"Bias Stack\"]:\n\n total = seqnum + imcount\n self.logger.info(\"Starting {0}s {1} stack.\".format(exptime, exptype))\n self.image_start.emit(imcount)\n\n try:\n for i in range(seqnum, total):\n self.logger.info(\"Starting image {0} of {1}.\".format(i+1-seqnum, imcount))\n filename = exposure.im_acq(mode, filepath, exptime, i, **kwargs)\n self.logger.info(\"Exposure {0} finished successfully.\".format(filename))\n self.image_taken.emit(i+1-seqnum)\n self.seqnum_inc.emit(i)\n except subprocess.CalledProcessError:\n self.logger.exception(\"Error in executable {0}_acq. Image not taken.\".format(mode))\n except OSError:\n self.logger.exception(\"Executable {0}_acq not found. Image not taken.\".format(mode))\n except IOError:\n self.logger.exception(\"File already exists. Image not taken.\")\n else:\n self.logger.info(\"Exposure stack finished successfully.\")\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename, '-zoom', 'to', 'fit', '-cmap', 'b'])\n \n ## Check if a series of exposures of increase exposure time\n elif exptype in [\"Exposure Series\", \"Dark Series\"]:\n\n ## Parameter checks\n if mintime > maxtime:\n self.logger.warning(\"Minimum time must be less than Maximum time. Series not started.\")\n return\n elif step <= 0:\n self.logger.warning(\"Time step must be greater than 0. Series not started.\")\n return\n\n ## Construct array of exposure times\n t = mintime\n time_array = []\n while t <= maxtime:\n time_array.append(t)\n t += step\n \n ## Perform series\n self.logger.info(\"Starting {0} series with mintime {1}, maxtime {2}, and step {3}.\".format(exptype, mintime, maxtime, step))\n self.image_start.emit(len(time_array))\n \n try:\n for i, time in enumerate(time_array):\n self.logger.info(\"Starting {0}s {1} image.\".format(time, mode))\n filename = exposure.im_acq(mode, filepath, time, seqnum, **kwargs)\n self.logger.info(\"Exposure {0} finished successfully.\".format(filename))\n self.image_taken.emit(i+1)\n except subprocess.CalledProcessError:\n self.logger.exception(\"Error in executable {0}_acq. Image not taken.\".format(mode))\n except OSError:\n self.logger.exception(\"Executable {0}_acq not found. Image not taken.\".format(mode))\n except IOError:\n self.logger.exception(\"File already exists. Image not taken.\")\n else:\n self.logger.info(\"Exposure series finished successfully.\")\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename, '-zoom', 'to', 'fit', '-cmap', 'b'])\n self.seqnum_inc.emit(seqnum)","def measure_flats(det, shutter, quantity, samStage, samPos):\n priorPosition = samStage.position\n yield from set_white_frame()\n yield from bps.mv(\n samStage, samPos,\n shutter, \"open\")\n yield from _acquire_n_frames(det, quantity)\n yield from bps.mv(samStage, priorPosition)","def plasma_dose(self, width, power):\n print('Start plasma dose.')\n self.seren.settings['set_forward_power'] = power\n self.seren.settings['RF_enable'] = True\n time.sleep(width)\n self.seren.settings['RF_enable'] = False\n self.seren.settings['set_forward_power'] = 0\n print('Plasma dose finished.')","def strut(self):\n self.fwd(left=50, right=50)\n for x in range(2):\n self.servo(1000)\n time.sleep(.1) \n self.servo(1500) # Look Straight\n time.sleep(1)\n self.servo(2000)\n time.sleep(.1)\n self.servo(1500)","def dark(s='dark'):\n s = s.strip()[:80] #truncate to 80 char to fit in FITS header\n print camera.SetShutter(2)\n camera.status.imgtype = 'DARK'\n camera.status.object = s\n camera.status.update()","def illustrate_sift(self):\n\n print 'passe illustrate sift in'\n\n work_dir = self.work_dir\n draw_keys_oriented(work_dir+'keys_im0.txt',\n work_dir+'input_0.orig.png',\n work_dir+'keys_im0.png')\n draw_keys_oriented(work_dir+'keys_im1.txt',\n work_dir+'input_1.orig.png',\n work_dir+'keys_im1.png')\n print 'passe illustrate sift in'\n\n for im in ['0','1']:\n for kypts in ['NES', 'DoGSoftThresh', 'ExtrInterp',\n 'ExtrInterpREJ', 'DoGThresh', 'OnEdgeResp',\n 'OnEdgeRespREJ']:\n draw_keys(work_dir+'extra_'+kypts+'_im'+im+'.txt',\n work_dir+'input_'+im+'.orig.png',\n work_dir+'extra_'+kypts+'_im'+im+'.png') \n\n draw_keys_oriented(work_dir+'extra_OriAssignedMULT_im'+im+'.txt',\n work_dir+'input_'+im+'.orig.png',\n work_dir+'extra_OriAssignedMULT_im'+im+'.png')\n\n return 1","def smooth_stitch(*, input_dir, output_dir):\n image_paths = glob(os.path.join(input_dir, \"*.tif\"))\n if not image_paths:\n raise RuntimeError(\"%s does not contain any .tif file\" % (input_dir))\n\n # Get the profile and affine of some image as template for output image\n first_image = image_paths[0]\n with rasterio.open(first_image) as src:\n profile = src.profile.copy()\n src_res = src.res\n chip_size = src.width\n assert src.width == src.height\n\n with tempfile.TemporaryDirectory() as tmpdir:\n tmp_image_paths = generate_spline_window_chips(\n image_paths=image_paths, output_dir=tmpdir\n )\n\n # Get bounds from all images and build R-Tree index\n idx, (dst_w, dst_s, dst_e, dst_n) = build_bounds_index(tmp_image_paths)\n\n # Get affine transform for complete bounds\n logger.info(\"Output bounds: %r\", (dst_w, dst_s, dst_e, dst_n))\n output_transform = Affine.translation(dst_w, dst_n)\n logger.info(\"Output transform, before scaling: %r\", output_transform)\n\n output_transform *= Affine.scale(src_res[0], -src_res[1])\n logger.info(\"Output transform, after scaling: %r\", output_transform)\n\n # Compute output array shape. We guarantee it will cover the output\n # bounds completely. We need this to build windows list later.\n output_width = int(math.ceil((dst_e - dst_w) / src_res[0]))\n output_height = int(math.ceil((dst_n - dst_s) / src_res[1]))\n\n # Set width and height for output chips, and other attributes\n profile.update(width=chip_size, height=chip_size, tiled=True)\n\n windows = list(\n sliding_windows(chip_size, width=output_width, height=output_height)\n )\n logger.info(\"Num. windows: %d\", len(windows))\n\n for win, (i, j) in tqdm(windows):\n # Get window affine transform and bounds\n win_transform = rasterio.windows.transform(win, output_transform)\n win_bounds = rasterio.windows.bounds(win, output_transform)\n\n # Get chips that intersect with window\n intersect_chip_paths = [\n tmp_image_paths[i] for i in idx.intersection(win_bounds)\n ]\n\n if intersect_chip_paths:\n # Merge them with median method\n img = merge_chips(intersect_chip_paths, win_bounds=win_bounds)\n\n # Write output chip\n profile.update(transform=win_transform)\n output_path = os.path.join(output_dir, f\"{i}_{j}.tif\")\n\n os.makedirs(output_dir, exist_ok=True)\n with rasterio.open(output_path, \"w\", **profile) as dst:\n for i in range(img.shape[0]):\n dst.write(img[i, :, :], i + 1)","def WarpOpen(wn, fn, ms = 15, Wres = 300, Hres = 300, M = 20, k_spr = 10, dt = 0.0125):\n MSG(\"WarpOpen\")\n cv2.namedWindow(wn)\n img = cv2.imread(fn,1)\n img = cv2.resize(img, (Wres,Hres))\n (h,w,cols) = img.shape\n L0 = list(img.flatten())\n warp.open(L0, M, w, h)\n warp.set_k_spr(k_spr)\n warp.set_dt(dt)\n return","def swarpfilter(d, dir, directory, images, keys, filter, lamp, camera, done, output, type):\n filt = images.files_filtered(FWINAME=filter, FLSPECTR=lamp, CAMNAME=camera, HISTORY=done)\n files = [d + x for x in filt.tolist()]\n print(files)\n if files:\n swarp(files, output=directory + '/' + output + '.fits', celestial_type=type)","def punched(self):\n if not self.dizzy:\n self.dizzy = 1\n self.original = self.image\n Chimp.count_punch += 1","def expose_test(self):\n with self.lock:\n self.dark = 1\n self.tstart = time.time()\n self.timestamp = time.strftime(\"%Y-%m-%dT%H:%M:%S\", time.localtime(self.tstart))\n imagesize = (self.expArea[3] - self.expArea[1],\n self.expArea[2] - self.expArea[0])\n self.data = np.ones(shape=imagesize, dtype=np.uint16)\n self.tend = time.time()","def capture(self, channel: LC):\n\n # check if gain information is available, if not, update first\n if \"d2d\" not in self.config:\n self.setup_d2d()\n self.update()\n\n # turn on the light\n self.light_control(channel, 1)\n\n # assemble the terminal command\n path_to_bright = os.getcwd() + \"/cam/tmp/bright.bmp\"\n path_to_dark = os.getcwd() + \"/cam/tmp/dark.bmp\"\n gain = self.config[\"d2d\"][channel][\"analog-gain\"] * self.config[\"d2d\"][channel][\"digital-gain\"]\n\n photo_cmd = \"raspistill -e bmp -w {} -h {} -ss {} -t 1000 -awb off -awbg {},{} -ag {} -dg {}\".format(self.settings.resolution[0], self.settings.resolution[1], self.settings.shutter_speed[channel], self.config[\"wb\"][channel][\"r\"], self.config[\"wb\"][channel][\"b\"], self.config[\"d2d\"][channel][\"analog-gain\"], self.config[\"d2d\"][channel][\"digital-gain\"])\n\n # run command and take bright and dark picture\n # start the bright image capture by spawning a clean process and executing the command, then waiting for the q\n p = mp.Process(target=photo_worker, args=(photo_cmd + \" -o {}\".format(path_to_bright),))\n try:\n p.start()\n p.join()\n except OSError:\n d_print(\"Could not start child process, out of memory\", 3)\n return (None, 0)\n # turn off the light\n self.light_control(channel, 0)\n # start the dark image capture by spawning a clean process and executing the command, then waiting for the q\n p = mp.Process(target=photo_worker, args=(photo_cmd + \" -o {}\".format(path_to_dark),))\n try:\n p.start()\n p.join()\n except OSError:\n d_print(\"Could not start child process, out of memory\", 3)\n return (None, 0)\n\n # load the images from file, perform dark frame subtraction and return the array\n bright = Image.open(path_to_bright)\n rgb = np.array(bright)\n if channel != LC.GROWTH:\n dark = Image.open(path_to_dark)\n rgb = cv2.subtract(rgb, np.array(dark))\n\n # if the time since last update is larger than a day, update the gains after the photo\n if time.time() - self.config[\"d2d\"][\"timestamp\"] > 3600*24:\n self.update()\n\n return (rgb, gain)","def _do_expose_loop(self, fitsfile, seconds):\n log.debug(f\"Starting expose loop with {self.max_exposures} exposures\")\n while (self.current_exposure is not None and \n self.current_exposure < self.max_exposures):\n self.current_exposure += 1\n self.Expose(fitsfile, seconds)\n while self.process and self.process.poll() is None:\n sleep(5)\n if not self.process or self.process.returncode != 0:\n break\n \n self.current_exposure = None\n self.max_exposures = None","def continue_with_exposure(self):\r\n # Allocate space to give to scan_until_abort, and name the two\r\n # rows appropriately.\r\n self.data_pair = self.cam.get_new_array(n_images=2)\r\n self.pump_probe_data = self.data_pair[0]\r\n self.probe_only_data = self.data_pair[1]\r\n # Keep track of which image will be updated next\r\n self.next_data_has_pump = True\r\n\r\n # Tell self.thread what to do when the camera has new images\r\n self.cam.new_images.connect(self.send_new_images)\r\n\r\n # Get the current array of wavelengths from cam\r\n self.wavelen_arr = self.cam.get_wavelen_array()\r\n\r\n # Queue a call to cam.scan_until_abort\r\n self.startAcq.emit(self.data_pair)\r\n\r\n # Tell listeners (plotting widgets) to start displaying data too\r\n self.startDisplay.emit()","def fire_smelter(self):\n # Get the smelter\n screenshot = utils.take_screenshot()\n forge = screenshot[152:168, 168:184]\n\n # Check if the cold forge exists\n result = cv2.matchTemplate(forge, self.cold_forge_template, cv2.TM_CCORR_NORMED)\n max_val = cv2.minMaxLoc(result)[1]\n\n # Found cold forge, light it and wait\n if max_val > 0.9:\n pyautogui.moveTo(192, 159, 0.15)\n pyautogui.doubleClick()\n sleep(1.5)","def spectate(self):\n pass","def __init__(self, slit_width_xaxis, slit_height_zaxis):\n super(SwScreen, self).__init__()\n self.sw = self.create_instance()\n\n self.set_output_files(fwrite=0, f_angle=0) #write all, TODO: remove\n\n n_screen = 1\n i_screen = np.array([1, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n i_abs = np.zeros(10)\n i_slit = np.zeros(10)\n i_stop = np.zeros(10)\n k_slit = np.zeros(10)\n thick = np.zeros(10)\n file_abs = np.array(['', '', '', '', '', '', '', '', '', ''])\n rx_slit = np.zeros(10)\n rz_slit = np.zeros(10)\n sl_dis = np.zeros(10)\n file_src_ext = np.array(['', '', '', '', '', '', '', '', '', ''])\n cx_slit = np.zeros(10)\n cz_slit = np.zeros(10)\n\n i_abs[0] = 0 # NO ABSORPTION\n i_slit[0] = 0 # APERTURING\n i_stop[0] = 0 # SLIT\n k_slit[0] = 0 # RECTANGULAR\n\n rx_slit[0] = slit_width_xaxis\n rz_slit[0] = slit_height_zaxis\n cx_slit[0] = 0.0\n cz_slit[0] = 0.0\n\n self.sw._oe.set_screens(n_screen,\n i_screen,\n i_abs,\n sl_dis,\n i_slit,\n i_stop,\n k_slit,\n thick,\n file_abs,\n rx_slit,\n rz_slit,\n cx_slit,\n cz_slit,\n file_src_ext)","def test_healpix_to_point_source_cuts(healpix_disk_new):\n skyobj = healpix_disk_new\n skyobj.healpix_to_point()\n skyobj.select(max_brightness=0.9 * skyobj.stokes[0].max())","def skyPixelsHPX(self,i, d,feedindex):\n\n # We store all the pointing information\n x = d['level1/spectrometer/pixel_pointing/pixel_ra'][feedindex,:][:,self.select_mask]\n x = x[:,0:self.datasizes[i]].flatten()\n y = d['level1/spectrometer/pixel_pointing/pixel_dec'][feedindex,:][:,self.select_mask]\n y = y[:,0:self.datasizes[i]].flatten()\n \n # convert to Galactic\n rot = hp.rotator.Rotator(coord=['C','G'])\n gb, gl = rot((90-y)*np.pi/180., x*np.pi/180.)\n\n pixels = hp.ang2pix(self.nside, gb, gl)\n return pixels","def setup():\n wcs = galsim.TanWCS(\n galsim.AffineTransform(0.26, 0.05, -0.08, -0.24, galsim.PositionD(1024,1024)),\n #galsim.AffineTransform(0.26, 0., 0., 0.26, galsim.PositionD(1024,1024)),\n galsim.CelestialCoord(5 * galsim.arcmin, -25 * galsim.degrees)\n )\n\n # Make the image (copied from test_single_image in test_simple.py)\n image = galsim.Image(2048, 2048, wcs=wcs)\n\n # Where to put the stars.\n x_list = [ 123.12, 345.98, 567.25, 1094.94, 924.15, 1532.74, 1743.11, 888.39, 1033.29, 1409.31 ]\n y_list = [ 345.43, 567.45, 1094.32, 924.29, 1532.92, 1743.83, 888.83, 1033.19, 1409.20, 123.11 ]\n\n # Draw a Gaussian PSF at each location on the image.\n sigma = 1.3\n g1 = 0.23\n g2 = -0.17\n du = 0.09 # in arcsec\n dv = -0.07\n flux = 123.45\n psf = galsim.Gaussian(sigma=sigma).shear(g1=g1, g2=g2).shift(du,dv) * flux\n for x, y in zip(x_list, y_list):\n bounds = galsim.BoundsI(int(x-31), int(x+32), int(y-31), int(y+32))\n offset = galsim.PositionD(x-int(x)-0.5, y-int(y)-0.5)\n psf.drawImage(image=image[bounds], method='no_pixel', offset=offset)\n image.addNoise(galsim.GaussianNoise(rng=galsim.BaseDeviate(1234), sigma=1e-6))\n\n # Write out the image to a file\n image_file = os.path.join('output','test_stats_image.fits')\n image.write(image_file)\n\n # Write out the catalog to a file\n dtype = [ ('x','f8'), ('y','f8') ]\n data = np.empty(len(x_list), dtype=dtype)\n data['x'] = x_list\n data['y'] = y_list\n cat_file = os.path.join('output','test_stats_cat.fits')\n fitsio.write(cat_file, data, clobber=True)","def sharpen(img, ker = (9,9), sigX=10.0):\n gaus = cv2.GaussianBlur(img, ker, sigX)\n unsharp = cv2.addWeighted(img, 1.5, gaus, -0.5, 0, img)\n return unsharp","def exposure(frameType, expTime):\n\n blobEvent.clear() \n\n # set the specified frame type\n if frameType.lower() == 'light':\n ccd_frame[0].s = PyIndi.ISS_ON\n ccd_frame[1].s = PyIndi.ISS_OFF\n ccd_frame[2].s = PyIndi.ISS_OFF\n ccd_frame[3].s = PyIndi.ISS_OFF \n indiclient.sendNewSwitch(ccd_frame)\n elif frameType.lower() == 'bias':\n ccd_frame[0].s = PyIndi.ISS_OFF\n ccd_frame[1].s = PyIndi.ISS_ON\n ccd_frame[2].s = PyIndi.ISS_OFF\n ccd_frame[3].s = PyIndi.ISS_OFF \n indiclient.sendNewSwitch(ccd_frame)\n elif frameType.lower() == 'dark':\n ccd_frame[0].s = PyIndi.ISS_OFF\n ccd_frame[1].s = PyIndi.ISS_OFF\n ccd_frame[2].s = PyIndi.ISS_ON\n ccd_frame[3].s = PyIndi.ISS_OFF \n indiclient.sendNewSwitch(ccd_frame)\n elif frameType.lower() == 'flat':\n ccd_frame[0].s = PyIndi.ISS_OFF\n ccd_frame[1].s = PyIndi.ISS_OFF\n ccd_frame[2].s = PyIndi.ISS_OFF\n ccd_frame[3].s = PyIndi.ISS_ON \n indiclient.sendNewSwitch(ccd_frame)\n\n # set the value for the next exposure\n ccd_exposure[0].value=expTime\n\n indiclient.sendNewNumber(ccd_exposure)\n\n # wait for the exposure\n blobEvent.wait()\n\n for blob in ccd_ccd1:\n # pyindi-client adds a getblobdata() method to IBLOB item\n # for accessing the contents of the blob, which is a bytearray in Python\n image_data=blob.getblobdata()\n\n # write the byte array out to a FITS file\n global imgNum\n global imgName\n imgNum += 1\n fileName = fileDir+'raw-'+str(imgNum).zfill(8)+'.fits'\n f = open(fileName, 'wb')\n f.write(image_data)\n f.close()\n imgName = fileName\n \n return fileName","def do_pixels(self):\n self.do_yurt_pixels()\n self.do_petal_strip_pixels()\n self.do_vase_pixels()","def main():\n original = SimpleImage('images/mt-rainier.jpg')\n original.show()\n reflected = make_reflected('images/mt-rainier.jpg')\n reflected.show()","def align(): # open EH and fast shutter\n\t#marAuxiliary.closeMarShield()\n\td2in()\n\td3in()\n\tsh('o')","def cehs():\n\tcloseEHShutter()","def endexposureloop(self):\n self.max_exposures = self.current_exposure","def camera(self):\n self.spectrum = self.spectrum","def do_stuff(self):\n self.create_tourism_raster()","def flatcombine(dir='Flats/*/dark_subtracted/'):\n\n for d in glob(dir):\n\n directory = \"/\".join(d.split('/')[0:2]) + '/swarped'\n if not os.path.exists(directory):\n os.makedirs(directory)\n\n keys = ['OBJECT', 'CAMNAME', 'FWINAME', 'ITIME', 'OBSDATE', 'FLSPECTR', 'HISTORY']\n images = ImageFileCollection(d, keywords=keys, glob_include='d*.fits')\n\n swarpfilter(d, dir, directory, images, keys, filter='H', lamp='on', camera='narrow', \n done='Dark Subtracted', output='cKNarrowLampOnH', type='PIXEL')\n swarpfilter(d, dir, directory, images, keys, filter='H', lamp='off', camera='narrow', \n done='Dark Subtracted', output='cKNarrowLampOffH', type='PIXEL')\n swarpfilter(d, dir, directory, images, keys, filter='H', lamp='on', camera='wide', done='Dark Subtracted',\n output='cKWideLampOnH', type='PIXEL')\n swarpfilter(d, dir, directory, images, keys, filter='H', lamp='off', camera='wide', done='Dark Subtracted',\n output='cKWideLampOffH', type='PIXEL')\n swarpfilter(d, dir, directory, images, keys, filter='Ks', lamp='on', camera='narrow', done='Dark Subtracted',\n output='cKNarrowLampOnKs', type='PIXEL')\n swarpfilter(d, dir, directory, images, keys, filter='Ks', lamp='off', camera='narrow', done='Dark Subtracted',\n output='cKNarrowLampOffKs', type='PIXEL')\n swarpfilter(d, dir, directory, images, keys, filter='Ks', lamp='on', camera='wide', done='Dark Subtracted',\n output='cKWideLampOnKs', type='PIXEL')\n swarpfilter(d, dir, directory, images, keys, filter='Ks', lamp='off', camera='wide', done='Dark Subtracted',\n output='cKWideLampOffKs', type='PIXEL')\n swarpfilter(d, dir, directory, images, keys, filter='J', lamp='on', camera='narrow', done='Dark Subtracted',\n output='cNarrowLampOnJ', type='PIXEL')\n swarpfilter(d, dir, directory, images, keys, filter='J', lamp='off', camera='narrow', done='Dark Subtracted',\n output='cKNarrowLampOffJ', type='PIXEL')\n swarpfilter(d, dir, directory, images, keys, filter='J', lamp='on', camera='wide', done='Dark Subtracted',\n output='cKWideLampOnJ', type='PIXEL')\n swarpfilter(d, dir, directory, images, keys, filter='J', lamp='off', camera='wide', done='Dark Subtracted',\n output='cKWideLampOffJ', type='PIXEL')","def spilloverEff(freq,fD, FFBW, dB_at_bw, feed_type):\n theta0 = fD2angle(fD,units='degrees')\n tt = 0.0\n dtt = 0.1\n theta = np.arange(0.0,180.0+dtt,dtt)\n g = feedPattern(freq, theta, FFBW, dB_at_bw, feed_type)\n theta = theta*math.pi/180.0\n\n # integrate over main beam\n gmb = np.where(theta < (theta0/2.0)*math.pi/180.0)\n kern = g[gmb]*np.sin(theta[gmb]) \n num = integ.trapz(kern,dx=dtt*math.pi/180.0)\n # integrate over full beam\n kern = g*np.sin(theta)\n den = integ.trapz(kern,dx=dtt*math.pi/180.0)\n \n n_spill = num/den\n return n_spill","def testSmallSrc(self):\n fromWcs = afwGeom.makeSkyWcs(\n crpix=lsst.geom.Point2D(0, 0),\n crval=lsst.geom.SpherePoint(359, 0, lsst.geom.degrees),\n cdMatrix=afwGeom.makeCdMatrix(scale=1.0e-8*lsst.geom.degrees),\n )\n fromExp = afwImage.ExposureF(afwImage.MaskedImageF(1, 1), fromWcs)\n\n toWcs = afwGeom.makeSkyWcs(\n crpix=lsst.geom.Point2D(0, 0),\n crval=lsst.geom.SpherePoint(358, 0, lsst.geom.degrees),\n cdMatrix=afwGeom.makeCdMatrix(scale=1.1e-8*lsst.geom.degrees),\n )\n toExp = afwImage.ExposureF(afwImage.MaskedImageF(10, 10), toWcs)\n\n warpControl = afwMath.WarpingControl(\"lanczos3\")\n # if a bug described in ticket #2441 is present, this will raise an\n # exception:\n numGoodPix = afwMath.warpExposure(toExp, fromExp, warpControl)\n self.assertEqual(numGoodPix, 0)\n self.assertTrue(np.all(np.isnan(toExp.image.array)))\n self.assertTrue(np.all(np.isinf(toExp.variance.array)))\n noDataBitMask = afwImage.Mask.getPlaneBitMask(\"NO_DATA\")\n self.assertTrue(np.all(toExp.mask.array == noDataBitMask))","def swingCapture(self, pulse, divider=2, count=5):\n pulse=int(pulse) #make sure is integer\n cap = cv2.VideoCapture(CAM0, cv2.CAP_DSHOW) # use camera to monitor the motor-mirror assemnbly \n frames=[] \n\n low, high=self._lo_hi_preprocess(CLK_WISE)\n low_antiClk, high_antiClk=self._lo_hi_preprocess(ANTI_CLK_W) # ret in C byte format already\n div=divider #divide pulses into groups\n for _ in range(count): #loop count\n sub_pulse=pulse//div\n for __ in range(div): #no of times to cap image\n for ___ in range(sub_pulse): # 1st clockwise direction\n self.objdll.USBIO_GPIOWrite(self.id, low, WRITE_EN) #;sleep(self.delay)#disable for highest motor speed\n self.objdll.USBIO_GPIOWrite(self.id, high, WRITE_EN) #; sleep(self.delay)#disable for highest motor speed\n ret, frame = cap.read() # Capture frame-by-frame \n frames.append(frame) # store per group\n\n for __ in range(div): \n for ___ in range(sub_pulse): # 1st anticlockwise direction\n self.objdll.USBIO_GPIOWrite(self.id, low_antiClk, WRITE_EN) #;sleep(self.delay)#disable for highest motor speed\n self.objdll.USBIO_GPIOWrite(self.id, high_antiClk, WRITE_EN) #; sleep(self.delay)#disable for highest motor speed\n ret, frame = cap.read() # Capture frame-by-frame \n frames.append(frame) # store per group\n\n\n \n cap.release()\n cv2.destroyAllWindows()\n return np.asarray(frames)","def phot_aperture(input_file):\n #set the original directory\n original_path = os.getcwd()\n save_path = input_file['save_path']\n planet = input_file['exoplanet']\n #radii = np.arange(input_file['apertures'][0],input_file['apertures'][1],0.1)\n radii = np.array(input_file['apertures'])\n #change to save data reduction directory\n os.chdir(save_path)\n if not os.path.exists('phot_results'):\n os.makedirs('phot_results')\n tempo = time.time()\n print 'Starting aperture photometry'\n print 'Saving results on: '+save_path+'/phot_results/'\n \n #check the number of objects to make the photometry\n N_obj = len(input_file['pxpositions'])/2.\n print 'Number of objects = ',N_obj\n positions = [] #create the positions variable (X,Y) in pixels unit on the CCD\n for i in range(len(input_file['pxpositions'])):\n if i % 2 == 0: #if the number is a even (or not a odd), the turple is created\n positions.append((input_file['pxpositions'][i],input_file['pxpositions'][i+1]))\n print 'Radius from ',radii[0],' to ',radii[-1],'\\n'\n \n skysection = input_file['skysection']\n skysection[0] = int(skysection[0])\n skysection[1] = int(skysection[1])\n \n images = sorted(glob.glob('AB'+planet+'*.fits'))\n for radius in radii:\n flux_data = []\n for i in range(len(images)):\n im = fits.getdata(images[i],header=False)\n im = array(im,dtype='Float64')\n \n # ERROR\n #Traceback (most recent call last):\n # File \"ExoTRed.py\", line 105, in <module>\n # exotred.phot_aperture(input_file)\n # File \"./sources/ExoTRed_core.py\", line 637, in phot_aperture \n # File \"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/background/background_2d.py\", line 329, in __init__\n # self._calc_bkg_bkgrms()\n # File \"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/background/background_2d.py\", line 686, in _calc_bkg_bkgrms\n # bkg = self._interpolate_meshes(self._bkg1d)\n # File \"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/background/background_2d.py\", line 575, in _interpolate_meshes\n # f = ShepardIDWInterpolator(yx, data)\n # File \"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/utils/interpolation.py\", line 138, in __init__\n # raise ValueError('The number of values must match the number '\n # ValueError: The number of values must match the number of coordinates.\n\n # bkg = background.background_2d.Background2D(im,tuple(skysection))\n # bkg_data = bkg.background\n # bkg_rms = bkg.background_rms\n\n # phot_table = aperture_photometry(im - bkg_data, CircularAperture(positions, radius),\n # error=bkg_rms, method ='center')#,effective_gain=float(input_file['gain']))\n ####### SUBSTITUTE ROUTINE\n window = 100\n sky_size = im.shape\n sky_mean = float(np.median(im[int(skysection[1]-window):int(skysection[1]+window),int(skysection[0]-window):int(skysection[0]+window)]))\n bkg = np.random.poisson(sky_mean,sky_size)\n apertures = CircularAperture(positions, radius)\n phot_table = aperture_photometry(im, apertures, error=bkg)\n #######\n phot_table_flux = np.array([]) #saving results of aperture photometry\n for j in range(len(phot_table['aperture_sum'])):\n phot_table_flux = np.concatenate((phot_table_flux,np.array([phot_table['aperture_sum'][j]])),axis=0)\n phot_table_flux = np.concatenate((phot_table_flux,np.array([phot_table['aperture_sum_err'][j]])),axis=0)\n flux = np.concatenate((phot_table_flux,np.array([images[i]])),axis=0)\n # flux = [phot_table['aperture_sum'][0], phot_table['aperture_sum'][1],phot_table['aperture_sum_err'][0],\n # phot_table['aperture_sum_err'][1],images[i]]\n flux_data.append(flux)\n flux_data = DataFrame(flux_data)#,columns=['hoststar','refstar','hoststar_err','refstar_err','image'])\n flux_data.to_csv('./phot_results/'+planet+'_flux_radius_'+str(radius)+'.csv',index=False)\n use.update_progress((float(np.where(radii == radius)[0])+1.)/len(radii))\n print 'Time total = ',abs(time.time()-tempo)/60.,' minutes'\n os.chdir(original_path)","def use_effect(self):\n if self.preview_name in FILTERS:\n photo = Image.open(self.path.url[1:])\n preview = photo.filter(FILTERS.get(self.preview_name))\n preview.save(self.path.url[1:])","def main():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--interval\", \"-t\", type=int,\n help=\"length of time in seconds between images\",\n default=60)\n parser.add_argument(\"--images\", \"-n\", type=int, help=\"number of images\", default=1)\n parser.add_argument(\"--output\", \"-o\",\n help=\"path to output directory\", default=\"./\")\n parser.add_argument(\"--rotation\", \"-r\",\n help=\"degrees to rotate pi image\", default=0)\n parser.add_argument(\"--iso\", \"-i\", type=int, help=\"camera iso 0 is auto mode\", default=0)\n parser.add_argument(\"--shutter\", \"-s\", type=int,\n help=\"camera shutter speed in microseconds 0 is auto mode\", default=0)\n parser.add_argument(\"--exposure\", \"-e\", help=\"exposure compensation set between -25 and +25\", default=0)\n args = parser.parse_args()\n interval = int(args.interval)\n images = int(args.images)\n output = args.output\n rotation = int(args.rotation)\n iso = int(args.iso)\n shutter_speed = int(args.shutter)\n exposure_compensation = int(args.exposure)\n\n\n timelapse(int=interval,\n n=images,\n dir=output,\n rotation=rotation,\n iso=iso,\n shutter=shutter_speed,\n exposure=exposure_compensation)","def run_shoe_rack_manipulation(self, debug=False, push_in_distance=0.00):\n\n print(\"\\n\\n--- Running Shoe Manipulation-------\\n\\n\")\n\n # self.taskRunner.callOnMain(self._poser_visualizer.visualize_result)\n\n if not self.check_category_goal_estimation_succeeded():\n return False\n\n # check that we really are doing mug\n category_manipulation_type = self.state.cache['category_manipulation_goal']['type']\n assert category_manipulation_type == CategoryManipulationType.SHOE_ON_RACK\n\n\n speed = self.graspingParams['speed']['fast']\n self.moveHome(speed=speed)\n\n result = self.state.cache['category_manipulation_goal']['result']\n T_W_fingertip = ros_numpy.numpify(result.T_world_gripper_fingertip)\n T_W_fingertip_vtk = transformUtils.getTransformFromNumpy(T_W_fingertip)\n\n grasp_data = GraspData.from_gripper_fingertip_frame(T_W_fingertip)\n grasp_data.gripper.params[\"hand_inner_diameter\"] = result.gripper_width\n grasp_data.gripper.params[\"hand_inner_diameter\"] = 0.07\n self.state.grasp_data = grasp_data\n\n # rotate the grasp to align with nominal\n params = self.getParamsForCurrentLocation()\n grasp_z_axis_nominal = np.array(params['grasp']['grasp_nominal_direction'])\n grasp_data.rotate_grasp_frame_to_nominal(grasp_z_axis_nominal)\n\n\n\n\n def vis_function():\n vis.updateFrame(T_W_fingertip_vtk, \"gripper fingertip frame\", scale=0.15, parent=self._vis_container)\n\n vis.updateFrame(grasp_data.grasp_frame, \"grasp frame\", scale=0.15, parent=self._vis_container)\n\n self.visualize_grasp(grasp_data)\n\n self.taskRunner.callOnMain(vis_function)\n\n # execute the grasp\n force_threshold_magnitude = 30\n object_in_gripper = self.execute_grasp(grasp_data, close_gripper=True, use_cartesian_plan=True, force_threshold_magnitude=force_threshold_magnitude, push_in_distance=0.04, ee_speed_m_s=0.1)\n\n\n if not object_in_gripper:\n print(\"grasp failed, returning\")\n return False\n\n print \"object_in_gripper:\", object_in_gripper\n\n T_goal_obs = self.state.cache['category_manipulation_goal'][\"T_goal_obs\"]\n T_W_G = self.state.cache['gripper_frame_at_grasp']\n\n\n\n pre_grasp_pose = self.state.cache['pre_grasp_ik_response'].joint_state.position\n pickup_speed = self.graspingParams['speed']['pickup']\n\n if not object_in_gripper:\n # open the gripper and back away\n self.gripperDriver.send_open_gripper_set_distance_from_current()\n self.robotService.moveToJointPosition(pre_grasp_pose,\n maxJointDegreesPerSecond=\n pickup_speed)\n return False\n\n # pickup the object\n self.robotService.moveToJointPosition(pre_grasp_pose,\n maxJointDegreesPerSecond=\n pickup_speed)\n\n # move home\n self.moveHome()\n\n # move to approach pose\n speed = self.graspingParams['speed']['fast']\n q_approach = np.array(self._stored_poses_director[\"left_table\"][\"shoe_approach\"])\n self.robotService.moveToJointPosition(q_approach, maxJointDegreesPerSecond=speed)\n\n\n # compute some poses\n T_goal_obs = ros_numpy.numpify(result.T_goal_obs) # 4 x 4 numpy matrix\n T_goal_obs_vtk = transformUtils.getTransformFromNumpy(T_goal_obs)\n object_manip = ObjectManipulation(T_goal_object=T_goal_obs_vtk, T_W_G=T_W_G)\n object_manip.compute_transforms()\n T_W_Gn_vtk = object_manip.T_W_Gn # gripper to world for place pose\n\n T_pre_goal_obs = ros_numpy.numpify(result.T_pre_goal_obs)\n T_pre_goal_obs_vtk = transformUtils.getTransformFromNumpy(T_pre_goal_obs)\n object_manip_approach = ObjectManipulation(T_goal_object=T_pre_goal_obs_vtk, T_W_G=T_W_G)\n object_manip_approach.compute_transforms()\n T_W_Gn_approach_vtk = object_manip_approach.T_W_Gn\n\n # move this down by push_in_distance\n\n pos, quat = transformUtils.poseFromTransform(T_W_Gn_approach_vtk)\n T_W_Gn_approach_vtk = transformUtils.transformFromPose(pos, quat)\n\n\n # now convert these to ee poses for running IK\n pos, quat = transformUtils.poseFromTransform(T_W_Gn_vtk)\n pos[2] -= push_in_distance\n T_W_Gn_vtk = transformUtils.transformFromPose(pos, quat)\n T_W_ee_vtk = self.getIiwaLinkEEFrameFromGraspFrame(T_W_Gn_vtk)\n T_W_ee = transformUtils.getNumpyFromTransform(T_W_ee_vtk)\n\n T_W_ee_approach_vtk = self.getIiwaLinkEEFrameFromGraspFrame(T_W_Gn_approach_vtk)\n T_W_ee_approach = transformUtils.getNumpyFromTransform(T_W_ee_approach_vtk)\n\n\n # place the object\n force_threshold_magnitude = 50 # shoes are heavy\n q_nom = np.array(self._stored_poses_director[\"Grasping\"][\"above_table_pre_grasp\"])\n q_nom = np.array(self._stored_poses_director[\"left_table\"][\"above_table_pre_grasp\"])\n code =self.execute_place_new(T_W_ee, T_W_ee_approach, q_nom=q_nom, use_cartesian_plan=True, force_threshold_magnitude=force_threshold_magnitude)\n\n print(\"\\n\\n--- Finished Shoe Manipulation-------\\n\\n\")\n\n self._shoe_manipulation_counter += 1\n\n return code","def stitchSpectra(lamb_list,count_list, method=\"scale\", edgeremove=(0, 0), shiftToPositive=False, dlambda=None):\r\n rawData=np.array([np.array(lamb_list),np.array(count_list)])\r\n rawData=rawData.swapaxes(0,1)\r\n coefficients = []\r\n print(\"Removing edges for stitching:\", *edgeremove)\r\n omitRight = rawData[0].shape[1] - math.floor(rawData[0].shape[1] * edgeremove[1])\r\n print(\"Stitching index range is \", 0, omitRight)\r\n processed = np.array(rawData[0][:, 0:omitRight]) \r\n if dlambda is None:\r\n dlambda = math.fabs(processed[0, 1] - processed[0, 0]) ## lambda steps of first spectrum are kept\r\n for i, spec in enumerate(rawData[1:]):\r\n omitLeft = math.floor(spec.shape[1] * edgeremove[0])\r\n omitRight = spec.shape[1] - math.floor(spec.shape[1] * edgeremove[1])\r\n print(\"Stitching index range is \", omitLeft, omitRight)\r\n if i == len(rawData)-2:\r\n spec = np.array(spec[:, omitLeft:]) ## do not shorten last array at end\r\n else:\r\n spec = np.array(spec[:, omitLeft:omitRight]) # shorten middle arrays at both sides\r\n print(\"Stitching spectrum in range\", np.min(spec[0,]), np.max(spec[0,]))\r\n # calculate overlap\r\n overlap = (np.min(spec[0,]), np.max(processed[0,])) \r\n #lambdas = np.arange(*overlap, dlambda)\r\n #leftfun = interp1d(processed[0,], processed[1,])\r\n #rightfun = interp1d(spec[0,], spec[1,])\r\n left = np.mean(processed[1, processed[0,] > overlap[0]]) ##mean of counts of overlap\r\n right = np.mean(spec[1, spec[0,] < overlap[1]])\r\n if method == \"shift\":\r\n # calculate offset in overlap region\r\n offset = left - right\r\n print(\"Stitching offset %s in overlap\", offset, *overlap)\r\n # add shifted spectrum\r\n spec[1,] = spec[1,] + offset\r\n coefficients.append(offset)\r\n elif method == \"scale\":\r\n # calculate factor in overlap region\r\n factor = left/right\r\n print(\"Stitching factor\"+str(factor)+\" in overlap \", *overlap)\r\n spec[1,] = spec[1,] * factor\r\n coefficients.append(factor)\r\n processed = np.concatenate([processed, spec], axis=1)\r\n # interpolate data on grid\r\n interpolated = interp1d(processed[0,], processed[1,])\r\n lambdas = np.arange(processed[0, 0], processed[0, -1], dlambda)\r\n specdata = interpolated(lambdas)\r\n # shift above 0\r\n if shiftToPositive:\r\n minimum = np.min(specdata)\r\n if minimum < 0:\r\n specdata += math.fabs(minimum)\r\n \r\n return (lambdas,specdata,coefficients)","def __call__(self):\n return self.shoot()","def run_std_sift(self): \n for i in range(2):\n image = 'input_'+str(i)+'.png'\n label = 'im'+str(i)\n f = open(self.work_dir+'keys_'+label+'.txt','w')\n sift = self.run_proc(['sift_cli', image], stdout=f)\n self.wait_proc(sift, timeout=self.timeout)\n return 1","def burning_ship(pixels, width, height, max_iterations, re_start, re_end, im_start, im_end, color_hue,\n color_saturation, color_intensity):\n\n for x in prange(0, width):\n for y in prange(0, height):\n c = complex((re_start + (x / width) * (re_end - re_start)),\n (im_start + (y / height) * (im_end - im_start)))\n z = 0.0j\n\n iterations = 0\n while (abs(z) < 4.0) and iterations < max_iterations:\n abs_z = complex(abs(z.real), abs(z.imag))\n z = abs_z * abs_z + c\n iterations += 1\n\n # Color smoothing\n smooth_iterations = iterations - math.log(math.log(z.real * z.real + z.imag * z.imag)) + 4.0\n\n if iterations >= max_iterations:\n pixels[x, y, 0] = 0\n pixels[x, y, 1] = 0\n pixels[x, y, 2] = 0\n else:\n pixels[x, y, 0] = 255 * (color_hue / 360)\n pixels[x, y, 1] = 255 * color_saturation\n pixels[x, y, 2] = 255 * min(color_intensity * smooth_iterations / max_iterations, 1)","def main():\n # color = rb.Color.BLUE.value\n # move_to_color(color)\n infared_sensor()\n\n # WHITE/RED does not work same with the BLUE/GREEN going down","def overlay(self):\n # retrieve header for photometry keywords\n # from current frame only\n hdr_str = self.run('fits header', via='get')\n\n # read it in to a fits header\n phdr = fits.Header()\n hdr = phdr.fromstring(hdr_str, sep='\\n')\n\n try:\n srcposx = hdr['SRCPOSX'] + 1\n srcposy = hdr['SRCPOSY'] + 1\n s1 = 'point({:f} {:f}) # ' \\\n 'point=x ' \\\n 'color=blue tag={{srcpos}} '\\\n 'text=SRCPOS'.format(srcposx, srcposy)\n self.run('regions', s1)\n except (KeyError, ValueError):\n pass\n try:\n stcentx = hdr['STCENTX'] + 1\n stcenty = hdr['STCENTY'] + 1\n photaper = hdr['PHOTAPER']\n photskap = [float(x) for x in hdr['PHOTSKAP'].split(',')]\n s1 = 'point({:f} {:f}) # ' \\\n 'point=x ' \\\n 'color=cyan tag={{srcpos}}'.format(stcentx, stcenty)\n self.run('regions', s1)\n s2 = 'circle({:f} {:f} {:f}) # ' \\\n 'color=cyan tag={{srcpos}}'.format(\n stcentx, stcenty, photaper)\n self.run('regions', s2)\n s3 = 'annulus({:f} {:f} {:f} {:f}) # ' \\\n 'color=cyan tag={{srcpos}} text=STCENT'.format(\n stcentx, stcenty, photskap[0], photskap[1])\n self.run('regions', s3)\n except (KeyError, ValueError):\n pass\n try:\n stcentx = hdr['STCENTX'] + 1\n stcenty = hdr['STCENTY'] + 1\n flux = hdr['STAPFLX']\n sky = hdr['STAPSKY']\n s1 = 'text({:f} {:f}) # color=cyan ' \\\n 'text=\"Flux={:.2f}, Sky={:.2f}\"'.format(\n stcentx, stcenty - 40, flux, sky)\n self.run('regions', s1)\n except (KeyError, ValueError):\n pass\n\n # try overlaying apertures as well\n try:\n self.overlay_aperture(hdr)\n except ValueError: # pragma: no cover\n # may be encountered with extensions with\n # unexpected WCSs\n pass","def run(self,workspace):\n image_name = self.image_name.value\n cpimage = workspace.image_set.get_image(image_name)\n image = cpimage.pixel_data\n mask = cpimage.mask\n workspace.display_data.statistics = []\n level = int(self.atrous_level.value)\n\n wavelet = self.a_trous(1.0*image, level+1)\n wlevprod = wavelet[:,:,level-1] * 3.0\n\n spotthresh = wlevprod.mean() + float(self.noise_removal_factor.value) * wlevprod.std()\n tidx = wlevprod < spotthresh\n wlevprod[tidx] = 0\n\n wlevprod = self.circular_average_filter(wlevprod, int(self.smoothing_filter_size.value))\n wlevprod = self.smooth_image(wlevprod, mask)\n\n max_wlevprod = scipy.ndimage.filters.maximum_filter(wlevprod,3)\n maxloc = (wlevprod == max_wlevprod)\n twlevprod = max_wlevprod > float(self.final_spot_threshold.value)\n maxloc[twlevprod == 0] = 0\n \n labeled_image,object_count = scipy.ndimage.label(maxloc,\n np.ones((3,3),bool))\n\n unedited_labels = labeled_image.copy()\n # Filter out objects touching the border or mask\n border_excluded_labeled_image = labeled_image.copy()\n labeled_image = self.filter_on_border(image, labeled_image)\n border_excluded_labeled_image[labeled_image > 0] = 0\n \n # Relabel the image\n labeled_image,object_count = relabel(labeled_image)\n new_labeled_image, new_object_count = self.limit_object_count(\n labeled_image, object_count)\n if new_object_count < object_count:\n # Add the labels that were filtered out into the border\n # image.\n border_excluded_mask = ((border_excluded_labeled_image > 0) |\n ((labeled_image > 0) & \n (new_labeled_image == 0)))\n border_excluded_labeled_image = scipy.ndimage.label(border_excluded_mask,\n np.ones((3,3),bool))[0]\n object_count = new_object_count\n labeled_image = new_labeled_image\n \n # Make an outline image\n outline_image = cellprofiler.cpmath.outline.outline(labeled_image)\n outline_border_excluded_image = cellprofiler.cpmath.outline.outline(border_excluded_labeled_image)\n \n if self.show_window:\n statistics = workspace.display_data.statistics\n statistics.append([\"# of accepted objects\",\n \"%d\"%(object_count)])\n\n workspace.display_data.image = image\n workspace.display_data.labeled_image = labeled_image\n workspace.display_data.border_excluded_labels = border_excluded_labeled_image\n\n # Add image measurements\n objname = self.object_name.value\n measurements = workspace.measurements\n cpmi.add_object_count_measurements(measurements,\n objname, object_count)\n # Add label matrices to the object set\n objects = cellprofiler.objects.Objects()\n objects.segmented = labeled_image\n objects.unedited_segmented = unedited_labels\n objects.parent_image = image\n \n workspace.object_set.add_objects(objects,self.object_name.value)\n cpmi.add_object_location_measurements(workspace.measurements, \n self.object_name.value,\n labeled_image)\n if self.should_save_outlines.value:\n out_img = cpi.Image(outline_image.astype(bool),\n parent_image = image)\n workspace.image_set.add(self.save_outlines.value, out_img)","def sim_image_ramp(det, im_slope, verbose=False, **kwargs):\n if verbose:\n _log.info('Generating image acquisition ramp...')\n\n return sim_dark_ramp(det, im_slope, ramp_avg_ch=None, verbose=False, **kwargs)","def make_spectra(directory,frame):\n oober = st.short_oober(directory, frame=frame)\n #st.MakeVelocitySpectra(oober,frame)\n #st.MakeAccelSpectra(oober,frame)\n #st.MakeMagneticSpectra(oober,frame)\n st.MakeDensitySpectra(oober,frame)","def punched(self):\n if not self.dizzy:\n self.dizzy= 1\n self.original= self.image","def write_images(band,skypos,tranges,skyrange,write_cnt=False,write_int=False,write_rr=False,framesz=0,width=False,height=False,verbose=0,tscale=1000.,memlight=False,coadd=False,response=False,calpath='../cal/',clobber=False,retries=20):\n\t# No files were requested, so don't bother doing anything.\n\tif not (write_cnt or write_int or write_rr):\n\t\treturn\n\tcount,rr,intensity=create_images(band,skypos,tranges,skyrange,framesz=framesz,width=width,height=height,verbose=verbose,tscale=tscale,memlight=memlight,coadd=coadd,response=response,calpath=calpath,retries=retries)\n\n\t# Add a conditional so that this is only created for multi-frame images\n\ttbl = movie_tbl(band,tranges,framesz=framesz,verbose=verbose,retries=retries)\n\n\tif write_cnt:\n\t\thdu = pyfits.PrimaryHDU(count)\n\t\thdu = fits_header(band,skypos,tranges,skyrange,width=width,height=height,verbose=verbose,tscale=tscale,hdu=hdu,retries=retries)\n\t\thdulist = pyfits.HDUList([hdu,tbl])\n\t\tif verbose:\n\t\t\tprint 'Writing count image to '+str(write_cnt)\n\t\thdulist.writeto(write_cnt,clobber=clobber)\n\tif write_rr:\n\t\thdu = pyfits.PrimaryHDU(rr)\n\t\thdu = fits_header(band,skypos,tranges,skyrange,width=width,height=height,verbose=verbose,tscale=tscale,hdu=hdu,retries=retries)\n\t\thdulist = pyfits.HDUList([hdu,tbl])\n\t\tif verbose:\n\t\t\tprint 'Writing response image to '+str(write_rr)\n hdulist.writeto(write_rr,clobber=clobber)\n\tif write_int:\n\t\thdu = pyfits.PrimaryHDU(intensity)\n\t\thdu = fits_header(band,skypos,tranges,skyrange,width=width,height=height,verbose=verbose,tscale=tscale,hdu=hdu,retries=retries)\n\t\thdulist = pyfits.HDUList([hdu,tbl])\n\t\tif verbose:\n\t\t\tprint 'Writing intensity image to '+str(write_int)\n\t\thdulist.writeto(write_int,clobber=clobber)\n\n\treturn","def psfphot(image, clobber=globclob, verbose=globver, pixtol=3.0,\n maxnpsf=5, interact=yes):\n\n # Defaults / constants\n psfmult=5.0 #standard factor (multiplied by fwhm to get psfradius)\n psfmultsmall=3.0 #similar to psfmult, adjusted for nstar and substar\n\n # Necessary package\n iraf.imutil()\n\n # Detect stars\n iqpkg.iqobjs(image, 3.0, 50000.0, wtimage=\"\", skyval=\"!MEDSKY\")\n\n root = image[:-5]\n [gain, rnoise, fwhm] = get_head(image, [\"GAIN\", \"READNOI\", \"SEEPIX\"])\n fwhm = float(fwhm); rnoise = float(rnoise)\n\n iraf.iterstat(image)\n \n # Saturation level\n if not check_head(image, \"SATURATE\"):\n saturate = 60000.0\n else:\n saturate = get_head(image, \"SATURATE\")\n \t \n # Update datapars and daopars\n iraf.datapars.fwhmpsf=fwhm\n iraf.datapars.sigma=iraf.iterstat.sigma\n iraf.datapars.datamin=iraf.iterstat.median-10*iraf.iterstat.sigma\n iraf.datapars.datamax=70000.0\n iraf.datapars.readnoise=rnoise\n iraf.datapars.epadu=gain \n iraf.daopars.psfrad=psfmult*fwhm\n iraf.daopars.fitrad=fwhm\n iraf.daopars.function=\"gauss,moffat15,moffat25,lorentz,penny1\"\n\n # coo file\n stars = Starlist(\"%s.stars\" % image)\n outf = open(\"%s.coo.1\" % image[:-5], \"w\")\n for star in stars:\n outf.write(\"%10.3f%10.3f\\n\" % (star.xval, star.yval))\n outf.close()\n\n #initial photometry\n iraf.daophot.phot(root,'default','default',aperture=fwhm,verify=no,\n verbose=verbose)\n\n iraf.datapars.datamax=30000.0\n iraf.pstselect(root,'default','default',maxnpsf,interactive=yes,\n verify=no,verbose=verbose)\n\n iraf.psf(root,'default','default','default','default','default',\n interactive=interact,verify=no,verbose=verbose)\n\n iraf.allstar(root,'default','default','default','default','default',\n verify=no,verbose=verbose)\n\n iraf.iterstat(\"%s.sub.fits\" % root)\n\n iraf.datapars.sigma=iraf.iterstat.sigma\n iraf.datapars.datamin=iraf.iterstat.median-10*iraf.iterstat.sigma\n\n iraf.datapars.datamax=70000.0\n iraf.daophot.phot(\"%s.sub.fits\" % root, \"SN.coo\", 'default', 'default',\n aperture=fwhm, verify=no, verbose=verbose)\n\n iraf.datapars.datamax=30000.0\n iraf.daopars.fitrad=fwhm*2.0\n iraf.allstar(\"%s.sub.fits\" % root, 'default', \"%s.psf.1.fits\" % root, \n 'default', 'default', 'default', verify=no, verbose=no)","def get_sky(plate, mjd, output_path, verbose=False):\n tag = f'PLATE {plate:05d} MJD {mjd:05d} PATH {output_path}'\n if verbose:\n print('Starting {}'.format(tag))\n # Initialize output data.\n last_nexp = None\n plugmaps = []\n wlens = {'b': [], 'r': []}\n wdisps = {'b': [], 'r': []}\n fluxes = {'b': [], 'r': []}\n ivars = {'b': [], 'r': []}\n flats = {'b': [], 'r': []}\n rdnoises = {'b': [], 'r': []}\n masks = {'b': [], 'r': []}\n obskeys = ('EXPOSURE', 'TAI-BEG', 'EXPTIME', 'AZ', 'ALT', 'AIRMASS',\n 'PRESSURE', 'AIRTEMP',\n 'RDNOISE0', 'RDNOISE1', 'RDNOISE2', 'RDNOISE3')\n obsvals = {key: [] for key in obskeys}\n # Size of each amplifier in raw image pixels along (wlen, tracex) axes.\n ampsize = {'b': (2056, 2048), 'r': (2064, 2057)}\n # ampx[band] tabulates whether each wavelength index is readout by\n # amplifier 0/2 (=0) or 1/3 (=1).\n ampx = {'b': 1 * (np.arange(4112) >= 2056),\n 'r': 1 * (np.arange(4128) >= 2064)}\n # amplifer[band] is a function that takes a traceset as input an returns an\n # array that tabulates whether each wavelength index is readout by\n # amplifier 0-3.\n amplifier = {'b': lambda x: 2 * (x >= 2048) + ampx['b'],\n 'r': lambda x: 2 * (x >= 2057) + ampx['r']}\n # Scaling such that RMS = rdnoise_scale * RDNOISEn * neff.\n rdnoise_scale = (4 * np.pi) ** 0.25\n # Conversion from constant log-lambda pixels to wavelength ratio.\n wdisp_const = 1e-4 * np.log(10)\n # Allowed pixel mask bits.\n valid_mask = (1 << 32) - 1\n # Slices of valid data to save. These trim pixels at each end where\n # IVAR=0 or other serious pixel mask bits are often set.\n valid_slices = {'b': slice(767, 3299), 'r': slice(483, 3668) }\n # Initialize data access.\n finder = bossdata.path.Finder()\n mirror = bossdata.remote.Manager()\n # Loop over spectrographs.\n expected_fibers = []\n for specidx in 1, 2:\n # Load the list of science exposures used for this spectrograph's coadd.\n fiber = 500 * (specidx - 1) + 1\n spec_name = finder.get_spec_path(plate, mjd, fiber=fiber, lite=True)\n exposures = bossdata.spec.SpecFile(mirror.get(spec_name)).exposures\n for band in 'b', 'r':\n camera = '{}{}'.format(band, specidx)\n use = valid_slices[band]\n # Loop over science exposures for this camera.\n nexp = exposures.num_by_camera[camera]\n if not (last_nexp is None or nexp == last_nexp):\n print(f'Different nexp for {camera} {tag}')\n return None\n last_nexp = nexp\n for expidx in range(nexp):\n # Load this camera's spFrame file.\n name = exposures.get_exposure_name(expidx, camera, 'spFrame')\n path = mirror.get(finder.get_plate_path(plate, name))\n spFrame = bossdata.plate.FrameFile(path, calibrated=False)\n # Lookup this spectrograph's sky fibers.\n sky_name = binary_type('SKY ', 'ascii')\n fiberidx = np.where(\n spFrame.plug_map['OBJTYPE'] == sky_name)[0]\n if expidx == 0 and band == 'b':\n # Save plugmap metadata.\n plugmaps.append(spFrame.plug_map[\n ['FIBERID','RA','DEC','XFOCAL','YFOCAL']][fiberidx])\n if specidx == 2:\n plugmap = astropy.table.vstack(plugmaps)\n if specidx == 1 and band == 'b':\n # Record observation metadata.\n for key in obskeys:\n try:\n value = spFrame.header[key]\n except KeyError:\n value = -999 # invalid value for int/float types\n obsvals[key].append(value)\n # Load the sky fiber data.\n fibers = spFrame.plug_map['FIBERID'][fiberidx].data\n assert np.all(fiberidx == spFrame.get_fiber_offsets([fibers]))\n if expidx == 0 and band == 'b':\n expected_fibers.append(fibers)\n if verbose:\n print('Found {} sky fibers on spec{}: {}.'.format(\n len(fibers), specidx,\n ','.join([str(f) for f in fibers])))\n else:\n if not np.all(fibers == expected_fibers[specidx - 1]):\n print('Did not get expected fibers for {} exp {}'\n .format(camera, expidx))\n data = spFrame.get_valid_data(\n fibers, include_sky=True, include_wdisp=True, use_ivar=True,\n pixel_quality_mask=valid_mask)\n if verbose:\n print('Reading {} for exposure {} / {}...'\n .format(camera, expidx + 1, nexp))\n assert data.shape == (len(fibers), 2 * ampsize[band][0])\n mask = spFrame.get_pixel_masks(fibers)\n masks[band].append(mask[:, use])\n # Identify pixels with valid data.\n valid = ~data['ivar'].mask\n bad_fibers = ~np.any(valid, axis=1)\n if verbose and np.any(bad_fibers):\n print(' bad fibers: {}'.format(fibers[bad_fibers]))\n ivar = data['ivar'].data\n assert np.all(ivar[valid] > 0)\n ivars[band].append(ivar[:, use])\n # Load the superflat and trace vectors for sky fibers.\n superflat = spFrame.get_superflat(fibers)\n tracex = spFrame.hdulist[7].read()[fiberidx]\n # Load fiberflat and neff vectors from this camera's spFlat.\n name = exposures.get_exposure_name(expidx, camera, 'spFlat')\n path = mirror.get(finder.get_plate_path(plate, name))\n with fits.open(path) as spFlat:\n fiberflat = spFlat[0].data[fiberidx]\n neff = bossdata.plate.TraceSet(spFlat[3]).get_y()[fiberidx]\n if np.any(neff[valid] <= 0):\n print(f'WARNING: neff <= 0 for {camera} {expidx} {tag}')\n # Lookup the per-amplifier readnoise values.\n readnoises = np.array([\n spFrame.header['RDNOISE{}'.format(amp)]\n for amp in range(4)], dtype=np.float32)\n # Determine which amplifier (0-3) each pixel along the trace is\n # read out by and scale to RMS readnoise per wavelength pixel.\n amp = amplifier[band](tracex)\n rdnoise = rdnoise_scale * readnoises[amp] * neff\n rdnoises[band].append(rdnoise[:, use].astype(np.float32))\n # Combine the superflat and fiberflat.\n flat = superflat * fiberflat\n assert np.all(flat[valid] > 0)\n flats[band].append(flat[:, use])\n # Save wavelength solutions in angstroms.\n wlen = data['wavelength'].data\n wlens[band].append(wlen[:, use])\n # Save wavelength dispersions in angstroms.\n wdisp = data['wdisp'].data\n assert np.all(wdisp[valid] > 0)\n wdisp = wlen * np.expm1(wdisp_const * wdisp)\n wdisps[band].append(wdisp[:, use])\n # Save the combined flat-fielded sky models + residuals,\n # which might be negative due to readnoise.\n flux = data['flux'].data + data['sky'].data\n fluxes[band].append(flux[:, use])\n # Build observation metadata table.\n obslist = astropy.table.Table()\n for key in obskeys:\n obslist[key] = obsvals[key]\n # Build the output HDU list.\n hdus = fits.HDUList()\n cards = dict(PLATE=plate, MJD=mjd, NFIBERS=len(plugmap), NEXP=nexp)\n hdus.append(fits.PrimaryHDU(header=fits.Header(cards)))\n hdus.append(fits.table_to_hdu(obslist))\n hdus[-1].name = 'OBSLIST'\n hdus.append(fits.table_to_hdu(plugmap))\n hdus[-1].name = 'PLUGMAP'\n for band in 'b', 'r':\n Band = band.upper()\n # Combine arrays for each band and save an an image HDU.\n hdus.append(fits.ImageHDU(np.vstack(wlens[band]),\n name='{}WLEN'.format(Band)))\n hdus.append(fits.ImageHDU(np.vstack(wdisps[band]),\n name='{}WDISP'.format(Band)))\n hdus.append(fits.ImageHDU(np.vstack(rdnoises[band]),\n name='{}RDNOISE'.format(Band)))\n hdus.append(fits.ImageHDU(np.vstack(flats[band]),\n name='{}FLAT'.format(Band)))\n hdus.append(fits.ImageHDU(np.vstack(fluxes[band]),\n name='{}FLUX'.format(Band)))\n hdus.append(fits.ImageHDU(np.vstack(ivars[band]),\n name='{}IVAR'.format(Band)))\n hdus.append(fits.ImageHDU(np.vstack(masks[band]),\n name='{}MASK'.format(Band)))\n name = os.path.join(output_path, 'sky-{}-{}.fits'.format(plate, mjd))\n hdus.writeto(name, overwrite=True)\n print('Completed {}'.format(tag))\n return obslist","def skycombine(dir = 'Objects'):\n \n if dir ==\"Objects\":\n dir = 'Objects/*/*/flat_corrected/'\n \n for d in glob(dir):\n \n directory = \"/\".join(d.split('/')[0:2]) + '/swarped'\n if not os.path.exists(directory):\n os.makedirs(directory)\n \n keys = ['OBJECTS', 'ITIME', 'FWINAME', 'OBSDATE', 'CAMNAME', 'HISTORY', 'FLSPECTR']\n images = ImageFileCollection(d, keywords = keys, glob_include = 'f*.fits')\n \n swarpfilter(d, dir, directory, images, keys, filter='H', lamp = '*', camera = 'narrow',\n done='Dark Subtracted', output='cKSkyNarrowH', type='EQUATORIAL')\n swarpfilter(d, dir, directory, images, keys, filter='H',lamp = '*', camera = 'wide', \n done='Dark Subtracted', output='cKSkyWideH', type='EQUATORIAL')\n swarpfilter(d, dir, directory, images, keys, filter='J',lamp = '*', camera = 'narrow', \n done='Dark Subtracted', output='cKSkyNarrowJ', type='EQUATORIAL')\n swarpfilter(d, dir, directory, images, keys, filter='J', lamp = '*',camera = 'wide', \n done='Dark Subtracted', output='cKSkyWideJ', type='EQUATORIAL') \n swarpfilter(d, dir, directory, images, keys, filter='Ks',lamp = '*', camera = 'narrow', \n done='Dark Subtracted', output='cKSkyNarrowKs', type='EQUATORIAL')\n swarpfilter(d, dir, directory, images, keys, filter='Ks',lamp = '*', camera = 'wide', \n done='Dark Subtracted', output='cKSkyWideKs', type='EQUATORIAL')\n swarpfilter(d, dir, directory, images, keys, filter='Lp',lamp = '*', camera = 'narrow', \n done='Dark Subtracted', output='cKSkyNarrowLp', type='EQUATORIAL')\n swarpfilter(d, dir, directory, images, keys, filter='Lp',lamp = '*', camera = 'wide', \n done='Dark Subtracted', output='cKSkyNarrowLp', type='EQUATORIAL')","def main(s0, s1, s2, s3, delayFunc, dm, decimate = 0):\n\n\t# Ignore, testing\n\n\n\t# Get the delays (in seconds)\n\tprint(\"Finding time delays...\")\n\tdelays = delayFunc(absftop, -100. / 512, nchans, dm)\n\tprint(\"Delays (s):\")\n\tprint(delays)\n\tdelays /= sampleRate\n\tdelays = delays.astype(int)\n\n\t# Build up a \n\toutputLen = int(s0.shape[0] - np.max(delays))\n\tdataOut = np.ones((outputLen, nchans), dtype = np.int32)\n\tprint(delays)\n\n\t# Terribl approach to RFI\n\tzapchans = list(range(150,200)) + list(range(280, 290)) + list(range(305, 320)) + list(range(450, nchans))\n\n\t# SImple implementation that works, but isn't cache efficient\n\tprint(\"Forming Stokes I + Dedispersing... processing channel:\")\n\tfor i in range(nchans):\n\t\tif i in zapchans:\n\t\t\tcontinue\n\t\tprint(f\"{i} ({100 * i / min(430,nchans)} %)\", end = '\\r')\n\t\tdataOut[..., i] += np.square(s0[delays[i]: delays[i] + outputLen, i].astype(np.int32))\n\t\tdataOut[..., i] += np.square(s1[delays[i]: delays[i] + outputLen, i].astype(np.int32))\n\t\tdataOut[..., i] += np.square(s2[delays[i]: delays[i] + outputLen, i].astype(np.int32))\n\t\tdataOut[..., i] += np.square(s3[delays[i]: delays[i] + outputLen, i].astype(np.int32))\n\n\t# Cache efficient but untested\n\t\"\"\"\n\tprint(\"Forming Stokes I + Dedispersing... processing sample:\")\n\tblockCount = 128\n\tblockSize = int(dataOut.shape[0] / blockCount)\n\tfor i in range(blockCount):\n\t\tif i in zapchans:\n\t\t\tcontinue\n\t\tprint(f\"{i* blockSize} -> {(i + 1) * blockSize} ({100 * i / blockCount:07.3f} %)\", end = '\\r')\n\t\tdataOut[i * blockSize: (i+1) * blockSize, :] += np.square(s0[i * blockLength + delays[i]: (i + 1) * blockLength + delays[i] + outputLen, i].astype(np.int32))\n\t\tdataOut[i * blockSize: (i+1) * blockSize, :] += np.square(s1[i * blockLength + delays[i]: (i + 1) * blockLength + delays[i] + outputLen, i].astype(np.int32))\n\t\tdataOut[i * blockSize: (i+1) * blockSize, :] += np.square(s2[i * blockLength + delays[i]: (i + 1) * blockLength + delays[i] + outputLen, i].astype(np.int32))\n\t\tdataOut[i * blockSize: (i+1) * blockSize, :] += np.square(s3[i * blockLength + delays[i]: (i + 1) * blockLength + delays[i] + outputLen, i].astype(np.int32))\n\t\"\"\"\n\n\tif decimate:\n\t\tprint(\"Decimating...\")\n\t\trollingSum = np.cumsum(dataOut, axis = 0)\n\t\tdataOut = rollingSum[decimate::decimate, :] - rollingSum[:-decimate:decimate, :]\n\n\n\tprint(\"Plotting...\")\n\tplt.figure(figsize = (24,12))\n\tplt.imshow(dataOut.T, aspect = 'auto', vmax = np.percentile(dataOut, 95), vmin = np.percentile(dataOut, 33))\n\tplt.savefig(f'./debugfull_{datetime.datetime.now().isoformat()}.png')\n\n\tplt.figure(figsize = (24,12))\n\tplt.imshow(np.log10(dataOut.T), aspect = 'auto', vmax = np.log10(np.percentile(dataOut, 95)), vmin = np.log10(np.percentile(dataOut, 33)))\n\tplt.savefig(f'./debugfull2_{datetime.datetime.now().isoformat()}.png')\n\t\n\tplt.figure(figsize = (24,12))\n\td1 = dataOut[:, :100].sum(axis = 1)\n\td1 -= np.mean(d1, dtype = np.int64)\n\td2 = dataOut[:, 100:200].sum(axis = 1)\n\td2 -= np.mean(d2, dtype = np.int64)\n\td3 = dataOut[:, 200:300].sum(axis = 1)\n\td3 -= np.mean(d3, dtype = np.int64)\n\td4 = dataOut[:, 300:].sum(axis = 1)\n\td4 -= np.mean(d4, dtype = np.int64)\n\tplt.plot(d1, alpha = 0.3, label = '1')\n\tplt.plot(d2, alpha = 0.3, label = '2')\n\tplt.plot(d3, alpha = 0.3, label = '3')\n\tplt.plot(d4, alpha = 0.3, label = '4')\n\tplt.legend()\n\tplt.savefig(f'./debug_{datetime.datetime.now().isoformat()}.png')\n\n\tprint(\"Done!\")","def activate(self):\n self.scriptedEffect.showEffectCursorInSliceView = False\n self.clippedMasterImageData = None","def run_sift(self):\n paradic = self.cfg['param']['paradic']\n for i in range(2):\n image = 'input_'+str(i)+'.png'\n label = 'im'+str(i)\n f = open(self.work_dir+'keys_'+label+'.txt','w')\n sift = self.run_proc(['sift_cli', image, label,\n str(paradic['n_oct']),\n str(paradic['n_spo']),\n str(paradic['sigma_min']),\n str(paradic['delta_min']),\n str(paradic['sigma_in']),\n str(paradic['C_DoG']),\n str(paradic['C_edge']),\n str(paradic['n_bins']),\n str(paradic['lambda_ori']),\n str(paradic['t']),\n str(paradic['n_hist']),\n str(paradic['n_ori']),\n str(paradic['lambda_descr'])],\n stdout=f) \n self.wait_proc(sift, timeout=self.timeout) \n return 1","def _generate_direct_image(self):\n filename = '0000_flt.fits'\n\n di_start_JD = (self.exp_start_times[0] - 1 * u.min).to(u.day)\n di_exp_gen = ExposureGenerator(self.detector, self.grism, self.NSAMP,\n self.SAMPSEQ, self.SUBARRAY,\n self.planet, filename, di_start_JD)\n\n try: # assume that its a list not a single value\n x_ref = self.x_ref[0]\n except TypeError:\n x_ref = self.x_ref\n\n try: # assume that its a list not a single value\n y_ref = self.y_ref[0]\n except TypeError:\n y_ref = self.y_ref\n\n exp = di_exp_gen.direct_image(x_ref, y_ref)\n exp.generate_fits(self.outdir, '0000_flt.fits')","def bias(s='bias'):\n s = s.strip()[:80] #truncate to 80 char to fit in FITS header\n exptime(0.0)\n print camera.SetShutter(2)\n camera.status.imgtype = 'BIAS'\n camera.status.object = s\n camera.status.update()","def _full_speed_rumble(self, images, duration):\n while duration > 0:\n self.microbit.display.show(images[0]) # pylint: disable=no-member\n time.sleep(0.04)\n self.microbit.display.show(images[1]) # pylint: disable=no-member\n time.sleep(0.04)\n duration -= 0.08","def exposure():\n def r(x):\n return x/6e4\n\n def w(x):\n return int(x*6e4)\n return r, w","def OFlow(testdirs, opath):\n\n\t# create directories if doesn't exist\n\tif not os.path.exists(opath):\n\t\tos.makedirs(opath)\n\n\tif not os.path.exists(opath+'/each_image'):\n\t\tos.makedirs(opath+'/each_image')\n\t\t\n\tif not os.path.exists(opath+'/masks'):\n\t\tos.makedirs(opath+'/masks')\n\t\t\n\tif not os.path.exists(opath+'/scaled_masks'):\n\t\tos.makedirs(opath+'/scaled_masks')\n\n\tdcount = 0\t# directory count\n\n\tfor d in testdirs:\n\n\t\th = d[-65:-1]\t# hash\n\n\t\t# create directory for each hash to save individual optical flow images separately\n\t\tif not os.path.exists(opath+'/each_image/'+h):\n\t\t\tos.makedirs(opath+'/each_image/'+h)\n\n\t\tprvs = cv2.imread(d + 'frame0000.png', 0)\t# previous image\n\n\t\ts = (prvs.shape[0], prvs.shape[1], 3)\t# hsv image shape\n\n\t\thsv = np.zeros(s, np.uint8)\n\t\thsv[...,1] = 255\n\t\t\n\t\tms = (prvs.shape[0], prvs.shape[1])\t\t# mask shape\n\t\t\n\t\tmask = np.zeros(ms, np.uint8)\n\t\tsum_mask = np.zeros(ms, np.uint8)\n\t\tscaled_mask = np.zeros(ms, np.uint8)\n\t\t\n\t\tprint(\"dir: \",dcount,\" dim: \",sum_mask.shape)\n\t\tdcount += 1\n\t\t\n\t\tflag = 0\n\n\t\tfor i in range(1,100):\n\t\t\tnxt = cv2.imread(d + 'frame00'+str(i).zfill(2)+'.png', 0)\t# next image\n\t\t\tflow = cv2.calcOpticalFlowFarneback(prvs,nxt, None, 0.5, 3, 15, 3, 5, 1.2, 0)\n\t\t\tmag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])\t# calculates magnitude and angles of 2D vectors\n\t\t\t\n\t\t\thsv[...,0] = ang*180/np.pi/2\n\t\t\t\n\t\t\thsv[...,2] = cv2.normalize(mag,None,0,255,cv2.NORM_MINMAX)\n\t\t\tbgr = cv2.cvtColor(hsv,cv2.COLOR_HSV2BGR)\n\t\t\tomg = cv2.cvtColor(bgr,cv2.COLOR_BGR2GRAY)\n\t#\t\tprint(omg.dtype)\n\t#\t\tprint(omg.shape)\n\t\t\t\n\t\t\tcv2.imshow('frame1',omg)\n\t\t\tom = Image.fromarray(omg)\n\t\t\tom.save(opath+'/each_image/'+h+'/frame00'+str(i).zfill(2)+'.png', 0)\n\t\t\t\n\t\t\tomg2 = omg\n\n\t\t\t# scaling with random hardcoded values\n\t\t\tfor r in range(omg2.shape[0]):\n\t\t\t\tfor c in range(omg2.shape[1]):\n\t\t\t\t\tif omg2[r][c] < 32:\n\t\t\t\t\t\tsum_mask[r][c] += 0\n\t\t\t\t\telif omg2[r][c] < 128:\n\t\t\t\t\t\tsum_mask[r][c] += 1\n\t\t\t\t\telse:\n\t\t\t\t\t\tsum_mask[r][c] += 2\n\n\t\t\tflag = cv2.waitKey(30) & 0xff\n\t\t\tif flag == 27:\t\t# press ESC to exit\n\t\t\t break\n\n\t\t\tprvs = nxt\n\n\t\t# generating mask based on sum_mask again based on random hardcoded values\n\t\tfor r in range(prvs.shape[0]):\n\t\t\tfor c in range(prvs.shape[1]):\n\t\t\t\tif sum_mask[r][c] > 50:\n\t\t\t\t\tmask[r][c] = 2\n\t\t\t\t\tscaled_mask[r][c] = 255\n\t\t\t\telif sum_mask[r][c] > 15:\n\t\t\t\t\tmask[r][c] = 1\n\t\t\t\t\tscaled_mask[r][c] = 128\n\t\tomask = Image.fromarray(mask)\n\t\tomask.save(opath+'/masks/'+h+'.png', 0)\n\t\tosmask = Image.fromarray(scaled_mask)\n\t\tosmask.save(opath+'/scaled_masks/'+h+'.png', 0)\n\n\tcv2.destroyAllWindows()","def toggle_exposure(self):\n\n checked1 = self.exp1_radio.isChecked()\n if checked1:\n self.exp2_radio.setChecked(True)\n else:\n self.exp1_radio.setChecked(True)\n self.select_exposure()","def __init__(self, width, height, framerate, max_dist, sv_path, \n record_time, saveimg, savepc, savebag):\n self.width = width\n self.height = height\n self.framerate = framerate\n self.max_dist = max_dist # filter\n self.sv_path = sv_path\n self.record_time = record_time\n self.saveimg = saveimg\n self.savepc = savepc\n self.savebag = savebag\n\n self.lane_detector = LaneDetector()\n self.pc = rs.pointcloud()\n self.colorizer = rs.colorizer()\n self.create_filter()","def setProtectSurfaces():\n dislin.shlsur()","def step(self, amt=1):\n \n # For checking if all the animations have their framse looked at\n #activewormind = [i for i, x in enumerate(self._idlelist) if x == False]\n #print \"Worm {} at {:5g}\".format(activewormind, 1000*(time.time() - starttime))\n # save times activated for each worm \n [self.timedata[i].append(1000*(time.time() - starttime)) for i, x in enumerate(self._idlelist) if x == False]\n \n #self._led.buffer = [0] * 480\n self._led.pixheights = [-100] * self._led.numLEDs\n #print type(self._led.buffer)\n for ledcopy in self._ledcopies:\n # self._led.buffer = map(ixor, self._led.buffer, ledcopy.buffer)\n # use pixheights but assume all buffers same size\n # print ledcopy.driver[0].pixheights\n for pix in range(self._led.numLEDs):\n #for ledcopy in self._ledcopies:\n if self._led.pixheights[pix] == ledcopy.driver[0].pixheights[pix]:\n for i in range(3):\n self._led.buffer[3*pix + i] ^= ledcopy.buffer[3*pix + i]\n elif self._led.pixheights[pix] < ledcopy.driver[0].pixheights[pix]:\n for i in range(3):\n self._led.buffer[3*pix + i] = ledcopy.buffer[3*pix + i]\n self._led.pixheights[pix] = ledcopy.driver[0].pixheights[pix] \n self._step += 1","def run_observation(self):\n\n self._generate_direct_image() # to calibrate x_ref and y_ref\n\n num_frames = len(self.exp_start_times)\n progress = Progress(num_frames)\n self.progess = progress\n\n progress_line = 'Generating frames 0/{} done'.format(num_frames)\n progress.print_status_line(progress_line)\n progress.progress_line = progress_line\n\n for i, start_time in enumerate(self.exp_start_times):\n filenum = i + 1\n self._generate_exposure(start_time, filenum)\n\n progress.increment()\n progress_line = 'Generating frames {}/{} done'.format(filenum,\n num_frames)\n progress.print_status_line(progress_line)\n\n # so it can be retreived by exposure_generator\n progress.progress_line = progress_line","def fireRandom():\n#the increment and the A1-H8 define the possible colors the pixels can be\n\tincrement = 20\n A1 = Color(255, 0, 0)\n B2 = Color(255, increment, 0)\n C3 = Color(255, increment * 2, 0)\n D4 = Color(255, increment * 3, 0)\n E5 = Color(255, increment * 4, 0)\n F6 = Color(255, increment * 5, 0)\n G7 = Color(255, increment * 6, 0)\n H8 = Color(255, increment * 7, 0)\n#the for loop with i and the number of pixels cycles through all the pixels we have so that they each get called when a random number does\n for i in range (strip.numPixels()):\n threeQuarters = randrange(0, 4)\n if threeQuarters == 1 or threeQuarters == 2 or threeQuarters == 3 :\n#the above if statement and the threeQuarters variable makes it so that the pixels only recieve a color 75% of the time. This makes a flicker.\n shade = randrange(0,9)\n\n if shade == 1:\n strip.setPixelColor(i, A1)\n strip.show()\n elif shade == 2:\n strip.setPixelColor(i, B2)\n strip.show()\n elif shade == 3:\n strip.setPixelColor(i, C3)\n strip.show()\n elif shade == 4:\n strip.setPixelColor(i, D4)\n strip.show()\n elif shade == 5:\n strip.setPixelColor(i, E5)\n strip.show()\n elif shade == 6:\n strip.setPixelColor(i, F6)\n strip.show()\n elif shade == 7:\n strip.setPixelColor(i, G7)\n\t\t\t\tstrip.show()\n\t\t\telse: \n\t\t\t\tstrip.setPixelColor(i, H8)\n\t\t\t\tstrip.show()"],"string":"[\n \"def do_line_scan_shutter_closed(self):\\n scan = self.scan\\n laser = self.devices[scan['laser']['name']]\\n shutter = self.scan['shutter']\\n ni_daq = self.devices['NI-DAQ']\\n ni_daq.driver.digital_output(shutter['port'], False)\\n if not isinstance(shutter['delay'], Q_):\\n delay = Q_(shutter['delay'])\\n else:\\n delay = shutter['delay']\\n delay = delay.m_as('s')\\n if delay > 0:\\n time.sleep(delay)\\n ni_daq.driver.digital_output(shutter['port'], True)\\n print('Pumped Scan')\\n laser.driver.execute_sweep()\\n approx_time_to_scan = (laser.params['stop_wavelength'] - laser.params['start_wavelength']) / laser.params['wavelength_speed']*laser.params['wavelength_sweeps']\\n\\n while laser.driver.sweep_condition != 'Stop':\\n sleep(approx_time_to_scan.m/config.monitor_read_scan)\\n ni_daq.driver.digital_output(shutter['port'], False)\\n laser.driver.wavelength = scan['laser']['params']['start_wavelength']\\n \\n # Repeat with shutter closed to get reference scan\\n \\n ni_daq.driver.digital_output(shutter['port'], False)\\n if not isinstance(shutter['delay'], Q_):\\n delay = Q_(shutter['delay'])\\n else:\\n delay = shutter['delay']\\n delay = delay.m_as('s')\\n if delay > 0:\\n time.sleep(delay)\\n print('Reference Scan')\\n laser.driver.execute_sweep()\\n approx_time_to_scan = (laser.params['stop_wavelength'] - laser.params['start_wavelength']) / laser.params['wavelength_speed']*laser.params['wavelength_sweeps']\\n while laser.driver.sweep_condition != 'Stop':\\n sleep(approx_time_to_scan.m/config.monitor_read_scan)\\n laser.driver.wavelength = scan['laser']['params']['start_wavelength']\\n \\n return True\",\n \"def sharpen_slide(self):\\r\\n std_input = self.horizontal.get() # Get the std defined by user\\r\\n c_input = self.vertical.get() # get the constant defined by the user\\r\\n img = self.master.images[-1] # Use the most recent displayed image for sharpening\\r\\n sharpened_image = sharpen.gaussian_unsharp_masking(img, std_input, c_input) # Apply unsharp masking on image\\r\\n self.master.display_image.display_image(img=sharpened_image) # display sharpened image\\r\\n self.master.images.append(sharpened_image) # Append the sharpened image on the stack\\r\",\n \"def run(self):\\n openShutter = True\\n actuateXed = False\\n image_type = \\\"PPUMP\\\"\\n\\n wl = float(self.eo_config.get(\\\"PPUMP_WL\\\", 550))\\n meas_flux = self.measured_flux(wl)\\n seqno = 0\\n for tokens in self.instructions:\\n exptime = float(tokens[1])\\n nframes = int(tokens[2])\\n shifts = int(tokens[3])\\n for iframe in range(nframes):\\n self.image_clears()\\n self.bias_image(seqno)\\n self.take_image(seqno, exptime, openShutter, actuateXed,\\n image_type)\\n seqno += 1\",\n \"def sync_shutter(self):\\n shutter = self.scan['shutter']\\n ni_daq = self.devices['NI-DAQ']\\n ni_daq.driver.digital_output(shutter['port'], False)\\n time.sleep(0.2)\\n ni_daq.driver.digital_output(shutter['port'], True)\\n time.sleep(0.2)\\n ni_daq.driver.digital_output(shutter['port'], False)\",\n \"def testSharpen (name = \\\"smokey.gif\\\", degree = 50, amount = 20):\\n image = Image(name)\\n print(\\\"Close the image window to see the transformation\\\")\\n image.draw()\\n image2 = sharpen(image, degree, amount)\\n image2.draw()\",\n \"def main():\\n camera = picamera.PiCamera()\\n camera.resolution = (RESOLUTIONX, RESOLUTIONY)\\n camera.iso = 800\\n time.sleep(2)\\n while True:\\n camera.capture('current-image.jpg')\\n adapt_steering(navigation.get_xposition('current-image.jpg'))\\n time.sleep(0.4)\",\n \"def shutter_pulse(self, width):\\n step_name = 'Shutter Pulse'\\n self.shutter.settings['shutter_open'] = True\\n self.db_poll(step_name)\\n print('Shutter open')\\n t0 = time.time()\\n t_lastlog = t0\\n while True:\\n if self.interrupt_measurement_called:\\n self.shutter.settings['shutter_open'] = False\\n break\\n if time.time()-t0 > width:\\n break\\n time.sleep(0.001)\\n if time.time() - t_lastlog > 0.2:\\n # do some logging\\n self.db_poll(step_name)\\n t_lastlog = time.time()\\n \\n self.shutter.settings['shutter_open'] = False\\n self.settings['steps_taken'] += 1\\n print('Shutter closed')\",\n \"def measure_darks(det, shutter, quantity):\\n yield from set_dark_frame()\\n yield from bps.mv(shutter, \\\"close\\\")\\n yield from _acquire_n_frames(det, quantity)\",\n \"def shar():\\n pass\",\n \"def warmup():\\n print camera.CoolerOFF()\\n camera.status.update()\",\n \"def shutter(self, state):\\n if self.status != \\\"not connected\\\":\\n m = self.serial\\n m.write(\\\"shutter \\\" + str(state) + \\\"\\\\r\\\\n\\\")\\n r = m.read(100)\\n if state == 'O':\\n st = \\\"open\\\"\\n else:\\n st = \\\"closed\\\"\\n result = \\\"out.monochrom: Shutter is \\\" + st\\n return result\\n else:\\n pass\",\n \"def sample_damaging(image):\\r\\n return crease_image(blotch_image(image, 100, True), 10, False)\",\n \"def expose(self):\\n if self.camera is None: # test mode -- immediately return test image\\n print(\\\"NO SPECTRAL CAMERA FOUND -- USING TEST DATA\\\")\\n self.filename = \\\"example_fits_files/Mooi\\\"\\n return\\n\\n exposure_time = self.time.get()\\n try:\\n self.exposure_time = float(exposure_time)\\n except:\\n message = \\\"Exposure time \\\\\\\"{0}\\\\\\\" cannot be converted to floating point number\\\".format(exposure_time)\\n messagebox.showerror(\\\"Error\\\", message)\\n raise ValueError(message)\\n filename = \\\"spectra/{0}\\\".format(timestamp())\\n self.camera.spectrum(self.exposure_time, filename)\\n self.filename = filename\",\n \"def setShutter( self, c, devChannel, state ):\\n dev = 'shutter'\\n self.validateDevChannel( dev, devChannel )\\n self.validateInput( dev, state )\\n channel = self.dcDict[dev]['devChannels'][devChannel]['channel']\\n self.tryToSend( channel, state )\",\n \"def skywalker(this, **kargs):\\n\\t\\t\\n\\t\\t# Arguments\\n\\t\\tbin = kargs.get('bin', this._BINARY)\\n\\t\\toffshore = kargs.get('offshore', 5)\\n\\t\\tminSize = kargs.get('minSize', 3)\\n\\t\\tblur = kargs.get('blur', False)\\n\\t\\t\\n\\t\\tif blur: # Flou de test\\n\\t\\t\\tkernel = np.ones((3, 3), np.float32)/9\\n\\t\\t\\tbin = cv2.filter2D(bin, -1, kernel)\\n\\t\\t\\n\\t\\t# On duplique l'image pour le rendu final\\n\\t\\tscan = EmptyFrom(bin, 3)\\n\\t\\tscan[:,:,0] = scan[:,:,1] = scan[:,:,2] = bin\\n\\t\\tthis._SCAN = scan\\n\\t\\t\\n\\t\\tstep = 0 # Compteur de pas dans le vide\\n\\t\\tstart, end = None, None\\n\\t\\t\\n\\t\\t# Dimensions de l'image à scanner\\n\\t\\tsize = D2Point(width(bin), height(bin))\\n\\t\\tratio = size if minSize < 1 else 1\\n\\t\\t\\n\\t\\t# Scan pixel par pixel, en partant du bas\\n\\t\\tfor v in xrange(int(size.y)-1, -1, -1):\\n\\t\\t\\tfor u in xrange(int(size.x)):\\n\\t\\t\\t\\n\\t\\t\\t\\tif bin.item((v, u)): # Si un pixel != 0:\\n\\t\\t\\t\\t\\tscan[v,u] = [0, 0, 255] # Rouge.\\n\\t\\t\\t\\t\\tstep = 0 # On reset le jump\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t# Si c'est le premier\\n\\t\\t\\t\\t\\tif not start:\\n\\t\\t\\t\\t\\t\\tstart = D2Point(u, v)\\n\\t\\t\\t\\t\\t\\tend = D2Point(u, v)\\n\\t\\t\\t\\t\\telse: # On trace\\n\\t\\t\\t\\t\\t\\tend.x, end.y = u, v\\n\\t\\t\\t\\t\\n\\t\\t\\t\\telif end:\\n\\t\\t\\t\\t\\tif step < offshore:\\n\\t\\t\\t\\t\\t\\tscan[v,u] = [0, 255, 255] # Jaune\\n\\t\\t\\t\\t\\t\\tstep += 1 # On continue\\n\\t\\t\\t\\t\\telif abs((start - end)/ratio) < minSize:\\n\\t\\t\\t\\t\\t\\tstart, end = None, None\\n\\t\\t\\t\\t\\telse: break\\n\\t\\t\\t\\t# elif end: break\\n\\t\\t\\t###\\n\\t\\t\\tif end: break\\n\\t\\t###\\n\\t\\t\\n\\t\\tif end: # Si on a trouvé une fin\\n\\t\\t\\t\\n\\t\\t\\t# Point médian = doigt\\n\\t\\t\\tresult = start % end\\n\\t\\t\\t\\n\\t\\t\\t# Visuel\\n\\t\\t\\tscan[:,result.x,:] = [0, 255, 0] # On trace une bande verte\\n\\t\\t\\tscan[result.y,:,:] = [0, 127, 0] # On trace une autre bande verte\\n\\t\\t\\t\\n\\t\\t\\t# Reformatage\\n\\t\\t\\tresult /= size-1 # On remet en ratio d'image\\n\\t\\t\\tresult.x = 1 - result.x # On inverse le côté de mesure\\n\\t\\t\\t\\n\\t\\t\\t# Stockage\\n\\t\\t\\tthis._DETECTED = result # On stocke le point détecté\\n\\t\\t\\tthis._BOTTOM = result.y == 1 # On clic ou bien ?\\n\\t\\t\\n\\t\\t# Si rien\\n\\t\\telse:\\n\\t\\t\\tresult = None\\n\\t\\t\\tthis._BOTTOM = False\\n\\t\\t\\n\\t\\t# Tchao\\n\\t\\treturn result\",\n \"def wfits(self, filename=None):\\n with self.lock:\\n dark = self.dark\\n if not filename:\\n if dark != 0:\\n filename = self.getNextFilename(\\\"dark\\\")\\n else:\\n filename = self.getNextFilename(\\\"object\\\")\\n with self.lock:\\n if(self.data.size == 0):\\n raise FliError(\\\"No image available\\\")\\n hdu = pyfits.PrimaryHDU(self.data)\\n hdr = hdu.header\\n with self.lock:\\n hdr.set('DATE', self.timestamp, 'exposure begin date')\\n hdr.set('INSTRUME', self.devname, 'this instrument')\\n hdr.set('SERIAL', self.devsn, 'serial number')\\n hdr.set('EXPTIME', self.exptime, 'exposure time (ms)')\\n hdr.set('VBIN', self.vbin, 'vertical binning')\\n hdr.set('HBIN', self.hbin, 'horizontal binning')\\n hdr.set('CCD-TEMP', self.temp, 'CCD temperature')\\n if dark != 0:\\n hdr.set('SHUTTER', 'CLOSE', 'shutter status')\\n else:\\n hdr.set('SHUTTER', 'OPEN', 'shutter status')\\n hdr.set('CCDAREA', '[%d:%d,%d:%d]' % self.expArea, 'image area')\\n hdu.writeto(filename, overwrite=True, checksum=True)\\n with self.lock:\\n self.filename = filename\",\n \"def start(self):\\n self.frame = 0\\n self._init_level(1)\\n self.reward = 0\\n self.pcontinue = 1\\n self.ghost_speed = self.ghost_speed_init\\n return self._make_image(), self.reward, self.pcontinue\",\n \"def __init__(\\n self,\\n win,\\n outer_diam_pix,\\n inner_diam_pix,\\n bg_colour=(-1, -1, -1),\\n line_colour=(+1, +1, +1),\\n spot_colour=(-1, -1, -1),\\n circle_edges=128,\\n ):\\n\\n self._win = win\\n self._outer_diam_pix = outer_diam_pix\\n self._inner_diam_pix = inner_diam_pix\\n self._circle_edges = circle_edges\\n self._stim = {}\\n\\n self._stim[\\\"aperture\\\"] = psychopy.visual.Aperture(\\n win=win,\\n size=self._outer_diam_pix,\\n nVert=self._circle_edges,\\n shape=\\\"circle\\\",\\n units=\\\"pix\\\",\\n autoLog=False,\\n )\\n\\n self._stim[\\\"aperture\\\"].enabled = False\\n\\n self._stim[\\\"bg\\\"] = psychopy.visual.Circle(\\n win=self._win,\\n radius=self._outer_diam_pix / 2.0,\\n units=\\\"pix\\\",\\n lineColor=None,\\n fillColor=bg_colour,\\n edges=self._circle_edges,\\n autoLog=False,\\n )\\n\\n self._stim[\\\"line\\\"] = psychopy.visual.Rect(\\n win=self._win,\\n size=(self._outer_diam_pix * 2, self._inner_diam_pix),\\n units=\\\"pix\\\",\\n lineWidth=0,\\n lineColor=None,\\n fillColor=line_colour,\\n autoLog=False,\\n )\\n\\n self._stim[\\\"spot\\\"] = psychopy.visual.Circle(\\n win=self._win,\\n radius=self._inner_diam_pix / 2.0,\\n units=\\\"pix\\\",\\n fillColor=spot_colour,\\n edges=self._circle_edges,\\n lineWidth=0,\\n autoLog=False,\\n )\\n\\n self.bg_colour = bg_colour\\n self.line_colour = line_colour\\n self.spot_colour = spot_colour\",\n \"def _generate_exposure(self, expstart, number):\\n\\n index_number = number - 1 # for zero indexing\\n\\n filename = '{:04d}_raw.fits'.format(number)\\n\\n exp_gen = ExposureGenerator(self.detector, self.grism, self.NSAMP,\\n self.SAMPSEQ, self.SUBARRAY,\\n self.planet, filename, expstart)\\n\\n if not self.spatial_scan:\\n self.sample_rate = 1 * u.year # high number reverts to read times\\n\\n _, sample_mid_points, sample_durations, read_index = \\\\\\n exp_gen._gen_scanning_sample_times(self.sample_rate)\\n\\n time_array = (sample_mid_points + expstart).to(u.day)\\n\\n if self.transmission_spectroscopy:\\n star_norm_flux = self.generate_lightcurves(time_array)\\n planet_depths = 1 - star_norm_flux\\n else:\\n planet_depths = None\\n\\n # x shifts - linear shift with exposure, second exposure shifted by\\n # x_shifts, direct image and first exp will match.\\n x_ref = self._try_index(self.x_ref, index_number)\\n y_ref = self._try_index(self.y_ref, index_number)\\n sky_background = self._try_index(self.sky_background, index_number)\\n\\n # X and Y Shifts\\n x_ref += self.x_shifts * index_number\\n y_ref += self.y_shifts * index_number\\n x_jitter = self.x_jitter\\n y_jitter = self.y_jitter\\n\\n if self._visit_trend:\\n scale_factor = self._visit_trend.get_scale_factor(index_number)\\n else:\\n scale_factor = None\\n\\n if self.spatial_scan:\\n exp_frame = exp_gen.scanning_frame(\\n x_ref, y_ref, x_jitter, y_jitter,\\n self.wl, self.stellar_flux, planet_depths,\\n self.scan_speed, self.sample_rate, sample_mid_points,\\n sample_durations, read_index, ssv_generator=self.ssv_gen,\\n noise_mean=self.noise_mean, noise_std=self.noise_std,\\n add_flat=self.add_flat, add_dark=self.add_dark,\\n scale_factor=scale_factor, sky_background=sky_background,\\n cosmic_rate=self.cosmic_rate,\\n add_gain_variations=self.add_gain_variations,\\n add_non_linear=self.add_non_linear,\\n clip_values_det_limits=self.clip_values_det_limits,\\n add_read_noise=self.add_read_noise,\\n add_stellar_noise=self.add_stellar_noise,\\n add_initial_bias=self.add_initial_bias,\\n progress_bar=self.progess,\\n threads=self.threads\\n )\\n else:\\n exp_frame = exp_gen.staring_frame(\\n x_ref, y_ref, x_jitter, y_jitter,\\n self.wl, self.stellar_flux, planet_depths,\\n sample_mid_points, sample_durations, read_index,\\n noise_mean=self.noise_mean, noise_std=self.noise_std,\\n add_flat=self.add_flat, add_dark=self.add_dark,\\n scale_factor=scale_factor, sky_background=sky_background,\\n cosmic_rate=self.cosmic_rate,\\n add_gain_variations=self.add_gain_variations,\\n add_non_linear=self.add_non_linear,\\n clip_values_det_limits=self.clip_values_det_limits,\\n add_read_noise=self.add_read_noise,\\n add_stellar_noise=self.add_stellar_noise,\\n add_initial_bias=self.add_initial_bias,\\n progress_bar=self.progess,\\n threads=self.threads\\n )\\n\\n exp_frame.generate_fits(self.outdir, filename, ldcoeffs=self.ldcoeffs)\\n\\n return exp_frame\",\n \"def cmdMouse(self, dev):\\n self.hitsMouses[dev] = False\\n f = open(self.inputPath + dev, 'rb')\\n while self.live:\\n f.read(500) # 144 kan eigenlijk alles zijn, behalve absurbt hoge waarden..\\n self.hitsMouses[dev] = True\\n time.sleep(0.1)\",\n \"def effect_spread(self, distance):\\n self.load()\\n return self._new(self.im.effect_spread(distance))\",\n \"def go():\\n ##########\\n #\\n # MB19284\\n #\\n ##########\\n\\n ##########\\n # Kp-band reduction\\n ##########\\n\\n target = 'mb19284'\\n sci_files = ['i200822_a011{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\\n sci_files += ['i200822_a012{0:03d}_flip'.format(ii) for ii in range(2, 25+1)]\\n sky_files = ['i200822_a018{0:03d}_flip'.format(ii) for ii in range(2, 6+1)]\\n refSrc = [917.75, 1033.5] # This is the target\\n # Alternative star to try (bright star to bottom of target): [1015, 581.9]\\n \\n sky.makesky(sky_files, target, 'kp_tdOpen', instrument=osiris)\\n data.clean(sci_files, target, 'kp_tdOpen', refSrc, refSrc, field=target, instrument=osiris)\\n data.calcStrehl(sci_files, 'kp_tdOpen', field=target, instrument=osiris)\\n data.combine(sci_files, 'kp_tdOpen', epoch, field=target,\\n trim=0, weight='strehl', submaps=3, instrument=osiris)\\n\\n ##########\\n #\\n # KB200101\\n #\\n ##########\\n\\n ##########\\n # Kp-band reduction\\n ##########\\n\\n # -- If you have more than one position angle, make sure to\\n # clean them seperatly.\\n # -- Strehl and Ref src should be the pixel coordinates of a bright\\n # (but non saturated) source in the first exposure of sci_files.\\n # -- If you use the OSIRIS image, you must include the full filename in the list. \\n target = 'kb200101'\\n sci_files = ['i200822_a014{0:03d}_flip'.format(ii) for ii in range(2, 28+1)]\\n sci_files += ['i200822_a015{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\\n sci_files += ['i200822_a016{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\\n sky_files = ['i200822_a017{0:03d}_flip'.format(ii) for ii in range(2, 6+1)]\\n refSrc = [975, 1006] # This is the target\\n # Alternative star to try (bright star to right of target): [1158, 994]\\n \\n sky.makesky(sky_files, target, 'kp_tdOpen', instrument=osiris)\\n data.clean(sci_files, target, 'kp_tdOpen', refSrc, refSrc, field=target, instrument=osiris)\\n data.calcStrehl(sci_files, 'kp_tdOpen', field=target, instrument=osiris)\\n data.combine(sci_files, 'kp_tdOpen', epoch, field=target,\\n trim=1, weight='strehl', submaps=3, instrument=osiris)\",\n \"def main():\\n\\n with its.device.ItsSession() as cam:\\n\\n props = cam.get_camera_properties()\\n its.caps.skip_unless(its.caps.raw16(props) and\\n its.caps.manual_sensor(props) and\\n its.caps.read_3a(props) and\\n its.caps.per_frame_control(props) and\\n not its.caps.mono_camera(props))\\n debug = its.caps.debug_mode()\\n\\n # Expose for the scene with min sensitivity\\n exp_min, exp_max = props[\\\"android.sensor.info.exposureTimeRange\\\"]\\n sens_min, _ = props[\\\"android.sensor.info.sensitivityRange\\\"]\\n # Digital gains might not be visible on RAW data\\n sens_max = props[\\\"android.sensor.maxAnalogSensitivity\\\"]\\n sens_step = (sens_max - sens_min) / NUM_ISO_STEPS\\n white_level = float(props[\\\"android.sensor.info.whiteLevel\\\"])\\n black_levels = [its.image.get_black_level(i,props) for i in range(4)]\\n # Get the active array width and height.\\n aax = props[\\\"android.sensor.info.activeArraySize\\\"][\\\"left\\\"]\\n aay = props[\\\"android.sensor.info.activeArraySize\\\"][\\\"top\\\"]\\n aaw = props[\\\"android.sensor.info.activeArraySize\\\"][\\\"right\\\"]-aax\\n aah = props[\\\"android.sensor.info.activeArraySize\\\"][\\\"bottom\\\"]-aay\\n raw_stat_fmt = {\\\"format\\\": \\\"rawStats\\\",\\n \\\"gridWidth\\\": aaw/IMG_STATS_GRID,\\n \\\"gridHeight\\\": aah/IMG_STATS_GRID}\\n\\n e_test = []\\n mult = 1.0\\n while exp_min*mult < exp_max:\\n e_test.append(int(exp_min*mult))\\n mult *= EXP_MULT\\n if e_test[-1] < exp_max * INCREASING_THR:\\n e_test.append(int(exp_max))\\n e_test_ms = [e / 1000000.0 for e in e_test]\\n\\n for s in range(sens_min, sens_max, sens_step):\\n means = []\\n means.append(black_levels)\\n reqs = [its.objects.manual_capture_request(s, e, 0) for e in e_test]\\n # Capture raw in debug mode, rawStats otherwise\\n caps = []\\n for i in range(len(reqs) / SLICE_LEN):\\n if debug:\\n caps += cam.do_capture(reqs[i*SLICE_LEN:(i+1)*SLICE_LEN], cam.CAP_RAW)\\n else:\\n caps += cam.do_capture(reqs[i*SLICE_LEN:(i+1)*SLICE_LEN], raw_stat_fmt)\\n last_n = len(reqs) % SLICE_LEN\\n if last_n == 1:\\n if debug:\\n caps += [cam.do_capture(reqs[-last_n:], cam.CAP_RAW)]\\n else:\\n caps += [cam.do_capture(reqs[-last_n:], raw_stat_fmt)]\\n elif last_n > 0:\\n if debug:\\n caps += cam.do_capture(reqs[-last_n:], cam.CAP_RAW)\\n else:\\n caps += cam.do_capture(reqs[-last_n:], raw_stat_fmt)\\n\\n # Measure the mean of each channel.\\n # Each shot should be brighter (except underexposed/overexposed scene)\\n for i,cap in enumerate(caps):\\n if debug:\\n planes = its.image.convert_capture_to_planes(cap, props)\\n tiles = [its.image.get_image_patch(p, 0.445, 0.445, 0.11, 0.11) for p in planes]\\n mean = [m * white_level for tile in tiles\\n for m in its.image.compute_image_means(tile)]\\n img = its.image.convert_capture_to_rgb_image(cap, props=props)\\n its.image.write_image(img, \\\"%s_s=%d_e=%05d.jpg\\\" % (NAME, s, e_test))\\n else:\\n mean_image, _ = its.image.unpack_rawstats_capture(cap)\\n mean = mean_image[IMG_STATS_GRID/2, IMG_STATS_GRID/2]\\n\\n print \\\"ISO=%d, exposure time=%.3fms, mean=%s\\\" % (\\n s, e_test[i] / 1000000.0, str(mean))\\n means.append(mean)\\n\\n\\n # means[0] is black level value\\n r = [m[0] for m in means[1:]]\\n gr = [m[1] for m in means[1:]]\\n gb = [m[2] for m in means[1:]]\\n b = [m[3] for m in means[1:]]\\n\\n pylab.plot(e_test_ms, r, \\\"r.-\\\")\\n pylab.plot(e_test_ms, b, \\\"b.-\\\")\\n pylab.plot(e_test_ms, gr, \\\"g.-\\\")\\n pylab.plot(e_test_ms, gb, \\\"k.-\\\")\\n pylab.xscale('log')\\n pylab.yscale('log')\\n pylab.title(\\\"%s ISO=%d\\\" % (NAME, s))\\n pylab.xlabel(\\\"Exposure time (ms)\\\")\\n pylab.ylabel(\\\"Center patch pixel mean\\\")\\n matplotlib.pyplot.savefig(\\\"%s_s=%d.png\\\" % (NAME, s))\\n pylab.clf()\\n\\n allow_under_saturated = True\\n for i in xrange(1, len(means)):\\n prev_mean = means[i-1]\\n mean = means[i]\\n\\n if np.isclose(max(mean), white_level, rtol=SATURATION_TOL):\\n print \\\"Saturated: white_level %f, max_mean %f\\\"% (white_level, max(mean))\\n break;\\n\\n if allow_under_saturated and np.allclose(mean, black_levels, rtol=BLK_LVL_TOL):\\n # All channel means are close to black level\\n continue\\n\\n allow_under_saturated = False\\n # Check pixel means are increasing (with small tolerance)\\n channels = [\\\"Red\\\", \\\"Gr\\\", \\\"Gb\\\", \\\"Blue\\\"]\\n for chan in range(4):\\n err_msg = \\\"ISO=%d, %s, exptime %3fms mean: %.2f, %s mean: %.2f, TOL=%.f%%\\\" % (\\n s, channels[chan],\\n e_test_ms[i-1], mean[chan],\\n \\\"black level\\\" if i == 1 else \\\"exptime %3fms\\\"%e_test_ms[i-2],\\n prev_mean[chan],\\n INCREASING_THR*100)\\n assert mean[chan] > prev_mean[chan] * INCREASING_THR, err_msg\",\n \"def sharpen(im):\\n kernel = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]])\\n im = cv2.filter2D(im, -1, kernel)\\n return im\",\n \"def surf_bright(im, coord, minrad=3.):\\n r = minrad\\n slist = []\\n while r < 80:\\n aperture = CircularAperture(coord, r=r)\\n phot_tab = aperture_photometry(im, aperture)\\n s = phot_tab['aperture_sum']\\n sb = s/(np.pi * r**2)\\n print(sb)\\n r += 1\",\n \"def expose(self, cmd, expTime, expType):\\n\\n if not expType:\\n expType = 'test'\\n if cmd:\\n cmd.inform('exposureState=\\\"exposing\\\"')\\n if expType not in ('bias', 'test') and expTime > 0:\\n time.sleep(expTime + self._exposureOverheadTime())\\n\\n if cmd:\\n cmd.inform('exposureState=\\\"reading\\\"')\\n\\n f = pyfits.open('/home/chyan/mhs/data/mcs/schmidt_fiber_snr400_rmod71.fits')\\n image = f[0].data\\n # image = numpy.random.normal(self.biasLevel,\\n # scale=self.readNoise,\\n # size=self.imageSize).astype('u2')\\n\\n if expType != 'test':\\n time.sleep(self._readoutTime())\\n return image\",\n \"def sharpen(image_path, factor=3):\\n BasicTransform.convert_image(image_path)\\n\\n with Image.open(image_path) as img:\\n filter = ImageEnhance.Sharpness(img)\\n new_image = filter.enhance(factor)\\n new_image.save(image_path)\",\n \"def expand_slicer_aperture(system):\\n\\n # First of all, we need to find the Surface Number for the IMAGE SLICER\\n N_surfaces = system.LDE.NumberOfSurfaces\\n surface_names = {} # A dictionary of surface number -> surface comment\\n for k in np.arange(1, N_surfaces):\\n surface_names[k] = system.LDE.GetSurfaceAt(k).Comment\\n # find the Slicer surface number\\n try:\\n # The naming convention for this surface has changed. Not the same for Nominal Design as Monte Carlos\\n slicer_num = list(surface_names.keys())[list(surface_names.values()).index('Slicer Mirror')]\\n except ValueError:\\n slicer_num = list(surface_names.keys())[list(surface_names.values()).index('IFU ISA')]\\n slicer = system.LDE.GetSurfaceAt(slicer_num)\\n\\n # Read Current Aperture Settings\\n apt_type = slicer.ApertureData.CurrentType\\n # print(\\\"Aperture type: \\\", apt_type)\\n if apt_type == 4: # 4 is Rectangular aperture\\n current_apt_sett = slicer.ApertureData.CurrentTypeSettings\\n # print(\\\"Current Settings:\\\")\\n x0 = current_apt_sett._S_RectangularAperture.XHalfWidth\\n y0 = current_apt_sett._S_RectangularAperture.YHalfWidth\\n # If the Y aperture hasn't been changed already, we change it here to 999 mm to get all rays through\\n if y0 != 999:\\n # Change Settings\\n aperture_settings = slicer.ApertureData.CreateApertureTypeSettings(\\n constants.SurfaceApertureTypes_RectangularAperture)\\n aperture_settings._S_RectangularAperture.XHalfWidth = x0\\n aperture_settings._S_RectangularAperture.YHalfWidth = 999\\n slicer.ApertureData.ChangeApertureTypeSettings(aperture_settings)\\n\\n current_apt_sett = slicer.ApertureData.CurrentTypeSettings\\n # Notify that we have successfully modified the aperture\\n print(\\\"Changing aperture of surface: \\\", slicer.Comment)\\n print(\\\"New Settings:\\\")\\n print(\\\"X_HalfWidth = %.2f\\\" % current_apt_sett._S_RectangularAperture.XHalfWidth)\\n print(\\\"Y_HalfWidth = %.2f\\\" % current_apt_sett._S_RectangularAperture.YHalfWidth)\\n\\n return\",\n \"def apply_sharpening_on(image):\\n # Create kernel\\n kernel = np.array([[0, -1, 0],\\n [-1, 5, -1],\\n [0, -1, 0]])\\n\\n # Sharpen image\\n sharp_image = cv2.filter2D(image, -1, kernel)\\n return sharp_image\",\n \"def on_run(self):\\n self.set_illumination({'mode': 'breathe'})\",\n \"def main():\\n NAME = os.path.basename(__file__).split(\\\".\\\")[0]\\n\\n with its.device.ItsSession() as cam:\\n\\n props = cam.get_camera_properties()\\n\\n white_level = float(props['android.sensor.info.whiteLevel'])\\n black_levels = props['android.sensor.blackLevelPattern']\\n idxs = its.image.get_canonical_cfa_order(props)\\n black_levels = [black_levels[i] for i in idxs]\\n\\n # Expose for the scene with min sensitivity\\n sens_min, sens_max = props['android.sensor.info.sensitivityRange']\\n s_ae,e_ae,awb_gains,awb_ccm,_ = cam.do_3a(get_results=True)\\n s_e_prod = s_ae * e_ae\\n\\n # Make the image brighter since the script looks at linear Bayer\\n # raw patches rather than gamma-encoded YUV patches (and the AE\\n # probably under-exposes a little for this use-case).\\n s_e_prod *= 2\\n\\n # Capture raw frames across the full sensitivity range.\\n NUM_SENS_STEPS = 15\\n sens_step = int((sens_max - sens_min - 1) / float(NUM_SENS_STEPS))\\n reqs = []\\n sens = []\\n for s in range(sens_min, sens_max, sens_step):\\n e = int(s_e_prod / float(s))\\n req = its.objects.manual_capture_request(s, e)\\n req[\\\"android.colorCorrection.transform\\\"] = \\\\\\n its.objects.float_to_rational(awb_ccm)\\n req[\\\"android.colorCorrection.gains\\\"] = awb_gains\\n reqs.append(req)\\n sens.append(s)\\n\\n caps = cam.do_capture(reqs, cam.CAP_RAW)\\n\\n # A list of the (x,y) coords of the center pixel of a collection of\\n # patches of a color checker chart. Each patch should be uniform,\\n # however the actual color doesn't matter. Note that the coords are\\n # relative to the *converted* RGB image, which is 1/2 x 1/2 of the\\n # full size; convert back to full.\\n img = its.image.convert_capture_to_rgb_image(caps[0], props=props)\\n patches = its.image.get_color_checker_chart_patches(img, NAME+\\\"_debug\\\")\\n patches = [(2*x,2*y) for (x,y) in sum(patches,[])]\\n\\n lines = []\\n for (s,cap) in zip(sens,caps):\\n # For each capture, compute the mean value in each patch, for each\\n # Bayer plane; discard patches where pixels are close to clamped.\\n # Also compute the variance.\\n CLAMP_THRESH = 0.2\\n planes = its.image.convert_capture_to_planes(cap, props)\\n points = []\\n for i,plane in enumerate(planes):\\n plane = (plane * white_level - black_levels[i]) / (\\n white_level - black_levels[i])\\n for j,(x,y) in enumerate(patches):\\n tile = plane[y/2-16:y/2+16:,x/2-16:x/2+16:,::]\\n mean = its.image.compute_image_means(tile)[0]\\n var = its.image.compute_image_variances(tile)[0]\\n if (mean > CLAMP_THRESH and mean < 1.0-CLAMP_THRESH):\\n # Each point is a (mean,variance) tuple for a patch;\\n # for a given ISO, there should be a linear\\n # relationship between these values.\\n points.append((mean,var))\\n\\n # Fit a line to the points, with a line equation: y = mx + b.\\n # This line is the relationship between mean and variance (i.e.)\\n # between signal level and noise, for this particular sensor.\\n # In the DNG noise model, the gradient (m) is \\\"S\\\", and the offset\\n # (b) is \\\"O\\\".\\n points.sort()\\n xs = [x for (x,y) in points]\\n ys = [y for (x,y) in points]\\n m,b = numpy.polyfit(xs, ys, 1)\\n lines.append((s,m,b))\\n print s, \\\"->\\\", m, b\\n\\n # TODO: Clean up these checks (which currently fail in some cases).\\n # Some sanity checks:\\n # * Noise levels should increase with brightness.\\n # * Extrapolating to a black image, the noise should be positive.\\n # Basically, the \\\"b\\\" value should correspnd to the read noise,\\n # which is the noise level if the sensor was operating in zero\\n # light.\\n #assert(m > 0)\\n #assert(b >= 0)\\n\\n # Draw a plot.\\n pylab.plot(xs, ys, 'r')\\n pylab.plot([0,xs[-1]],[b,m*xs[-1]+b],'b')\\n matplotlib.pyplot.savefig(\\\"%s_plot_mean_vs_variance.png\\\" % (NAME))\\n\\n # Now fit a line across the (m,b) line parameters for each sensitivity.\\n # The gradient (m) params are fit to the \\\"S\\\" line, and the offset (b)\\n # params are fit to the \\\"O\\\" line, both as a function of sensitivity.\\n gains = [d[0] for d in lines]\\n Ss = [d[1] for d in lines]\\n Os = [d[2] for d in lines]\\n mS,bS = numpy.polyfit(gains, Ss, 1)\\n mO,bO = numpy.polyfit(gains, Os, 1)\\n\\n # Plot curve \\\"O\\\" as 10x, so it fits in the same scale as curve \\\"S\\\".\\n pylab.plot(gains, [10*o for o in Os], 'r')\\n pylab.plot([gains[0],gains[-1]],\\n [10*mO*gains[0]+10*bO, 10*mO*gains[-1]+10*bO], 'b')\\n pylab.plot(gains, Ss, 'r')\\n pylab.plot([gains[0],gains[-1]], [mS*gains[0]+bS, mS*gains[-1]+bS], 'b')\\n matplotlib.pyplot.savefig(\\\"%s_plot_S_O.png\\\" % (NAME))\\n\\n print \\\"\\\"\\\"\\n /* Generated test code to dump a table of data for external validation\\n * of the noise model parameters.\\n */\\n #include <stdio.h>\\n #include <assert.h>\\n double compute_noise_model_entry_S(int sens);\\n double compute_noise_model_entry_O(int sens);\\n int main(void) {\\n int sens;\\n for (sens = %d; sens <= %d; sens += 100) {\\n double o = compute_noise_model_entry_O(sens);\\n double s = compute_noise_model_entry_S(sens);\\n printf(\\\"%%d,%%lf,%%lf\\\\\\\\n\\\", sens, o, s);\\n }\\n return 0;\\n }\\n\\n /* Generated functions to map a given sensitivity to the O and S noise\\n * model parameters in the DNG noise model.\\n */\\n double compute_noise_model_entry_S(int sens) {\\n double s = %e * sens + %e;\\n return s < 0.0 ? 0.0 : s;\\n }\\n double compute_noise_model_entry_O(int sens) {\\n double o = %e * sens + %e;\\n return o < 0.0 ? 0.0 : o;\\n }\\n \\\"\\\"\\\"%(sens_min,sens_max,mS,bS,mO,bO)\",\n \"def grass_drass():\",\n \"def flat(s='flat'):\\n s = s.strip()[:80] #truncate to 80 char to fit in FITS header\\n print camera.SetShutter(0)\\n camera.status.imgtype = 'FLAT'\\n camera.status.object = s\\n camera.status.update()\",\n \"def __call__(self, frame_num):\\n # propagate and set the density\\n self.img.set_array(\\n np.abs(self.quant_sys.propagate(10)) ** 2\\n )\\n return self.img,\",\n \"def opd_dither(cfg):\\n \\n setpoint_new = pi.getINDI('PLC.UBCSettings.PLSetpoint')\\n file_number = pi.getINDI('NOMIC.CamInfo.FIndex') # Get initial file number\\n offsets = np.array(cfg['nomic_dither_opd_pattern']) * 5.0 * 180.0 / np.pi # input in rad at 11um, but commandet offsets in deg in K band\\n pi.setINDI('NOMIC.EditFITS.Keyword=spdthpos;Value=0.0;Comment=setpoint dither position (offset from nominal setpoint) in rad')\\n while True:\\n for i_step in range(0, len(cfg['nomic_dither_opd_pattern'])):\\n file_number = file_number + cfg['nomic_dither_opd_ndits'][i_step]\\n try:\\n pi.evalINDI ('\\\"NOMIC.CamInfo.FIndex\\\" >= %d' % file_number, timeout=900) # wait for cfg['nomic_dither_opd_ndits'][i] new files to arrive\\n except:\\n info('OPD dither offset timed out (more than 15 min since last offset)')\\n print(' or was interrupted.')\\n print(' Make sure to restart OPD dither pattern.')\\n return()\\n setpoint_old = pi.getINDI('PLC.UBCSettings.PLSetpoint') # ask for current setpoint\\n if (setpoint_old - setpoint_new) > 2.9: # if expected setpoint is more than ~0.01 rad (at 11um) different from current setpoint\\n info('Setpoint has changed between two dither positions.')\\n setpoint_new = setpoint_old + offsets[i_step] # determine new setpoint\\n pi.setINDI('NOMIC.EditFITS.Keyword=spdthpos;Value=' + str(np.sum(offsets[:i_step+1])) + ';Comment=setpoint dither position (offset from nominal setpoint) in rad')\\n pi.setINDI('PLC.PLSetpoint.PLSetpoint=' + str(setpoint_new) + ';forNAC=0') # send a dither offset\",\n \"def farm(w,h,status='harvest',loops=1):\\n h1 = int(h/2) # var to get seeds from first half (or fewer) of rows\\n food_key = 5 # hotbar key for food\\n dirt_place_time = 4.5\\n walk_time = 0.33\\n wait_time = 0.7\\n grow_time = 540 # time for plants to grow = 600s - (time to log out & in) \\n \\n ctrl.resetCamera('down')\\n for loop in range(loops):\\n for y in range(h):\\n for x in range(w):\\n # checks if char is hungry before moving, & eats food on food_key\\n if img_obj.isHungry():\\n ctrl.eatFood(key=food_key)\\n if status == 'harvest':\\n # picks up farm patch, loot seeds, places farm patch, continues \\n if y < h1: \\n ctrl.selectOption('down')\\n time.sleep(dirt_place_time) # takes 3 sec + more time due to server lag\\n ctrl.selectOption('right')\\n ctrl.loot() \\n \\n ctrl.walk('down', walk_time * 2, jump=True)\\n ctrl.selectOption('down')\\n ctrl.clickLMB()\\n time.sleep(dirt_place_time)\\n \\n ctrl.walk('up', walk_time, jump=True)\\n \\n else:\\n ctrl.selectOption('right')\\n for i in range(12): # takes 5 seconds to harvest, in 6 seconds, f key is pressed 12 times\\n ctrl.loot()\\n time.sleep(.5)\\n \\n time.sleep(wait_time) # delay to make sure it jumps to the next patch\\n # plants seeds - assumes char is holding seeds\\n ctrl.selectOption('right')\\n for i in range(12): # takes 5 seconds to harvest, in 5.5 seconds, f key is pressed 11 times\\n ctrl.loot()\\n time.sleep(.5)\\n time.sleep(wait_time)\\n \\n # moves char to next farm patch\\n if x != (w-1): # if not on last farm patch of row\\n if y % 2 == 0:\\n direction = 'left'\\n else:\\n direction = 'right'\\n ctrl.walk(direction, walk_time, jump=True)\\n time.sleep(wait_time) # delay for server lag\\n \\n # moves char up to next row if not on last row\\n if y != (h-1):\\n ctrl.walk('up', walk_time, jump=True)\\n \\n # final loot loop to get remaining items\\n # for i in range(10):\\n # ctrl.loot()\\n # time.sleep(.5)\\n \\n # returns char to bottom right farm patch\\n if (h) % 2 != 0: # if height is odd, move char to right side\\n for x in range(w-1):\\n ctrl.walk('right', walk_time, jump=True)\\n time.sleep(wait_time)\\n for y in range(h-1):\\n ctrl.walk('down', walk_time * 2, jump=True)\\n time.sleep(wait_time)\\n \\n # returns to lobby, waits for plants to grow, logs in\\n ctrl.returnToLobby()\\n time.sleep(grow_time)\\n ctrl.enterGame()\\n # resets camera to be aligned facing North as camera will always be pointed North after logging in\\n ctrl.walk('up', .1, jump=True) \\n time.sleep(wait_time)\\n ctrl.walk('down', .1, jump=True)\\n \\n ctrl.resetCamera('down')\\n # when relogging, char is displaced sometimes, this checks if field is selected, if not it'll try to find it, if that fails the program exits\\n if not (img_obj.checkObjTitle('field')):\\n ctrl.walk('left', walk_time, jump=True)\\n if not (img_obj.checkObjTitle('field')):\\n ctrl.walk('up', walk_time, jump=True)\\n if not (img_obj.checkObjTitle('field')):\\n break\",\n \"def expose(self):\\n\\n ## Determine type of exposure (exp, series, stack)\\n exptype = str(self.exptypeComboBox.currentText())\\n mode = self.modedict[exptype]\\n\\n ## Get exposure parameters\\n if mode == \\\"bias\\\":\\n exptime = 0.0\\n else:\\n exptime = self.exptimeSpinBox.value()\\n imcount = self.imstackSpinBox.value()\\n seqnum = self.imnumSpinBox.value()\\n mintime = self.minexpSpinBox.value()\\n maxtime = self.maxexpSpinBox.value()\\n step = self.tstepSpinBox.value()\\n\\n ## Determine filter kwargs\\n if self.filterToggleButton.isChecked():\\n kwargs = {'filter_name' : str(self.filterComboBox.currentText())}\\n else:\\n kwargs = {'monowl' : self.monoSpinBox.value()}\\n\\n if self.testimCheckBox.isChecked():\\n title = 'test'\\n else:\\n title = str(self.imtitleLineEdit.text())\\n\\n ## Build filepath\\n filepath = os.path.join(str(self.imfilenameLineEdit.text()),title)\\n \\n ## Check if single exposure\\n if exptype in [\\\"Exposure\\\", \\\"Dark\\\", \\\"Bias\\\"]:\\n\\n ## Perform exposure\\n self.logger.info(\\\"Starting {0}s {1} image.\\\".format(exptime, exptype))\\n self.image_start.emit(1)\\n\\n try:\\n filename = exposure.im_acq(mode, filepath, exptime, seqnum, **kwargs)\\n self.image_taken.emit(1)\\n except subprocess.CalledProcessError:\\n self.logger.exception(\\\"Error in executable {0}_acq. Image not taken.\\\".format(mode))\\n except OSError:\\n self.logger.exception(\\\"Executable {0}_acq not found. Image not taken\\\".format(mode))\\n except IOError:\\n self.logger.exception(\\\"File already exits. Image not taken.\\\")\\n else:\\n self.logger.info(\\\"Exposure {0} finished successfully.\\\".format(filename))\\n self.seqnum_inc.emit(seqnum)\\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename,\\n '-zoom', 'to', 'fit', '-cmap', 'b'])\\n\\n ## Check if a stack of exposures of same type\\n elif exptype in [\\\"Exposure Stack\\\", \\\"Dark Stack\\\", \\\"Bias Stack\\\"]:\\n\\n total = seqnum + imcount\\n self.logger.info(\\\"Starting {0}s {1} stack.\\\".format(exptime, exptype))\\n self.image_start.emit(imcount)\\n\\n try:\\n for i in range(seqnum, total):\\n self.logger.info(\\\"Starting image {0} of {1}.\\\".format(i+1-seqnum, imcount))\\n filename = exposure.im_acq(mode, filepath, exptime, i, **kwargs)\\n self.logger.info(\\\"Exposure {0} finished successfully.\\\".format(filename))\\n self.image_taken.emit(i+1-seqnum)\\n self.seqnum_inc.emit(i)\\n except subprocess.CalledProcessError:\\n self.logger.exception(\\\"Error in executable {0}_acq. Image not taken.\\\".format(mode))\\n except OSError:\\n self.logger.exception(\\\"Executable {0}_acq not found. Image not taken.\\\".format(mode))\\n except IOError:\\n self.logger.exception(\\\"File already exists. Image not taken.\\\")\\n else:\\n self.logger.info(\\\"Exposure stack finished successfully.\\\")\\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename, '-zoom', 'to', 'fit', '-cmap', 'b'])\\n \\n ## Check if a series of exposures of increase exposure time\\n elif exptype in [\\\"Exposure Series\\\", \\\"Dark Series\\\"]:\\n\\n ## Parameter checks\\n if mintime > maxtime:\\n self.logger.warning(\\\"Minimum time must be less than Maximum time. Series not started.\\\")\\n return\\n elif step <= 0:\\n self.logger.warning(\\\"Time step must be greater than 0. Series not started.\\\")\\n return\\n\\n ## Construct array of exposure times\\n t = mintime\\n time_array = []\\n while t <= maxtime:\\n time_array.append(t)\\n t += step\\n \\n ## Perform series\\n self.logger.info(\\\"Starting {0} series with mintime {1}, maxtime {2}, and step {3}.\\\".format(exptype, mintime, maxtime, step))\\n self.image_start.emit(len(time_array))\\n \\n try:\\n for i, time in enumerate(time_array):\\n self.logger.info(\\\"Starting {0}s {1} image.\\\".format(time, mode))\\n filename = exposure.im_acq(mode, filepath, time, seqnum, **kwargs)\\n self.logger.info(\\\"Exposure {0} finished successfully.\\\".format(filename))\\n self.image_taken.emit(i+1)\\n except subprocess.CalledProcessError:\\n self.logger.exception(\\\"Error in executable {0}_acq. Image not taken.\\\".format(mode))\\n except OSError:\\n self.logger.exception(\\\"Executable {0}_acq not found. Image not taken.\\\".format(mode))\\n except IOError:\\n self.logger.exception(\\\"File already exists. Image not taken.\\\")\\n else:\\n self.logger.info(\\\"Exposure series finished successfully.\\\")\\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename, '-zoom', 'to', 'fit', '-cmap', 'b'])\\n self.seqnum_inc.emit(seqnum)\",\n \"def measure_flats(det, shutter, quantity, samStage, samPos):\\n priorPosition = samStage.position\\n yield from set_white_frame()\\n yield from bps.mv(\\n samStage, samPos,\\n shutter, \\\"open\\\")\\n yield from _acquire_n_frames(det, quantity)\\n yield from bps.mv(samStage, priorPosition)\",\n \"def plasma_dose(self, width, power):\\n print('Start plasma dose.')\\n self.seren.settings['set_forward_power'] = power\\n self.seren.settings['RF_enable'] = True\\n time.sleep(width)\\n self.seren.settings['RF_enable'] = False\\n self.seren.settings['set_forward_power'] = 0\\n print('Plasma dose finished.')\",\n \"def strut(self):\\n self.fwd(left=50, right=50)\\n for x in range(2):\\n self.servo(1000)\\n time.sleep(.1) \\n self.servo(1500) # Look Straight\\n time.sleep(1)\\n self.servo(2000)\\n time.sleep(.1)\\n self.servo(1500)\",\n \"def dark(s='dark'):\\n s = s.strip()[:80] #truncate to 80 char to fit in FITS header\\n print camera.SetShutter(2)\\n camera.status.imgtype = 'DARK'\\n camera.status.object = s\\n camera.status.update()\",\n \"def illustrate_sift(self):\\n\\n print 'passe illustrate sift in'\\n\\n work_dir = self.work_dir\\n draw_keys_oriented(work_dir+'keys_im0.txt',\\n work_dir+'input_0.orig.png',\\n work_dir+'keys_im0.png')\\n draw_keys_oriented(work_dir+'keys_im1.txt',\\n work_dir+'input_1.orig.png',\\n work_dir+'keys_im1.png')\\n print 'passe illustrate sift in'\\n\\n for im in ['0','1']:\\n for kypts in ['NES', 'DoGSoftThresh', 'ExtrInterp',\\n 'ExtrInterpREJ', 'DoGThresh', 'OnEdgeResp',\\n 'OnEdgeRespREJ']:\\n draw_keys(work_dir+'extra_'+kypts+'_im'+im+'.txt',\\n work_dir+'input_'+im+'.orig.png',\\n work_dir+'extra_'+kypts+'_im'+im+'.png') \\n\\n draw_keys_oriented(work_dir+'extra_OriAssignedMULT_im'+im+'.txt',\\n work_dir+'input_'+im+'.orig.png',\\n work_dir+'extra_OriAssignedMULT_im'+im+'.png')\\n\\n return 1\",\n \"def smooth_stitch(*, input_dir, output_dir):\\n image_paths = glob(os.path.join(input_dir, \\\"*.tif\\\"))\\n if not image_paths:\\n raise RuntimeError(\\\"%s does not contain any .tif file\\\" % (input_dir))\\n\\n # Get the profile and affine of some image as template for output image\\n first_image = image_paths[0]\\n with rasterio.open(first_image) as src:\\n profile = src.profile.copy()\\n src_res = src.res\\n chip_size = src.width\\n assert src.width == src.height\\n\\n with tempfile.TemporaryDirectory() as tmpdir:\\n tmp_image_paths = generate_spline_window_chips(\\n image_paths=image_paths, output_dir=tmpdir\\n )\\n\\n # Get bounds from all images and build R-Tree index\\n idx, (dst_w, dst_s, dst_e, dst_n) = build_bounds_index(tmp_image_paths)\\n\\n # Get affine transform for complete bounds\\n logger.info(\\\"Output bounds: %r\\\", (dst_w, dst_s, dst_e, dst_n))\\n output_transform = Affine.translation(dst_w, dst_n)\\n logger.info(\\\"Output transform, before scaling: %r\\\", output_transform)\\n\\n output_transform *= Affine.scale(src_res[0], -src_res[1])\\n logger.info(\\\"Output transform, after scaling: %r\\\", output_transform)\\n\\n # Compute output array shape. We guarantee it will cover the output\\n # bounds completely. We need this to build windows list later.\\n output_width = int(math.ceil((dst_e - dst_w) / src_res[0]))\\n output_height = int(math.ceil((dst_n - dst_s) / src_res[1]))\\n\\n # Set width and height for output chips, and other attributes\\n profile.update(width=chip_size, height=chip_size, tiled=True)\\n\\n windows = list(\\n sliding_windows(chip_size, width=output_width, height=output_height)\\n )\\n logger.info(\\\"Num. windows: %d\\\", len(windows))\\n\\n for win, (i, j) in tqdm(windows):\\n # Get window affine transform and bounds\\n win_transform = rasterio.windows.transform(win, output_transform)\\n win_bounds = rasterio.windows.bounds(win, output_transform)\\n\\n # Get chips that intersect with window\\n intersect_chip_paths = [\\n tmp_image_paths[i] for i in idx.intersection(win_bounds)\\n ]\\n\\n if intersect_chip_paths:\\n # Merge them with median method\\n img = merge_chips(intersect_chip_paths, win_bounds=win_bounds)\\n\\n # Write output chip\\n profile.update(transform=win_transform)\\n output_path = os.path.join(output_dir, f\\\"{i}_{j}.tif\\\")\\n\\n os.makedirs(output_dir, exist_ok=True)\\n with rasterio.open(output_path, \\\"w\\\", **profile) as dst:\\n for i in range(img.shape[0]):\\n dst.write(img[i, :, :], i + 1)\",\n \"def WarpOpen(wn, fn, ms = 15, Wres = 300, Hres = 300, M = 20, k_spr = 10, dt = 0.0125):\\n MSG(\\\"WarpOpen\\\")\\n cv2.namedWindow(wn)\\n img = cv2.imread(fn,1)\\n img = cv2.resize(img, (Wres,Hres))\\n (h,w,cols) = img.shape\\n L0 = list(img.flatten())\\n warp.open(L0, M, w, h)\\n warp.set_k_spr(k_spr)\\n warp.set_dt(dt)\\n return\",\n \"def swarpfilter(d, dir, directory, images, keys, filter, lamp, camera, done, output, type):\\n filt = images.files_filtered(FWINAME=filter, FLSPECTR=lamp, CAMNAME=camera, HISTORY=done)\\n files = [d + x for x in filt.tolist()]\\n print(files)\\n if files:\\n swarp(files, output=directory + '/' + output + '.fits', celestial_type=type)\",\n \"def punched(self):\\n if not self.dizzy:\\n self.dizzy = 1\\n self.original = self.image\\n Chimp.count_punch += 1\",\n \"def expose_test(self):\\n with self.lock:\\n self.dark = 1\\n self.tstart = time.time()\\n self.timestamp = time.strftime(\\\"%Y-%m-%dT%H:%M:%S\\\", time.localtime(self.tstart))\\n imagesize = (self.expArea[3] - self.expArea[1],\\n self.expArea[2] - self.expArea[0])\\n self.data = np.ones(shape=imagesize, dtype=np.uint16)\\n self.tend = time.time()\",\n \"def capture(self, channel: LC):\\n\\n # check if gain information is available, if not, update first\\n if \\\"d2d\\\" not in self.config:\\n self.setup_d2d()\\n self.update()\\n\\n # turn on the light\\n self.light_control(channel, 1)\\n\\n # assemble the terminal command\\n path_to_bright = os.getcwd() + \\\"/cam/tmp/bright.bmp\\\"\\n path_to_dark = os.getcwd() + \\\"/cam/tmp/dark.bmp\\\"\\n gain = self.config[\\\"d2d\\\"][channel][\\\"analog-gain\\\"] * self.config[\\\"d2d\\\"][channel][\\\"digital-gain\\\"]\\n\\n photo_cmd = \\\"raspistill -e bmp -w {} -h {} -ss {} -t 1000 -awb off -awbg {},{} -ag {} -dg {}\\\".format(self.settings.resolution[0], self.settings.resolution[1], self.settings.shutter_speed[channel], self.config[\\\"wb\\\"][channel][\\\"r\\\"], self.config[\\\"wb\\\"][channel][\\\"b\\\"], self.config[\\\"d2d\\\"][channel][\\\"analog-gain\\\"], self.config[\\\"d2d\\\"][channel][\\\"digital-gain\\\"])\\n\\n # run command and take bright and dark picture\\n # start the bright image capture by spawning a clean process and executing the command, then waiting for the q\\n p = mp.Process(target=photo_worker, args=(photo_cmd + \\\" -o {}\\\".format(path_to_bright),))\\n try:\\n p.start()\\n p.join()\\n except OSError:\\n d_print(\\\"Could not start child process, out of memory\\\", 3)\\n return (None, 0)\\n # turn off the light\\n self.light_control(channel, 0)\\n # start the dark image capture by spawning a clean process and executing the command, then waiting for the q\\n p = mp.Process(target=photo_worker, args=(photo_cmd + \\\" -o {}\\\".format(path_to_dark),))\\n try:\\n p.start()\\n p.join()\\n except OSError:\\n d_print(\\\"Could not start child process, out of memory\\\", 3)\\n return (None, 0)\\n\\n # load the images from file, perform dark frame subtraction and return the array\\n bright = Image.open(path_to_bright)\\n rgb = np.array(bright)\\n if channel != LC.GROWTH:\\n dark = Image.open(path_to_dark)\\n rgb = cv2.subtract(rgb, np.array(dark))\\n\\n # if the time since last update is larger than a day, update the gains after the photo\\n if time.time() - self.config[\\\"d2d\\\"][\\\"timestamp\\\"] > 3600*24:\\n self.update()\\n\\n return (rgb, gain)\",\n \"def _do_expose_loop(self, fitsfile, seconds):\\n log.debug(f\\\"Starting expose loop with {self.max_exposures} exposures\\\")\\n while (self.current_exposure is not None and \\n self.current_exposure < self.max_exposures):\\n self.current_exposure += 1\\n self.Expose(fitsfile, seconds)\\n while self.process and self.process.poll() is None:\\n sleep(5)\\n if not self.process or self.process.returncode != 0:\\n break\\n \\n self.current_exposure = None\\n self.max_exposures = None\",\n \"def continue_with_exposure(self):\\r\\n # Allocate space to give to scan_until_abort, and name the two\\r\\n # rows appropriately.\\r\\n self.data_pair = self.cam.get_new_array(n_images=2)\\r\\n self.pump_probe_data = self.data_pair[0]\\r\\n self.probe_only_data = self.data_pair[1]\\r\\n # Keep track of which image will be updated next\\r\\n self.next_data_has_pump = True\\r\\n\\r\\n # Tell self.thread what to do when the camera has new images\\r\\n self.cam.new_images.connect(self.send_new_images)\\r\\n\\r\\n # Get the current array of wavelengths from cam\\r\\n self.wavelen_arr = self.cam.get_wavelen_array()\\r\\n\\r\\n # Queue a call to cam.scan_until_abort\\r\\n self.startAcq.emit(self.data_pair)\\r\\n\\r\\n # Tell listeners (plotting widgets) to start displaying data too\\r\\n self.startDisplay.emit()\",\n \"def fire_smelter(self):\\n # Get the smelter\\n screenshot = utils.take_screenshot()\\n forge = screenshot[152:168, 168:184]\\n\\n # Check if the cold forge exists\\n result = cv2.matchTemplate(forge, self.cold_forge_template, cv2.TM_CCORR_NORMED)\\n max_val = cv2.minMaxLoc(result)[1]\\n\\n # Found cold forge, light it and wait\\n if max_val > 0.9:\\n pyautogui.moveTo(192, 159, 0.15)\\n pyautogui.doubleClick()\\n sleep(1.5)\",\n \"def spectate(self):\\n pass\",\n \"def __init__(self, slit_width_xaxis, slit_height_zaxis):\\n super(SwScreen, self).__init__()\\n self.sw = self.create_instance()\\n\\n self.set_output_files(fwrite=0, f_angle=0) #write all, TODO: remove\\n\\n n_screen = 1\\n i_screen = np.array([1, 0, 0, 0, 0, 0, 0, 0, 0, 0])\\n i_abs = np.zeros(10)\\n i_slit = np.zeros(10)\\n i_stop = np.zeros(10)\\n k_slit = np.zeros(10)\\n thick = np.zeros(10)\\n file_abs = np.array(['', '', '', '', '', '', '', '', '', ''])\\n rx_slit = np.zeros(10)\\n rz_slit = np.zeros(10)\\n sl_dis = np.zeros(10)\\n file_src_ext = np.array(['', '', '', '', '', '', '', '', '', ''])\\n cx_slit = np.zeros(10)\\n cz_slit = np.zeros(10)\\n\\n i_abs[0] = 0 # NO ABSORPTION\\n i_slit[0] = 0 # APERTURING\\n i_stop[0] = 0 # SLIT\\n k_slit[0] = 0 # RECTANGULAR\\n\\n rx_slit[0] = slit_width_xaxis\\n rz_slit[0] = slit_height_zaxis\\n cx_slit[0] = 0.0\\n cz_slit[0] = 0.0\\n\\n self.sw._oe.set_screens(n_screen,\\n i_screen,\\n i_abs,\\n sl_dis,\\n i_slit,\\n i_stop,\\n k_slit,\\n thick,\\n file_abs,\\n rx_slit,\\n rz_slit,\\n cx_slit,\\n cz_slit,\\n file_src_ext)\",\n \"def test_healpix_to_point_source_cuts(healpix_disk_new):\\n skyobj = healpix_disk_new\\n skyobj.healpix_to_point()\\n skyobj.select(max_brightness=0.9 * skyobj.stokes[0].max())\",\n \"def skyPixelsHPX(self,i, d,feedindex):\\n\\n # We store all the pointing information\\n x = d['level1/spectrometer/pixel_pointing/pixel_ra'][feedindex,:][:,self.select_mask]\\n x = x[:,0:self.datasizes[i]].flatten()\\n y = d['level1/spectrometer/pixel_pointing/pixel_dec'][feedindex,:][:,self.select_mask]\\n y = y[:,0:self.datasizes[i]].flatten()\\n \\n # convert to Galactic\\n rot = hp.rotator.Rotator(coord=['C','G'])\\n gb, gl = rot((90-y)*np.pi/180., x*np.pi/180.)\\n\\n pixels = hp.ang2pix(self.nside, gb, gl)\\n return pixels\",\n \"def setup():\\n wcs = galsim.TanWCS(\\n galsim.AffineTransform(0.26, 0.05, -0.08, -0.24, galsim.PositionD(1024,1024)),\\n #galsim.AffineTransform(0.26, 0., 0., 0.26, galsim.PositionD(1024,1024)),\\n galsim.CelestialCoord(5 * galsim.arcmin, -25 * galsim.degrees)\\n )\\n\\n # Make the image (copied from test_single_image in test_simple.py)\\n image = galsim.Image(2048, 2048, wcs=wcs)\\n\\n # Where to put the stars.\\n x_list = [ 123.12, 345.98, 567.25, 1094.94, 924.15, 1532.74, 1743.11, 888.39, 1033.29, 1409.31 ]\\n y_list = [ 345.43, 567.45, 1094.32, 924.29, 1532.92, 1743.83, 888.83, 1033.19, 1409.20, 123.11 ]\\n\\n # Draw a Gaussian PSF at each location on the image.\\n sigma = 1.3\\n g1 = 0.23\\n g2 = -0.17\\n du = 0.09 # in arcsec\\n dv = -0.07\\n flux = 123.45\\n psf = galsim.Gaussian(sigma=sigma).shear(g1=g1, g2=g2).shift(du,dv) * flux\\n for x, y in zip(x_list, y_list):\\n bounds = galsim.BoundsI(int(x-31), int(x+32), int(y-31), int(y+32))\\n offset = galsim.PositionD(x-int(x)-0.5, y-int(y)-0.5)\\n psf.drawImage(image=image[bounds], method='no_pixel', offset=offset)\\n image.addNoise(galsim.GaussianNoise(rng=galsim.BaseDeviate(1234), sigma=1e-6))\\n\\n # Write out the image to a file\\n image_file = os.path.join('output','test_stats_image.fits')\\n image.write(image_file)\\n\\n # Write out the catalog to a file\\n dtype = [ ('x','f8'), ('y','f8') ]\\n data = np.empty(len(x_list), dtype=dtype)\\n data['x'] = x_list\\n data['y'] = y_list\\n cat_file = os.path.join('output','test_stats_cat.fits')\\n fitsio.write(cat_file, data, clobber=True)\",\n \"def sharpen(img, ker = (9,9), sigX=10.0):\\n gaus = cv2.GaussianBlur(img, ker, sigX)\\n unsharp = cv2.addWeighted(img, 1.5, gaus, -0.5, 0, img)\\n return unsharp\",\n \"def exposure(frameType, expTime):\\n\\n blobEvent.clear() \\n\\n # set the specified frame type\\n if frameType.lower() == 'light':\\n ccd_frame[0].s = PyIndi.ISS_ON\\n ccd_frame[1].s = PyIndi.ISS_OFF\\n ccd_frame[2].s = PyIndi.ISS_OFF\\n ccd_frame[3].s = PyIndi.ISS_OFF \\n indiclient.sendNewSwitch(ccd_frame)\\n elif frameType.lower() == 'bias':\\n ccd_frame[0].s = PyIndi.ISS_OFF\\n ccd_frame[1].s = PyIndi.ISS_ON\\n ccd_frame[2].s = PyIndi.ISS_OFF\\n ccd_frame[3].s = PyIndi.ISS_OFF \\n indiclient.sendNewSwitch(ccd_frame)\\n elif frameType.lower() == 'dark':\\n ccd_frame[0].s = PyIndi.ISS_OFF\\n ccd_frame[1].s = PyIndi.ISS_OFF\\n ccd_frame[2].s = PyIndi.ISS_ON\\n ccd_frame[3].s = PyIndi.ISS_OFF \\n indiclient.sendNewSwitch(ccd_frame)\\n elif frameType.lower() == 'flat':\\n ccd_frame[0].s = PyIndi.ISS_OFF\\n ccd_frame[1].s = PyIndi.ISS_OFF\\n ccd_frame[2].s = PyIndi.ISS_OFF\\n ccd_frame[3].s = PyIndi.ISS_ON \\n indiclient.sendNewSwitch(ccd_frame)\\n\\n # set the value for the next exposure\\n ccd_exposure[0].value=expTime\\n\\n indiclient.sendNewNumber(ccd_exposure)\\n\\n # wait for the exposure\\n blobEvent.wait()\\n\\n for blob in ccd_ccd1:\\n # pyindi-client adds a getblobdata() method to IBLOB item\\n # for accessing the contents of the blob, which is a bytearray in Python\\n image_data=blob.getblobdata()\\n\\n # write the byte array out to a FITS file\\n global imgNum\\n global imgName\\n imgNum += 1\\n fileName = fileDir+'raw-'+str(imgNum).zfill(8)+'.fits'\\n f = open(fileName, 'wb')\\n f.write(image_data)\\n f.close()\\n imgName = fileName\\n \\n return fileName\",\n \"def do_pixels(self):\\n self.do_yurt_pixels()\\n self.do_petal_strip_pixels()\\n self.do_vase_pixels()\",\n \"def main():\\n original = SimpleImage('images/mt-rainier.jpg')\\n original.show()\\n reflected = make_reflected('images/mt-rainier.jpg')\\n reflected.show()\",\n \"def align(): # open EH and fast shutter\\n\\t#marAuxiliary.closeMarShield()\\n\\td2in()\\n\\td3in()\\n\\tsh('o')\",\n \"def cehs():\\n\\tcloseEHShutter()\",\n \"def endexposureloop(self):\\n self.max_exposures = self.current_exposure\",\n \"def camera(self):\\n self.spectrum = self.spectrum\",\n \"def do_stuff(self):\\n self.create_tourism_raster()\",\n \"def flatcombine(dir='Flats/*/dark_subtracted/'):\\n\\n for d in glob(dir):\\n\\n directory = \\\"/\\\".join(d.split('/')[0:2]) + '/swarped'\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n\\n keys = ['OBJECT', 'CAMNAME', 'FWINAME', 'ITIME', 'OBSDATE', 'FLSPECTR', 'HISTORY']\\n images = ImageFileCollection(d, keywords=keys, glob_include='d*.fits')\\n\\n swarpfilter(d, dir, directory, images, keys, filter='H', lamp='on', camera='narrow', \\n done='Dark Subtracted', output='cKNarrowLampOnH', type='PIXEL')\\n swarpfilter(d, dir, directory, images, keys, filter='H', lamp='off', camera='narrow', \\n done='Dark Subtracted', output='cKNarrowLampOffH', type='PIXEL')\\n swarpfilter(d, dir, directory, images, keys, filter='H', lamp='on', camera='wide', done='Dark Subtracted',\\n output='cKWideLampOnH', type='PIXEL')\\n swarpfilter(d, dir, directory, images, keys, filter='H', lamp='off', camera='wide', done='Dark Subtracted',\\n output='cKWideLampOffH', type='PIXEL')\\n swarpfilter(d, dir, directory, images, keys, filter='Ks', lamp='on', camera='narrow', done='Dark Subtracted',\\n output='cKNarrowLampOnKs', type='PIXEL')\\n swarpfilter(d, dir, directory, images, keys, filter='Ks', lamp='off', camera='narrow', done='Dark Subtracted',\\n output='cKNarrowLampOffKs', type='PIXEL')\\n swarpfilter(d, dir, directory, images, keys, filter='Ks', lamp='on', camera='wide', done='Dark Subtracted',\\n output='cKWideLampOnKs', type='PIXEL')\\n swarpfilter(d, dir, directory, images, keys, filter='Ks', lamp='off', camera='wide', done='Dark Subtracted',\\n output='cKWideLampOffKs', type='PIXEL')\\n swarpfilter(d, dir, directory, images, keys, filter='J', lamp='on', camera='narrow', done='Dark Subtracted',\\n output='cNarrowLampOnJ', type='PIXEL')\\n swarpfilter(d, dir, directory, images, keys, filter='J', lamp='off', camera='narrow', done='Dark Subtracted',\\n output='cKNarrowLampOffJ', type='PIXEL')\\n swarpfilter(d, dir, directory, images, keys, filter='J', lamp='on', camera='wide', done='Dark Subtracted',\\n output='cKWideLampOnJ', type='PIXEL')\\n swarpfilter(d, dir, directory, images, keys, filter='J', lamp='off', camera='wide', done='Dark Subtracted',\\n output='cKWideLampOffJ', type='PIXEL')\",\n \"def spilloverEff(freq,fD, FFBW, dB_at_bw, feed_type):\\n theta0 = fD2angle(fD,units='degrees')\\n tt = 0.0\\n dtt = 0.1\\n theta = np.arange(0.0,180.0+dtt,dtt)\\n g = feedPattern(freq, theta, FFBW, dB_at_bw, feed_type)\\n theta = theta*math.pi/180.0\\n\\n # integrate over main beam\\n gmb = np.where(theta < (theta0/2.0)*math.pi/180.0)\\n kern = g[gmb]*np.sin(theta[gmb]) \\n num = integ.trapz(kern,dx=dtt*math.pi/180.0)\\n # integrate over full beam\\n kern = g*np.sin(theta)\\n den = integ.trapz(kern,dx=dtt*math.pi/180.0)\\n \\n n_spill = num/den\\n return n_spill\",\n \"def testSmallSrc(self):\\n fromWcs = afwGeom.makeSkyWcs(\\n crpix=lsst.geom.Point2D(0, 0),\\n crval=lsst.geom.SpherePoint(359, 0, lsst.geom.degrees),\\n cdMatrix=afwGeom.makeCdMatrix(scale=1.0e-8*lsst.geom.degrees),\\n )\\n fromExp = afwImage.ExposureF(afwImage.MaskedImageF(1, 1), fromWcs)\\n\\n toWcs = afwGeom.makeSkyWcs(\\n crpix=lsst.geom.Point2D(0, 0),\\n crval=lsst.geom.SpherePoint(358, 0, lsst.geom.degrees),\\n cdMatrix=afwGeom.makeCdMatrix(scale=1.1e-8*lsst.geom.degrees),\\n )\\n toExp = afwImage.ExposureF(afwImage.MaskedImageF(10, 10), toWcs)\\n\\n warpControl = afwMath.WarpingControl(\\\"lanczos3\\\")\\n # if a bug described in ticket #2441 is present, this will raise an\\n # exception:\\n numGoodPix = afwMath.warpExposure(toExp, fromExp, warpControl)\\n self.assertEqual(numGoodPix, 0)\\n self.assertTrue(np.all(np.isnan(toExp.image.array)))\\n self.assertTrue(np.all(np.isinf(toExp.variance.array)))\\n noDataBitMask = afwImage.Mask.getPlaneBitMask(\\\"NO_DATA\\\")\\n self.assertTrue(np.all(toExp.mask.array == noDataBitMask))\",\n \"def swingCapture(self, pulse, divider=2, count=5):\\n pulse=int(pulse) #make sure is integer\\n cap = cv2.VideoCapture(CAM0, cv2.CAP_DSHOW) # use camera to monitor the motor-mirror assemnbly \\n frames=[] \\n\\n low, high=self._lo_hi_preprocess(CLK_WISE)\\n low_antiClk, high_antiClk=self._lo_hi_preprocess(ANTI_CLK_W) # ret in C byte format already\\n div=divider #divide pulses into groups\\n for _ in range(count): #loop count\\n sub_pulse=pulse//div\\n for __ in range(div): #no of times to cap image\\n for ___ in range(sub_pulse): # 1st clockwise direction\\n self.objdll.USBIO_GPIOWrite(self.id, low, WRITE_EN) #;sleep(self.delay)#disable for highest motor speed\\n self.objdll.USBIO_GPIOWrite(self.id, high, WRITE_EN) #; sleep(self.delay)#disable for highest motor speed\\n ret, frame = cap.read() # Capture frame-by-frame \\n frames.append(frame) # store per group\\n\\n for __ in range(div): \\n for ___ in range(sub_pulse): # 1st anticlockwise direction\\n self.objdll.USBIO_GPIOWrite(self.id, low_antiClk, WRITE_EN) #;sleep(self.delay)#disable for highest motor speed\\n self.objdll.USBIO_GPIOWrite(self.id, high_antiClk, WRITE_EN) #; sleep(self.delay)#disable for highest motor speed\\n ret, frame = cap.read() # Capture frame-by-frame \\n frames.append(frame) # store per group\\n\\n\\n \\n cap.release()\\n cv2.destroyAllWindows()\\n return np.asarray(frames)\",\n \"def phot_aperture(input_file):\\n #set the original directory\\n original_path = os.getcwd()\\n save_path = input_file['save_path']\\n planet = input_file['exoplanet']\\n #radii = np.arange(input_file['apertures'][0],input_file['apertures'][1],0.1)\\n radii = np.array(input_file['apertures'])\\n #change to save data reduction directory\\n os.chdir(save_path)\\n if not os.path.exists('phot_results'):\\n os.makedirs('phot_results')\\n tempo = time.time()\\n print 'Starting aperture photometry'\\n print 'Saving results on: '+save_path+'/phot_results/'\\n \\n #check the number of objects to make the photometry\\n N_obj = len(input_file['pxpositions'])/2.\\n print 'Number of objects = ',N_obj\\n positions = [] #create the positions variable (X,Y) in pixels unit on the CCD\\n for i in range(len(input_file['pxpositions'])):\\n if i % 2 == 0: #if the number is a even (or not a odd), the turple is created\\n positions.append((input_file['pxpositions'][i],input_file['pxpositions'][i+1]))\\n print 'Radius from ',radii[0],' to ',radii[-1],'\\\\n'\\n \\n skysection = input_file['skysection']\\n skysection[0] = int(skysection[0])\\n skysection[1] = int(skysection[1])\\n \\n images = sorted(glob.glob('AB'+planet+'*.fits'))\\n for radius in radii:\\n flux_data = []\\n for i in range(len(images)):\\n im = fits.getdata(images[i],header=False)\\n im = array(im,dtype='Float64')\\n \\n # ERROR\\n #Traceback (most recent call last):\\n # File \\\"ExoTRed.py\\\", line 105, in <module>\\n # exotred.phot_aperture(input_file)\\n # File \\\"./sources/ExoTRed_core.py\\\", line 637, in phot_aperture \\n # File \\\"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/background/background_2d.py\\\", line 329, in __init__\\n # self._calc_bkg_bkgrms()\\n # File \\\"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/background/background_2d.py\\\", line 686, in _calc_bkg_bkgrms\\n # bkg = self._interpolate_meshes(self._bkg1d)\\n # File \\\"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/background/background_2d.py\\\", line 575, in _interpolate_meshes\\n # f = ShepardIDWInterpolator(yx, data)\\n # File \\\"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/utils/interpolation.py\\\", line 138, in __init__\\n # raise ValueError('The number of values must match the number '\\n # ValueError: The number of values must match the number of coordinates.\\n\\n # bkg = background.background_2d.Background2D(im,tuple(skysection))\\n # bkg_data = bkg.background\\n # bkg_rms = bkg.background_rms\\n\\n # phot_table = aperture_photometry(im - bkg_data, CircularAperture(positions, radius),\\n # error=bkg_rms, method ='center')#,effective_gain=float(input_file['gain']))\\n ####### SUBSTITUTE ROUTINE\\n window = 100\\n sky_size = im.shape\\n sky_mean = float(np.median(im[int(skysection[1]-window):int(skysection[1]+window),int(skysection[0]-window):int(skysection[0]+window)]))\\n bkg = np.random.poisson(sky_mean,sky_size)\\n apertures = CircularAperture(positions, radius)\\n phot_table = aperture_photometry(im, apertures, error=bkg)\\n #######\\n phot_table_flux = np.array([]) #saving results of aperture photometry\\n for j in range(len(phot_table['aperture_sum'])):\\n phot_table_flux = np.concatenate((phot_table_flux,np.array([phot_table['aperture_sum'][j]])),axis=0)\\n phot_table_flux = np.concatenate((phot_table_flux,np.array([phot_table['aperture_sum_err'][j]])),axis=0)\\n flux = np.concatenate((phot_table_flux,np.array([images[i]])),axis=0)\\n # flux = [phot_table['aperture_sum'][0], phot_table['aperture_sum'][1],phot_table['aperture_sum_err'][0],\\n # phot_table['aperture_sum_err'][1],images[i]]\\n flux_data.append(flux)\\n flux_data = DataFrame(flux_data)#,columns=['hoststar','refstar','hoststar_err','refstar_err','image'])\\n flux_data.to_csv('./phot_results/'+planet+'_flux_radius_'+str(radius)+'.csv',index=False)\\n use.update_progress((float(np.where(radii == radius)[0])+1.)/len(radii))\\n print 'Time total = ',abs(time.time()-tempo)/60.,' minutes'\\n os.chdir(original_path)\",\n \"def use_effect(self):\\n if self.preview_name in FILTERS:\\n photo = Image.open(self.path.url[1:])\\n preview = photo.filter(FILTERS.get(self.preview_name))\\n preview.save(self.path.url[1:])\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--interval\\\", \\\"-t\\\", type=int,\\n help=\\\"length of time in seconds between images\\\",\\n default=60)\\n parser.add_argument(\\\"--images\\\", \\\"-n\\\", type=int, help=\\\"number of images\\\", default=1)\\n parser.add_argument(\\\"--output\\\", \\\"-o\\\",\\n help=\\\"path to output directory\\\", default=\\\"./\\\")\\n parser.add_argument(\\\"--rotation\\\", \\\"-r\\\",\\n help=\\\"degrees to rotate pi image\\\", default=0)\\n parser.add_argument(\\\"--iso\\\", \\\"-i\\\", type=int, help=\\\"camera iso 0 is auto mode\\\", default=0)\\n parser.add_argument(\\\"--shutter\\\", \\\"-s\\\", type=int,\\n help=\\\"camera shutter speed in microseconds 0 is auto mode\\\", default=0)\\n parser.add_argument(\\\"--exposure\\\", \\\"-e\\\", help=\\\"exposure compensation set between -25 and +25\\\", default=0)\\n args = parser.parse_args()\\n interval = int(args.interval)\\n images = int(args.images)\\n output = args.output\\n rotation = int(args.rotation)\\n iso = int(args.iso)\\n shutter_speed = int(args.shutter)\\n exposure_compensation = int(args.exposure)\\n\\n\\n timelapse(int=interval,\\n n=images,\\n dir=output,\\n rotation=rotation,\\n iso=iso,\\n shutter=shutter_speed,\\n exposure=exposure_compensation)\",\n \"def run_shoe_rack_manipulation(self, debug=False, push_in_distance=0.00):\\n\\n print(\\\"\\\\n\\\\n--- Running Shoe Manipulation-------\\\\n\\\\n\\\")\\n\\n # self.taskRunner.callOnMain(self._poser_visualizer.visualize_result)\\n\\n if not self.check_category_goal_estimation_succeeded():\\n return False\\n\\n # check that we really are doing mug\\n category_manipulation_type = self.state.cache['category_manipulation_goal']['type']\\n assert category_manipulation_type == CategoryManipulationType.SHOE_ON_RACK\\n\\n\\n speed = self.graspingParams['speed']['fast']\\n self.moveHome(speed=speed)\\n\\n result = self.state.cache['category_manipulation_goal']['result']\\n T_W_fingertip = ros_numpy.numpify(result.T_world_gripper_fingertip)\\n T_W_fingertip_vtk = transformUtils.getTransformFromNumpy(T_W_fingertip)\\n\\n grasp_data = GraspData.from_gripper_fingertip_frame(T_W_fingertip)\\n grasp_data.gripper.params[\\\"hand_inner_diameter\\\"] = result.gripper_width\\n grasp_data.gripper.params[\\\"hand_inner_diameter\\\"] = 0.07\\n self.state.grasp_data = grasp_data\\n\\n # rotate the grasp to align with nominal\\n params = self.getParamsForCurrentLocation()\\n grasp_z_axis_nominal = np.array(params['grasp']['grasp_nominal_direction'])\\n grasp_data.rotate_grasp_frame_to_nominal(grasp_z_axis_nominal)\\n\\n\\n\\n\\n def vis_function():\\n vis.updateFrame(T_W_fingertip_vtk, \\\"gripper fingertip frame\\\", scale=0.15, parent=self._vis_container)\\n\\n vis.updateFrame(grasp_data.grasp_frame, \\\"grasp frame\\\", scale=0.15, parent=self._vis_container)\\n\\n self.visualize_grasp(grasp_data)\\n\\n self.taskRunner.callOnMain(vis_function)\\n\\n # execute the grasp\\n force_threshold_magnitude = 30\\n object_in_gripper = self.execute_grasp(grasp_data, close_gripper=True, use_cartesian_plan=True, force_threshold_magnitude=force_threshold_magnitude, push_in_distance=0.04, ee_speed_m_s=0.1)\\n\\n\\n if not object_in_gripper:\\n print(\\\"grasp failed, returning\\\")\\n return False\\n\\n print \\\"object_in_gripper:\\\", object_in_gripper\\n\\n T_goal_obs = self.state.cache['category_manipulation_goal'][\\\"T_goal_obs\\\"]\\n T_W_G = self.state.cache['gripper_frame_at_grasp']\\n\\n\\n\\n pre_grasp_pose = self.state.cache['pre_grasp_ik_response'].joint_state.position\\n pickup_speed = self.graspingParams['speed']['pickup']\\n\\n if not object_in_gripper:\\n # open the gripper and back away\\n self.gripperDriver.send_open_gripper_set_distance_from_current()\\n self.robotService.moveToJointPosition(pre_grasp_pose,\\n maxJointDegreesPerSecond=\\n pickup_speed)\\n return False\\n\\n # pickup the object\\n self.robotService.moveToJointPosition(pre_grasp_pose,\\n maxJointDegreesPerSecond=\\n pickup_speed)\\n\\n # move home\\n self.moveHome()\\n\\n # move to approach pose\\n speed = self.graspingParams['speed']['fast']\\n q_approach = np.array(self._stored_poses_director[\\\"left_table\\\"][\\\"shoe_approach\\\"])\\n self.robotService.moveToJointPosition(q_approach, maxJointDegreesPerSecond=speed)\\n\\n\\n # compute some poses\\n T_goal_obs = ros_numpy.numpify(result.T_goal_obs) # 4 x 4 numpy matrix\\n T_goal_obs_vtk = transformUtils.getTransformFromNumpy(T_goal_obs)\\n object_manip = ObjectManipulation(T_goal_object=T_goal_obs_vtk, T_W_G=T_W_G)\\n object_manip.compute_transforms()\\n T_W_Gn_vtk = object_manip.T_W_Gn # gripper to world for place pose\\n\\n T_pre_goal_obs = ros_numpy.numpify(result.T_pre_goal_obs)\\n T_pre_goal_obs_vtk = transformUtils.getTransformFromNumpy(T_pre_goal_obs)\\n object_manip_approach = ObjectManipulation(T_goal_object=T_pre_goal_obs_vtk, T_W_G=T_W_G)\\n object_manip_approach.compute_transforms()\\n T_W_Gn_approach_vtk = object_manip_approach.T_W_Gn\\n\\n # move this down by push_in_distance\\n\\n pos, quat = transformUtils.poseFromTransform(T_W_Gn_approach_vtk)\\n T_W_Gn_approach_vtk = transformUtils.transformFromPose(pos, quat)\\n\\n\\n # now convert these to ee poses for running IK\\n pos, quat = transformUtils.poseFromTransform(T_W_Gn_vtk)\\n pos[2] -= push_in_distance\\n T_W_Gn_vtk = transformUtils.transformFromPose(pos, quat)\\n T_W_ee_vtk = self.getIiwaLinkEEFrameFromGraspFrame(T_W_Gn_vtk)\\n T_W_ee = transformUtils.getNumpyFromTransform(T_W_ee_vtk)\\n\\n T_W_ee_approach_vtk = self.getIiwaLinkEEFrameFromGraspFrame(T_W_Gn_approach_vtk)\\n T_W_ee_approach = transformUtils.getNumpyFromTransform(T_W_ee_approach_vtk)\\n\\n\\n # place the object\\n force_threshold_magnitude = 50 # shoes are heavy\\n q_nom = np.array(self._stored_poses_director[\\\"Grasping\\\"][\\\"above_table_pre_grasp\\\"])\\n q_nom = np.array(self._stored_poses_director[\\\"left_table\\\"][\\\"above_table_pre_grasp\\\"])\\n code =self.execute_place_new(T_W_ee, T_W_ee_approach, q_nom=q_nom, use_cartesian_plan=True, force_threshold_magnitude=force_threshold_magnitude)\\n\\n print(\\\"\\\\n\\\\n--- Finished Shoe Manipulation-------\\\\n\\\\n\\\")\\n\\n self._shoe_manipulation_counter += 1\\n\\n return code\",\n \"def stitchSpectra(lamb_list,count_list, method=\\\"scale\\\", edgeremove=(0, 0), shiftToPositive=False, dlambda=None):\\r\\n rawData=np.array([np.array(lamb_list),np.array(count_list)])\\r\\n rawData=rawData.swapaxes(0,1)\\r\\n coefficients = []\\r\\n print(\\\"Removing edges for stitching:\\\", *edgeremove)\\r\\n omitRight = rawData[0].shape[1] - math.floor(rawData[0].shape[1] * edgeremove[1])\\r\\n print(\\\"Stitching index range is \\\", 0, omitRight)\\r\\n processed = np.array(rawData[0][:, 0:omitRight]) \\r\\n if dlambda is None:\\r\\n dlambda = math.fabs(processed[0, 1] - processed[0, 0]) ## lambda steps of first spectrum are kept\\r\\n for i, spec in enumerate(rawData[1:]):\\r\\n omitLeft = math.floor(spec.shape[1] * edgeremove[0])\\r\\n omitRight = spec.shape[1] - math.floor(spec.shape[1] * edgeremove[1])\\r\\n print(\\\"Stitching index range is \\\", omitLeft, omitRight)\\r\\n if i == len(rawData)-2:\\r\\n spec = np.array(spec[:, omitLeft:]) ## do not shorten last array at end\\r\\n else:\\r\\n spec = np.array(spec[:, omitLeft:omitRight]) # shorten middle arrays at both sides\\r\\n print(\\\"Stitching spectrum in range\\\", np.min(spec[0,]), np.max(spec[0,]))\\r\\n # calculate overlap\\r\\n overlap = (np.min(spec[0,]), np.max(processed[0,])) \\r\\n #lambdas = np.arange(*overlap, dlambda)\\r\\n #leftfun = interp1d(processed[0,], processed[1,])\\r\\n #rightfun = interp1d(spec[0,], spec[1,])\\r\\n left = np.mean(processed[1, processed[0,] > overlap[0]]) ##mean of counts of overlap\\r\\n right = np.mean(spec[1, spec[0,] < overlap[1]])\\r\\n if method == \\\"shift\\\":\\r\\n # calculate offset in overlap region\\r\\n offset = left - right\\r\\n print(\\\"Stitching offset %s in overlap\\\", offset, *overlap)\\r\\n # add shifted spectrum\\r\\n spec[1,] = spec[1,] + offset\\r\\n coefficients.append(offset)\\r\\n elif method == \\\"scale\\\":\\r\\n # calculate factor in overlap region\\r\\n factor = left/right\\r\\n print(\\\"Stitching factor\\\"+str(factor)+\\\" in overlap \\\", *overlap)\\r\\n spec[1,] = spec[1,] * factor\\r\\n coefficients.append(factor)\\r\\n processed = np.concatenate([processed, spec], axis=1)\\r\\n # interpolate data on grid\\r\\n interpolated = interp1d(processed[0,], processed[1,])\\r\\n lambdas = np.arange(processed[0, 0], processed[0, -1], dlambda)\\r\\n specdata = interpolated(lambdas)\\r\\n # shift above 0\\r\\n if shiftToPositive:\\r\\n minimum = np.min(specdata)\\r\\n if minimum < 0:\\r\\n specdata += math.fabs(minimum)\\r\\n \\r\\n return (lambdas,specdata,coefficients)\",\n \"def __call__(self):\\n return self.shoot()\",\n \"def run_std_sift(self): \\n for i in range(2):\\n image = 'input_'+str(i)+'.png'\\n label = 'im'+str(i)\\n f = open(self.work_dir+'keys_'+label+'.txt','w')\\n sift = self.run_proc(['sift_cli', image], stdout=f)\\n self.wait_proc(sift, timeout=self.timeout)\\n return 1\",\n \"def burning_ship(pixels, width, height, max_iterations, re_start, re_end, im_start, im_end, color_hue,\\n color_saturation, color_intensity):\\n\\n for x in prange(0, width):\\n for y in prange(0, height):\\n c = complex((re_start + (x / width) * (re_end - re_start)),\\n (im_start + (y / height) * (im_end - im_start)))\\n z = 0.0j\\n\\n iterations = 0\\n while (abs(z) < 4.0) and iterations < max_iterations:\\n abs_z = complex(abs(z.real), abs(z.imag))\\n z = abs_z * abs_z + c\\n iterations += 1\\n\\n # Color smoothing\\n smooth_iterations = iterations - math.log(math.log(z.real * z.real + z.imag * z.imag)) + 4.0\\n\\n if iterations >= max_iterations:\\n pixels[x, y, 0] = 0\\n pixels[x, y, 1] = 0\\n pixels[x, y, 2] = 0\\n else:\\n pixels[x, y, 0] = 255 * (color_hue / 360)\\n pixels[x, y, 1] = 255 * color_saturation\\n pixels[x, y, 2] = 255 * min(color_intensity * smooth_iterations / max_iterations, 1)\",\n \"def main():\\n # color = rb.Color.BLUE.value\\n # move_to_color(color)\\n infared_sensor()\\n\\n # WHITE/RED does not work same with the BLUE/GREEN going down\",\n \"def overlay(self):\\n # retrieve header for photometry keywords\\n # from current frame only\\n hdr_str = self.run('fits header', via='get')\\n\\n # read it in to a fits header\\n phdr = fits.Header()\\n hdr = phdr.fromstring(hdr_str, sep='\\\\n')\\n\\n try:\\n srcposx = hdr['SRCPOSX'] + 1\\n srcposy = hdr['SRCPOSY'] + 1\\n s1 = 'point({:f} {:f}) # ' \\\\\\n 'point=x ' \\\\\\n 'color=blue tag={{srcpos}} '\\\\\\n 'text=SRCPOS'.format(srcposx, srcposy)\\n self.run('regions', s1)\\n except (KeyError, ValueError):\\n pass\\n try:\\n stcentx = hdr['STCENTX'] + 1\\n stcenty = hdr['STCENTY'] + 1\\n photaper = hdr['PHOTAPER']\\n photskap = [float(x) for x in hdr['PHOTSKAP'].split(',')]\\n s1 = 'point({:f} {:f}) # ' \\\\\\n 'point=x ' \\\\\\n 'color=cyan tag={{srcpos}}'.format(stcentx, stcenty)\\n self.run('regions', s1)\\n s2 = 'circle({:f} {:f} {:f}) # ' \\\\\\n 'color=cyan tag={{srcpos}}'.format(\\n stcentx, stcenty, photaper)\\n self.run('regions', s2)\\n s3 = 'annulus({:f} {:f} {:f} {:f}) # ' \\\\\\n 'color=cyan tag={{srcpos}} text=STCENT'.format(\\n stcentx, stcenty, photskap[0], photskap[1])\\n self.run('regions', s3)\\n except (KeyError, ValueError):\\n pass\\n try:\\n stcentx = hdr['STCENTX'] + 1\\n stcenty = hdr['STCENTY'] + 1\\n flux = hdr['STAPFLX']\\n sky = hdr['STAPSKY']\\n s1 = 'text({:f} {:f}) # color=cyan ' \\\\\\n 'text=\\\"Flux={:.2f}, Sky={:.2f}\\\"'.format(\\n stcentx, stcenty - 40, flux, sky)\\n self.run('regions', s1)\\n except (KeyError, ValueError):\\n pass\\n\\n # try overlaying apertures as well\\n try:\\n self.overlay_aperture(hdr)\\n except ValueError: # pragma: no cover\\n # may be encountered with extensions with\\n # unexpected WCSs\\n pass\",\n \"def run(self,workspace):\\n image_name = self.image_name.value\\n cpimage = workspace.image_set.get_image(image_name)\\n image = cpimage.pixel_data\\n mask = cpimage.mask\\n workspace.display_data.statistics = []\\n level = int(self.atrous_level.value)\\n\\n wavelet = self.a_trous(1.0*image, level+1)\\n wlevprod = wavelet[:,:,level-1] * 3.0\\n\\n spotthresh = wlevprod.mean() + float(self.noise_removal_factor.value) * wlevprod.std()\\n tidx = wlevprod < spotthresh\\n wlevprod[tidx] = 0\\n\\n wlevprod = self.circular_average_filter(wlevprod, int(self.smoothing_filter_size.value))\\n wlevprod = self.smooth_image(wlevprod, mask)\\n\\n max_wlevprod = scipy.ndimage.filters.maximum_filter(wlevprod,3)\\n maxloc = (wlevprod == max_wlevprod)\\n twlevprod = max_wlevprod > float(self.final_spot_threshold.value)\\n maxloc[twlevprod == 0] = 0\\n \\n labeled_image,object_count = scipy.ndimage.label(maxloc,\\n np.ones((3,3),bool))\\n\\n unedited_labels = labeled_image.copy()\\n # Filter out objects touching the border or mask\\n border_excluded_labeled_image = labeled_image.copy()\\n labeled_image = self.filter_on_border(image, labeled_image)\\n border_excluded_labeled_image[labeled_image > 0] = 0\\n \\n # Relabel the image\\n labeled_image,object_count = relabel(labeled_image)\\n new_labeled_image, new_object_count = self.limit_object_count(\\n labeled_image, object_count)\\n if new_object_count < object_count:\\n # Add the labels that were filtered out into the border\\n # image.\\n border_excluded_mask = ((border_excluded_labeled_image > 0) |\\n ((labeled_image > 0) & \\n (new_labeled_image == 0)))\\n border_excluded_labeled_image = scipy.ndimage.label(border_excluded_mask,\\n np.ones((3,3),bool))[0]\\n object_count = new_object_count\\n labeled_image = new_labeled_image\\n \\n # Make an outline image\\n outline_image = cellprofiler.cpmath.outline.outline(labeled_image)\\n outline_border_excluded_image = cellprofiler.cpmath.outline.outline(border_excluded_labeled_image)\\n \\n if self.show_window:\\n statistics = workspace.display_data.statistics\\n statistics.append([\\\"# of accepted objects\\\",\\n \\\"%d\\\"%(object_count)])\\n\\n workspace.display_data.image = image\\n workspace.display_data.labeled_image = labeled_image\\n workspace.display_data.border_excluded_labels = border_excluded_labeled_image\\n\\n # Add image measurements\\n objname = self.object_name.value\\n measurements = workspace.measurements\\n cpmi.add_object_count_measurements(measurements,\\n objname, object_count)\\n # Add label matrices to the object set\\n objects = cellprofiler.objects.Objects()\\n objects.segmented = labeled_image\\n objects.unedited_segmented = unedited_labels\\n objects.parent_image = image\\n \\n workspace.object_set.add_objects(objects,self.object_name.value)\\n cpmi.add_object_location_measurements(workspace.measurements, \\n self.object_name.value,\\n labeled_image)\\n if self.should_save_outlines.value:\\n out_img = cpi.Image(outline_image.astype(bool),\\n parent_image = image)\\n workspace.image_set.add(self.save_outlines.value, out_img)\",\n \"def sim_image_ramp(det, im_slope, verbose=False, **kwargs):\\n if verbose:\\n _log.info('Generating image acquisition ramp...')\\n\\n return sim_dark_ramp(det, im_slope, ramp_avg_ch=None, verbose=False, **kwargs)\",\n \"def make_spectra(directory,frame):\\n oober = st.short_oober(directory, frame=frame)\\n #st.MakeVelocitySpectra(oober,frame)\\n #st.MakeAccelSpectra(oober,frame)\\n #st.MakeMagneticSpectra(oober,frame)\\n st.MakeDensitySpectra(oober,frame)\",\n \"def punched(self):\\n if not self.dizzy:\\n self.dizzy= 1\\n self.original= self.image\",\n \"def write_images(band,skypos,tranges,skyrange,write_cnt=False,write_int=False,write_rr=False,framesz=0,width=False,height=False,verbose=0,tscale=1000.,memlight=False,coadd=False,response=False,calpath='../cal/',clobber=False,retries=20):\\n\\t# No files were requested, so don't bother doing anything.\\n\\tif not (write_cnt or write_int or write_rr):\\n\\t\\treturn\\n\\tcount,rr,intensity=create_images(band,skypos,tranges,skyrange,framesz=framesz,width=width,height=height,verbose=verbose,tscale=tscale,memlight=memlight,coadd=coadd,response=response,calpath=calpath,retries=retries)\\n\\n\\t# Add a conditional so that this is only created for multi-frame images\\n\\ttbl = movie_tbl(band,tranges,framesz=framesz,verbose=verbose,retries=retries)\\n\\n\\tif write_cnt:\\n\\t\\thdu = pyfits.PrimaryHDU(count)\\n\\t\\thdu = fits_header(band,skypos,tranges,skyrange,width=width,height=height,verbose=verbose,tscale=tscale,hdu=hdu,retries=retries)\\n\\t\\thdulist = pyfits.HDUList([hdu,tbl])\\n\\t\\tif verbose:\\n\\t\\t\\tprint 'Writing count image to '+str(write_cnt)\\n\\t\\thdulist.writeto(write_cnt,clobber=clobber)\\n\\tif write_rr:\\n\\t\\thdu = pyfits.PrimaryHDU(rr)\\n\\t\\thdu = fits_header(band,skypos,tranges,skyrange,width=width,height=height,verbose=verbose,tscale=tscale,hdu=hdu,retries=retries)\\n\\t\\thdulist = pyfits.HDUList([hdu,tbl])\\n\\t\\tif verbose:\\n\\t\\t\\tprint 'Writing response image to '+str(write_rr)\\n hdulist.writeto(write_rr,clobber=clobber)\\n\\tif write_int:\\n\\t\\thdu = pyfits.PrimaryHDU(intensity)\\n\\t\\thdu = fits_header(band,skypos,tranges,skyrange,width=width,height=height,verbose=verbose,tscale=tscale,hdu=hdu,retries=retries)\\n\\t\\thdulist = pyfits.HDUList([hdu,tbl])\\n\\t\\tif verbose:\\n\\t\\t\\tprint 'Writing intensity image to '+str(write_int)\\n\\t\\thdulist.writeto(write_int,clobber=clobber)\\n\\n\\treturn\",\n \"def psfphot(image, clobber=globclob, verbose=globver, pixtol=3.0,\\n maxnpsf=5, interact=yes):\\n\\n # Defaults / constants\\n psfmult=5.0 #standard factor (multiplied by fwhm to get psfradius)\\n psfmultsmall=3.0 #similar to psfmult, adjusted for nstar and substar\\n\\n # Necessary package\\n iraf.imutil()\\n\\n # Detect stars\\n iqpkg.iqobjs(image, 3.0, 50000.0, wtimage=\\\"\\\", skyval=\\\"!MEDSKY\\\")\\n\\n root = image[:-5]\\n [gain, rnoise, fwhm] = get_head(image, [\\\"GAIN\\\", \\\"READNOI\\\", \\\"SEEPIX\\\"])\\n fwhm = float(fwhm); rnoise = float(rnoise)\\n\\n iraf.iterstat(image)\\n \\n # Saturation level\\n if not check_head(image, \\\"SATURATE\\\"):\\n saturate = 60000.0\\n else:\\n saturate = get_head(image, \\\"SATURATE\\\")\\n \\t \\n # Update datapars and daopars\\n iraf.datapars.fwhmpsf=fwhm\\n iraf.datapars.sigma=iraf.iterstat.sigma\\n iraf.datapars.datamin=iraf.iterstat.median-10*iraf.iterstat.sigma\\n iraf.datapars.datamax=70000.0\\n iraf.datapars.readnoise=rnoise\\n iraf.datapars.epadu=gain \\n iraf.daopars.psfrad=psfmult*fwhm\\n iraf.daopars.fitrad=fwhm\\n iraf.daopars.function=\\\"gauss,moffat15,moffat25,lorentz,penny1\\\"\\n\\n # coo file\\n stars = Starlist(\\\"%s.stars\\\" % image)\\n outf = open(\\\"%s.coo.1\\\" % image[:-5], \\\"w\\\")\\n for star in stars:\\n outf.write(\\\"%10.3f%10.3f\\\\n\\\" % (star.xval, star.yval))\\n outf.close()\\n\\n #initial photometry\\n iraf.daophot.phot(root,'default','default',aperture=fwhm,verify=no,\\n verbose=verbose)\\n\\n iraf.datapars.datamax=30000.0\\n iraf.pstselect(root,'default','default',maxnpsf,interactive=yes,\\n verify=no,verbose=verbose)\\n\\n iraf.psf(root,'default','default','default','default','default',\\n interactive=interact,verify=no,verbose=verbose)\\n\\n iraf.allstar(root,'default','default','default','default','default',\\n verify=no,verbose=verbose)\\n\\n iraf.iterstat(\\\"%s.sub.fits\\\" % root)\\n\\n iraf.datapars.sigma=iraf.iterstat.sigma\\n iraf.datapars.datamin=iraf.iterstat.median-10*iraf.iterstat.sigma\\n\\n iraf.datapars.datamax=70000.0\\n iraf.daophot.phot(\\\"%s.sub.fits\\\" % root, \\\"SN.coo\\\", 'default', 'default',\\n aperture=fwhm, verify=no, verbose=verbose)\\n\\n iraf.datapars.datamax=30000.0\\n iraf.daopars.fitrad=fwhm*2.0\\n iraf.allstar(\\\"%s.sub.fits\\\" % root, 'default', \\\"%s.psf.1.fits\\\" % root, \\n 'default', 'default', 'default', verify=no, verbose=no)\",\n \"def get_sky(plate, mjd, output_path, verbose=False):\\n tag = f'PLATE {plate:05d} MJD {mjd:05d} PATH {output_path}'\\n if verbose:\\n print('Starting {}'.format(tag))\\n # Initialize output data.\\n last_nexp = None\\n plugmaps = []\\n wlens = {'b': [], 'r': []}\\n wdisps = {'b': [], 'r': []}\\n fluxes = {'b': [], 'r': []}\\n ivars = {'b': [], 'r': []}\\n flats = {'b': [], 'r': []}\\n rdnoises = {'b': [], 'r': []}\\n masks = {'b': [], 'r': []}\\n obskeys = ('EXPOSURE', 'TAI-BEG', 'EXPTIME', 'AZ', 'ALT', 'AIRMASS',\\n 'PRESSURE', 'AIRTEMP',\\n 'RDNOISE0', 'RDNOISE1', 'RDNOISE2', 'RDNOISE3')\\n obsvals = {key: [] for key in obskeys}\\n # Size of each amplifier in raw image pixels along (wlen, tracex) axes.\\n ampsize = {'b': (2056, 2048), 'r': (2064, 2057)}\\n # ampx[band] tabulates whether each wavelength index is readout by\\n # amplifier 0/2 (=0) or 1/3 (=1).\\n ampx = {'b': 1 * (np.arange(4112) >= 2056),\\n 'r': 1 * (np.arange(4128) >= 2064)}\\n # amplifer[band] is a function that takes a traceset as input an returns an\\n # array that tabulates whether each wavelength index is readout by\\n # amplifier 0-3.\\n amplifier = {'b': lambda x: 2 * (x >= 2048) + ampx['b'],\\n 'r': lambda x: 2 * (x >= 2057) + ampx['r']}\\n # Scaling such that RMS = rdnoise_scale * RDNOISEn * neff.\\n rdnoise_scale = (4 * np.pi) ** 0.25\\n # Conversion from constant log-lambda pixels to wavelength ratio.\\n wdisp_const = 1e-4 * np.log(10)\\n # Allowed pixel mask bits.\\n valid_mask = (1 << 32) - 1\\n # Slices of valid data to save. These trim pixels at each end where\\n # IVAR=0 or other serious pixel mask bits are often set.\\n valid_slices = {'b': slice(767, 3299), 'r': slice(483, 3668) }\\n # Initialize data access.\\n finder = bossdata.path.Finder()\\n mirror = bossdata.remote.Manager()\\n # Loop over spectrographs.\\n expected_fibers = []\\n for specidx in 1, 2:\\n # Load the list of science exposures used for this spectrograph's coadd.\\n fiber = 500 * (specidx - 1) + 1\\n spec_name = finder.get_spec_path(plate, mjd, fiber=fiber, lite=True)\\n exposures = bossdata.spec.SpecFile(mirror.get(spec_name)).exposures\\n for band in 'b', 'r':\\n camera = '{}{}'.format(band, specidx)\\n use = valid_slices[band]\\n # Loop over science exposures for this camera.\\n nexp = exposures.num_by_camera[camera]\\n if not (last_nexp is None or nexp == last_nexp):\\n print(f'Different nexp for {camera} {tag}')\\n return None\\n last_nexp = nexp\\n for expidx in range(nexp):\\n # Load this camera's spFrame file.\\n name = exposures.get_exposure_name(expidx, camera, 'spFrame')\\n path = mirror.get(finder.get_plate_path(plate, name))\\n spFrame = bossdata.plate.FrameFile(path, calibrated=False)\\n # Lookup this spectrograph's sky fibers.\\n sky_name = binary_type('SKY ', 'ascii')\\n fiberidx = np.where(\\n spFrame.plug_map['OBJTYPE'] == sky_name)[0]\\n if expidx == 0 and band == 'b':\\n # Save plugmap metadata.\\n plugmaps.append(spFrame.plug_map[\\n ['FIBERID','RA','DEC','XFOCAL','YFOCAL']][fiberidx])\\n if specidx == 2:\\n plugmap = astropy.table.vstack(plugmaps)\\n if specidx == 1 and band == 'b':\\n # Record observation metadata.\\n for key in obskeys:\\n try:\\n value = spFrame.header[key]\\n except KeyError:\\n value = -999 # invalid value for int/float types\\n obsvals[key].append(value)\\n # Load the sky fiber data.\\n fibers = spFrame.plug_map['FIBERID'][fiberidx].data\\n assert np.all(fiberidx == spFrame.get_fiber_offsets([fibers]))\\n if expidx == 0 and band == 'b':\\n expected_fibers.append(fibers)\\n if verbose:\\n print('Found {} sky fibers on spec{}: {}.'.format(\\n len(fibers), specidx,\\n ','.join([str(f) for f in fibers])))\\n else:\\n if not np.all(fibers == expected_fibers[specidx - 1]):\\n print('Did not get expected fibers for {} exp {}'\\n .format(camera, expidx))\\n data = spFrame.get_valid_data(\\n fibers, include_sky=True, include_wdisp=True, use_ivar=True,\\n pixel_quality_mask=valid_mask)\\n if verbose:\\n print('Reading {} for exposure {} / {}...'\\n .format(camera, expidx + 1, nexp))\\n assert data.shape == (len(fibers), 2 * ampsize[band][0])\\n mask = spFrame.get_pixel_masks(fibers)\\n masks[band].append(mask[:, use])\\n # Identify pixels with valid data.\\n valid = ~data['ivar'].mask\\n bad_fibers = ~np.any(valid, axis=1)\\n if verbose and np.any(bad_fibers):\\n print(' bad fibers: {}'.format(fibers[bad_fibers]))\\n ivar = data['ivar'].data\\n assert np.all(ivar[valid] > 0)\\n ivars[band].append(ivar[:, use])\\n # Load the superflat and trace vectors for sky fibers.\\n superflat = spFrame.get_superflat(fibers)\\n tracex = spFrame.hdulist[7].read()[fiberidx]\\n # Load fiberflat and neff vectors from this camera's spFlat.\\n name = exposures.get_exposure_name(expidx, camera, 'spFlat')\\n path = mirror.get(finder.get_plate_path(plate, name))\\n with fits.open(path) as spFlat:\\n fiberflat = spFlat[0].data[fiberidx]\\n neff = bossdata.plate.TraceSet(spFlat[3]).get_y()[fiberidx]\\n if np.any(neff[valid] <= 0):\\n print(f'WARNING: neff <= 0 for {camera} {expidx} {tag}')\\n # Lookup the per-amplifier readnoise values.\\n readnoises = np.array([\\n spFrame.header['RDNOISE{}'.format(amp)]\\n for amp in range(4)], dtype=np.float32)\\n # Determine which amplifier (0-3) each pixel along the trace is\\n # read out by and scale to RMS readnoise per wavelength pixel.\\n amp = amplifier[band](tracex)\\n rdnoise = rdnoise_scale * readnoises[amp] * neff\\n rdnoises[band].append(rdnoise[:, use].astype(np.float32))\\n # Combine the superflat and fiberflat.\\n flat = superflat * fiberflat\\n assert np.all(flat[valid] > 0)\\n flats[band].append(flat[:, use])\\n # Save wavelength solutions in angstroms.\\n wlen = data['wavelength'].data\\n wlens[band].append(wlen[:, use])\\n # Save wavelength dispersions in angstroms.\\n wdisp = data['wdisp'].data\\n assert np.all(wdisp[valid] > 0)\\n wdisp = wlen * np.expm1(wdisp_const * wdisp)\\n wdisps[band].append(wdisp[:, use])\\n # Save the combined flat-fielded sky models + residuals,\\n # which might be negative due to readnoise.\\n flux = data['flux'].data + data['sky'].data\\n fluxes[band].append(flux[:, use])\\n # Build observation metadata table.\\n obslist = astropy.table.Table()\\n for key in obskeys:\\n obslist[key] = obsvals[key]\\n # Build the output HDU list.\\n hdus = fits.HDUList()\\n cards = dict(PLATE=plate, MJD=mjd, NFIBERS=len(plugmap), NEXP=nexp)\\n hdus.append(fits.PrimaryHDU(header=fits.Header(cards)))\\n hdus.append(fits.table_to_hdu(obslist))\\n hdus[-1].name = 'OBSLIST'\\n hdus.append(fits.table_to_hdu(plugmap))\\n hdus[-1].name = 'PLUGMAP'\\n for band in 'b', 'r':\\n Band = band.upper()\\n # Combine arrays for each band and save an an image HDU.\\n hdus.append(fits.ImageHDU(np.vstack(wlens[band]),\\n name='{}WLEN'.format(Band)))\\n hdus.append(fits.ImageHDU(np.vstack(wdisps[band]),\\n name='{}WDISP'.format(Band)))\\n hdus.append(fits.ImageHDU(np.vstack(rdnoises[band]),\\n name='{}RDNOISE'.format(Band)))\\n hdus.append(fits.ImageHDU(np.vstack(flats[band]),\\n name='{}FLAT'.format(Band)))\\n hdus.append(fits.ImageHDU(np.vstack(fluxes[band]),\\n name='{}FLUX'.format(Band)))\\n hdus.append(fits.ImageHDU(np.vstack(ivars[band]),\\n name='{}IVAR'.format(Band)))\\n hdus.append(fits.ImageHDU(np.vstack(masks[band]),\\n name='{}MASK'.format(Band)))\\n name = os.path.join(output_path, 'sky-{}-{}.fits'.format(plate, mjd))\\n hdus.writeto(name, overwrite=True)\\n print('Completed {}'.format(tag))\\n return obslist\",\n \"def skycombine(dir = 'Objects'):\\n \\n if dir ==\\\"Objects\\\":\\n dir = 'Objects/*/*/flat_corrected/'\\n \\n for d in glob(dir):\\n \\n directory = \\\"/\\\".join(d.split('/')[0:2]) + '/swarped'\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n \\n keys = ['OBJECTS', 'ITIME', 'FWINAME', 'OBSDATE', 'CAMNAME', 'HISTORY', 'FLSPECTR']\\n images = ImageFileCollection(d, keywords = keys, glob_include = 'f*.fits')\\n \\n swarpfilter(d, dir, directory, images, keys, filter='H', lamp = '*', camera = 'narrow',\\n done='Dark Subtracted', output='cKSkyNarrowH', type='EQUATORIAL')\\n swarpfilter(d, dir, directory, images, keys, filter='H',lamp = '*', camera = 'wide', \\n done='Dark Subtracted', output='cKSkyWideH', type='EQUATORIAL')\\n swarpfilter(d, dir, directory, images, keys, filter='J',lamp = '*', camera = 'narrow', \\n done='Dark Subtracted', output='cKSkyNarrowJ', type='EQUATORIAL')\\n swarpfilter(d, dir, directory, images, keys, filter='J', lamp = '*',camera = 'wide', \\n done='Dark Subtracted', output='cKSkyWideJ', type='EQUATORIAL') \\n swarpfilter(d, dir, directory, images, keys, filter='Ks',lamp = '*', camera = 'narrow', \\n done='Dark Subtracted', output='cKSkyNarrowKs', type='EQUATORIAL')\\n swarpfilter(d, dir, directory, images, keys, filter='Ks',lamp = '*', camera = 'wide', \\n done='Dark Subtracted', output='cKSkyWideKs', type='EQUATORIAL')\\n swarpfilter(d, dir, directory, images, keys, filter='Lp',lamp = '*', camera = 'narrow', \\n done='Dark Subtracted', output='cKSkyNarrowLp', type='EQUATORIAL')\\n swarpfilter(d, dir, directory, images, keys, filter='Lp',lamp = '*', camera = 'wide', \\n done='Dark Subtracted', output='cKSkyNarrowLp', type='EQUATORIAL')\",\n \"def main(s0, s1, s2, s3, delayFunc, dm, decimate = 0):\\n\\n\\t# Ignore, testing\\n\\n\\n\\t# Get the delays (in seconds)\\n\\tprint(\\\"Finding time delays...\\\")\\n\\tdelays = delayFunc(absftop, -100. / 512, nchans, dm)\\n\\tprint(\\\"Delays (s):\\\")\\n\\tprint(delays)\\n\\tdelays /= sampleRate\\n\\tdelays = delays.astype(int)\\n\\n\\t# Build up a \\n\\toutputLen = int(s0.shape[0] - np.max(delays))\\n\\tdataOut = np.ones((outputLen, nchans), dtype = np.int32)\\n\\tprint(delays)\\n\\n\\t# Terribl approach to RFI\\n\\tzapchans = list(range(150,200)) + list(range(280, 290)) + list(range(305, 320)) + list(range(450, nchans))\\n\\n\\t# SImple implementation that works, but isn't cache efficient\\n\\tprint(\\\"Forming Stokes I + Dedispersing... processing channel:\\\")\\n\\tfor i in range(nchans):\\n\\t\\tif i in zapchans:\\n\\t\\t\\tcontinue\\n\\t\\tprint(f\\\"{i} ({100 * i / min(430,nchans)} %)\\\", end = '\\\\r')\\n\\t\\tdataOut[..., i] += np.square(s0[delays[i]: delays[i] + outputLen, i].astype(np.int32))\\n\\t\\tdataOut[..., i] += np.square(s1[delays[i]: delays[i] + outputLen, i].astype(np.int32))\\n\\t\\tdataOut[..., i] += np.square(s2[delays[i]: delays[i] + outputLen, i].astype(np.int32))\\n\\t\\tdataOut[..., i] += np.square(s3[delays[i]: delays[i] + outputLen, i].astype(np.int32))\\n\\n\\t# Cache efficient but untested\\n\\t\\\"\\\"\\\"\\n\\tprint(\\\"Forming Stokes I + Dedispersing... processing sample:\\\")\\n\\tblockCount = 128\\n\\tblockSize = int(dataOut.shape[0] / blockCount)\\n\\tfor i in range(blockCount):\\n\\t\\tif i in zapchans:\\n\\t\\t\\tcontinue\\n\\t\\tprint(f\\\"{i* blockSize} -> {(i + 1) * blockSize} ({100 * i / blockCount:07.3f} %)\\\", end = '\\\\r')\\n\\t\\tdataOut[i * blockSize: (i+1) * blockSize, :] += np.square(s0[i * blockLength + delays[i]: (i + 1) * blockLength + delays[i] + outputLen, i].astype(np.int32))\\n\\t\\tdataOut[i * blockSize: (i+1) * blockSize, :] += np.square(s1[i * blockLength + delays[i]: (i + 1) * blockLength + delays[i] + outputLen, i].astype(np.int32))\\n\\t\\tdataOut[i * blockSize: (i+1) * blockSize, :] += np.square(s2[i * blockLength + delays[i]: (i + 1) * blockLength + delays[i] + outputLen, i].astype(np.int32))\\n\\t\\tdataOut[i * blockSize: (i+1) * blockSize, :] += np.square(s3[i * blockLength + delays[i]: (i + 1) * blockLength + delays[i] + outputLen, i].astype(np.int32))\\n\\t\\\"\\\"\\\"\\n\\n\\tif decimate:\\n\\t\\tprint(\\\"Decimating...\\\")\\n\\t\\trollingSum = np.cumsum(dataOut, axis = 0)\\n\\t\\tdataOut = rollingSum[decimate::decimate, :] - rollingSum[:-decimate:decimate, :]\\n\\n\\n\\tprint(\\\"Plotting...\\\")\\n\\tplt.figure(figsize = (24,12))\\n\\tplt.imshow(dataOut.T, aspect = 'auto', vmax = np.percentile(dataOut, 95), vmin = np.percentile(dataOut, 33))\\n\\tplt.savefig(f'./debugfull_{datetime.datetime.now().isoformat()}.png')\\n\\n\\tplt.figure(figsize = (24,12))\\n\\tplt.imshow(np.log10(dataOut.T), aspect = 'auto', vmax = np.log10(np.percentile(dataOut, 95)), vmin = np.log10(np.percentile(dataOut, 33)))\\n\\tplt.savefig(f'./debugfull2_{datetime.datetime.now().isoformat()}.png')\\n\\t\\n\\tplt.figure(figsize = (24,12))\\n\\td1 = dataOut[:, :100].sum(axis = 1)\\n\\td1 -= np.mean(d1, dtype = np.int64)\\n\\td2 = dataOut[:, 100:200].sum(axis = 1)\\n\\td2 -= np.mean(d2, dtype = np.int64)\\n\\td3 = dataOut[:, 200:300].sum(axis = 1)\\n\\td3 -= np.mean(d3, dtype = np.int64)\\n\\td4 = dataOut[:, 300:].sum(axis = 1)\\n\\td4 -= np.mean(d4, dtype = np.int64)\\n\\tplt.plot(d1, alpha = 0.3, label = '1')\\n\\tplt.plot(d2, alpha = 0.3, label = '2')\\n\\tplt.plot(d3, alpha = 0.3, label = '3')\\n\\tplt.plot(d4, alpha = 0.3, label = '4')\\n\\tplt.legend()\\n\\tplt.savefig(f'./debug_{datetime.datetime.now().isoformat()}.png')\\n\\n\\tprint(\\\"Done!\\\")\",\n \"def activate(self):\\n self.scriptedEffect.showEffectCursorInSliceView = False\\n self.clippedMasterImageData = None\",\n \"def run_sift(self):\\n paradic = self.cfg['param']['paradic']\\n for i in range(2):\\n image = 'input_'+str(i)+'.png'\\n label = 'im'+str(i)\\n f = open(self.work_dir+'keys_'+label+'.txt','w')\\n sift = self.run_proc(['sift_cli', image, label,\\n str(paradic['n_oct']),\\n str(paradic['n_spo']),\\n str(paradic['sigma_min']),\\n str(paradic['delta_min']),\\n str(paradic['sigma_in']),\\n str(paradic['C_DoG']),\\n str(paradic['C_edge']),\\n str(paradic['n_bins']),\\n str(paradic['lambda_ori']),\\n str(paradic['t']),\\n str(paradic['n_hist']),\\n str(paradic['n_ori']),\\n str(paradic['lambda_descr'])],\\n stdout=f) \\n self.wait_proc(sift, timeout=self.timeout) \\n return 1\",\n \"def _generate_direct_image(self):\\n filename = '0000_flt.fits'\\n\\n di_start_JD = (self.exp_start_times[0] - 1 * u.min).to(u.day)\\n di_exp_gen = ExposureGenerator(self.detector, self.grism, self.NSAMP,\\n self.SAMPSEQ, self.SUBARRAY,\\n self.planet, filename, di_start_JD)\\n\\n try: # assume that its a list not a single value\\n x_ref = self.x_ref[0]\\n except TypeError:\\n x_ref = self.x_ref\\n\\n try: # assume that its a list not a single value\\n y_ref = self.y_ref[0]\\n except TypeError:\\n y_ref = self.y_ref\\n\\n exp = di_exp_gen.direct_image(x_ref, y_ref)\\n exp.generate_fits(self.outdir, '0000_flt.fits')\",\n \"def bias(s='bias'):\\n s = s.strip()[:80] #truncate to 80 char to fit in FITS header\\n exptime(0.0)\\n print camera.SetShutter(2)\\n camera.status.imgtype = 'BIAS'\\n camera.status.object = s\\n camera.status.update()\",\n \"def _full_speed_rumble(self, images, duration):\\n while duration > 0:\\n self.microbit.display.show(images[0]) # pylint: disable=no-member\\n time.sleep(0.04)\\n self.microbit.display.show(images[1]) # pylint: disable=no-member\\n time.sleep(0.04)\\n duration -= 0.08\",\n \"def exposure():\\n def r(x):\\n return x/6e4\\n\\n def w(x):\\n return int(x*6e4)\\n return r, w\",\n \"def OFlow(testdirs, opath):\\n\\n\\t# create directories if doesn't exist\\n\\tif not os.path.exists(opath):\\n\\t\\tos.makedirs(opath)\\n\\n\\tif not os.path.exists(opath+'/each_image'):\\n\\t\\tos.makedirs(opath+'/each_image')\\n\\t\\t\\n\\tif not os.path.exists(opath+'/masks'):\\n\\t\\tos.makedirs(opath+'/masks')\\n\\t\\t\\n\\tif not os.path.exists(opath+'/scaled_masks'):\\n\\t\\tos.makedirs(opath+'/scaled_masks')\\n\\n\\tdcount = 0\\t# directory count\\n\\n\\tfor d in testdirs:\\n\\n\\t\\th = d[-65:-1]\\t# hash\\n\\n\\t\\t# create directory for each hash to save individual optical flow images separately\\n\\t\\tif not os.path.exists(opath+'/each_image/'+h):\\n\\t\\t\\tos.makedirs(opath+'/each_image/'+h)\\n\\n\\t\\tprvs = cv2.imread(d + 'frame0000.png', 0)\\t# previous image\\n\\n\\t\\ts = (prvs.shape[0], prvs.shape[1], 3)\\t# hsv image shape\\n\\n\\t\\thsv = np.zeros(s, np.uint8)\\n\\t\\thsv[...,1] = 255\\n\\t\\t\\n\\t\\tms = (prvs.shape[0], prvs.shape[1])\\t\\t# mask shape\\n\\t\\t\\n\\t\\tmask = np.zeros(ms, np.uint8)\\n\\t\\tsum_mask = np.zeros(ms, np.uint8)\\n\\t\\tscaled_mask = np.zeros(ms, np.uint8)\\n\\t\\t\\n\\t\\tprint(\\\"dir: \\\",dcount,\\\" dim: \\\",sum_mask.shape)\\n\\t\\tdcount += 1\\n\\t\\t\\n\\t\\tflag = 0\\n\\n\\t\\tfor i in range(1,100):\\n\\t\\t\\tnxt = cv2.imread(d + 'frame00'+str(i).zfill(2)+'.png', 0)\\t# next image\\n\\t\\t\\tflow = cv2.calcOpticalFlowFarneback(prvs,nxt, None, 0.5, 3, 15, 3, 5, 1.2, 0)\\n\\t\\t\\tmag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])\\t# calculates magnitude and angles of 2D vectors\\n\\t\\t\\t\\n\\t\\t\\thsv[...,0] = ang*180/np.pi/2\\n\\t\\t\\t\\n\\t\\t\\thsv[...,2] = cv2.normalize(mag,None,0,255,cv2.NORM_MINMAX)\\n\\t\\t\\tbgr = cv2.cvtColor(hsv,cv2.COLOR_HSV2BGR)\\n\\t\\t\\tomg = cv2.cvtColor(bgr,cv2.COLOR_BGR2GRAY)\\n\\t#\\t\\tprint(omg.dtype)\\n\\t#\\t\\tprint(omg.shape)\\n\\t\\t\\t\\n\\t\\t\\tcv2.imshow('frame1',omg)\\n\\t\\t\\tom = Image.fromarray(omg)\\n\\t\\t\\tom.save(opath+'/each_image/'+h+'/frame00'+str(i).zfill(2)+'.png', 0)\\n\\t\\t\\t\\n\\t\\t\\tomg2 = omg\\n\\n\\t\\t\\t# scaling with random hardcoded values\\n\\t\\t\\tfor r in range(omg2.shape[0]):\\n\\t\\t\\t\\tfor c in range(omg2.shape[1]):\\n\\t\\t\\t\\t\\tif omg2[r][c] < 32:\\n\\t\\t\\t\\t\\t\\tsum_mask[r][c] += 0\\n\\t\\t\\t\\t\\telif omg2[r][c] < 128:\\n\\t\\t\\t\\t\\t\\tsum_mask[r][c] += 1\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tsum_mask[r][c] += 2\\n\\n\\t\\t\\tflag = cv2.waitKey(30) & 0xff\\n\\t\\t\\tif flag == 27:\\t\\t# press ESC to exit\\n\\t\\t\\t break\\n\\n\\t\\t\\tprvs = nxt\\n\\n\\t\\t# generating mask based on sum_mask again based on random hardcoded values\\n\\t\\tfor r in range(prvs.shape[0]):\\n\\t\\t\\tfor c in range(prvs.shape[1]):\\n\\t\\t\\t\\tif sum_mask[r][c] > 50:\\n\\t\\t\\t\\t\\tmask[r][c] = 2\\n\\t\\t\\t\\t\\tscaled_mask[r][c] = 255\\n\\t\\t\\t\\telif sum_mask[r][c] > 15:\\n\\t\\t\\t\\t\\tmask[r][c] = 1\\n\\t\\t\\t\\t\\tscaled_mask[r][c] = 128\\n\\t\\tomask = Image.fromarray(mask)\\n\\t\\tomask.save(opath+'/masks/'+h+'.png', 0)\\n\\t\\tosmask = Image.fromarray(scaled_mask)\\n\\t\\tosmask.save(opath+'/scaled_masks/'+h+'.png', 0)\\n\\n\\tcv2.destroyAllWindows()\",\n \"def toggle_exposure(self):\\n\\n checked1 = self.exp1_radio.isChecked()\\n if checked1:\\n self.exp2_radio.setChecked(True)\\n else:\\n self.exp1_radio.setChecked(True)\\n self.select_exposure()\",\n \"def __init__(self, width, height, framerate, max_dist, sv_path, \\n record_time, saveimg, savepc, savebag):\\n self.width = width\\n self.height = height\\n self.framerate = framerate\\n self.max_dist = max_dist # filter\\n self.sv_path = sv_path\\n self.record_time = record_time\\n self.saveimg = saveimg\\n self.savepc = savepc\\n self.savebag = savebag\\n\\n self.lane_detector = LaneDetector()\\n self.pc = rs.pointcloud()\\n self.colorizer = rs.colorizer()\\n self.create_filter()\",\n \"def setProtectSurfaces():\\n dislin.shlsur()\",\n \"def step(self, amt=1):\\n \\n # For checking if all the animations have their framse looked at\\n #activewormind = [i for i, x in enumerate(self._idlelist) if x == False]\\n #print \\\"Worm {} at {:5g}\\\".format(activewormind, 1000*(time.time() - starttime))\\n # save times activated for each worm \\n [self.timedata[i].append(1000*(time.time() - starttime)) for i, x in enumerate(self._idlelist) if x == False]\\n \\n #self._led.buffer = [0] * 480\\n self._led.pixheights = [-100] * self._led.numLEDs\\n #print type(self._led.buffer)\\n for ledcopy in self._ledcopies:\\n # self._led.buffer = map(ixor, self._led.buffer, ledcopy.buffer)\\n # use pixheights but assume all buffers same size\\n # print ledcopy.driver[0].pixheights\\n for pix in range(self._led.numLEDs):\\n #for ledcopy in self._ledcopies:\\n if self._led.pixheights[pix] == ledcopy.driver[0].pixheights[pix]:\\n for i in range(3):\\n self._led.buffer[3*pix + i] ^= ledcopy.buffer[3*pix + i]\\n elif self._led.pixheights[pix] < ledcopy.driver[0].pixheights[pix]:\\n for i in range(3):\\n self._led.buffer[3*pix + i] = ledcopy.buffer[3*pix + i]\\n self._led.pixheights[pix] = ledcopy.driver[0].pixheights[pix] \\n self._step += 1\",\n \"def run_observation(self):\\n\\n self._generate_direct_image() # to calibrate x_ref and y_ref\\n\\n num_frames = len(self.exp_start_times)\\n progress = Progress(num_frames)\\n self.progess = progress\\n\\n progress_line = 'Generating frames 0/{} done'.format(num_frames)\\n progress.print_status_line(progress_line)\\n progress.progress_line = progress_line\\n\\n for i, start_time in enumerate(self.exp_start_times):\\n filenum = i + 1\\n self._generate_exposure(start_time, filenum)\\n\\n progress.increment()\\n progress_line = 'Generating frames {}/{} done'.format(filenum,\\n num_frames)\\n progress.print_status_line(progress_line)\\n\\n # so it can be retreived by exposure_generator\\n progress.progress_line = progress_line\",\n \"def fireRandom():\\n#the increment and the A1-H8 define the possible colors the pixels can be\\n\\tincrement = 20\\n A1 = Color(255, 0, 0)\\n B2 = Color(255, increment, 0)\\n C3 = Color(255, increment * 2, 0)\\n D4 = Color(255, increment * 3, 0)\\n E5 = Color(255, increment * 4, 0)\\n F6 = Color(255, increment * 5, 0)\\n G7 = Color(255, increment * 6, 0)\\n H8 = Color(255, increment * 7, 0)\\n#the for loop with i and the number of pixels cycles through all the pixels we have so that they each get called when a random number does\\n for i in range (strip.numPixels()):\\n threeQuarters = randrange(0, 4)\\n if threeQuarters == 1 or threeQuarters == 2 or threeQuarters == 3 :\\n#the above if statement and the threeQuarters variable makes it so that the pixels only recieve a color 75% of the time. This makes a flicker.\\n shade = randrange(0,9)\\n\\n if shade == 1:\\n strip.setPixelColor(i, A1)\\n strip.show()\\n elif shade == 2:\\n strip.setPixelColor(i, B2)\\n strip.show()\\n elif shade == 3:\\n strip.setPixelColor(i, C3)\\n strip.show()\\n elif shade == 4:\\n strip.setPixelColor(i, D4)\\n strip.show()\\n elif shade == 5:\\n strip.setPixelColor(i, E5)\\n strip.show()\\n elif shade == 6:\\n strip.setPixelColor(i, F6)\\n strip.show()\\n elif shade == 7:\\n strip.setPixelColor(i, G7)\\n\\t\\t\\t\\tstrip.show()\\n\\t\\t\\telse: \\n\\t\\t\\t\\tstrip.setPixelColor(i, H8)\\n\\t\\t\\t\\tstrip.show()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.609327","0.60517883","0.6042764","0.5937301","0.58709234","0.57097524","0.5626163","0.56135774","0.5605713","0.5569856","0.5565318","0.55331594","0.5474416","0.54720265","0.546944","0.546139","0.5431014","0.5417215","0.5389273","0.5385319","0.53823715","0.53608334","0.5350842","0.5325013","0.5324093","0.53186107","0.5307615","0.5303014","0.5300838","0.5296238","0.5292857","0.5291221","0.5282675","0.52644855","0.52548665","0.5253392","0.52530366","0.5241206","0.5239949","0.5238053","0.5229733","0.5214106","0.5202829","0.5195585","0.5184195","0.5172646","0.51605767","0.5148059","0.51400894","0.5135868","0.51358485","0.51358145","0.5132701","0.51205426","0.51172316","0.5108857","0.50945365","0.5087174","0.50836754","0.5079301","0.50784755","0.50663245","0.5059835","0.505474","0.5052357","0.5051662","0.5042399","0.50404537","0.5036776","0.5036536","0.50353616","0.50246084","0.5022891","0.5021086","0.5021034","0.50131553","0.5011978","0.49950886","0.49923852","0.49839252","0.4976915","0.4969501","0.4968737","0.4968196","0.49600044","0.4956715","0.49446705","0.49427888","0.49364802","0.4929312","0.49276537","0.4926511","0.4924106","0.491814","0.491698","0.49169424","0.49164906","0.49164748","0.4915689","0.49103296","0.49092796"],"string":"[\n \"0.609327\",\n \"0.60517883\",\n \"0.6042764\",\n \"0.5937301\",\n \"0.58709234\",\n \"0.57097524\",\n \"0.5626163\",\n \"0.56135774\",\n \"0.5605713\",\n \"0.5569856\",\n \"0.5565318\",\n \"0.55331594\",\n \"0.5474416\",\n \"0.54720265\",\n \"0.546944\",\n \"0.546139\",\n \"0.5431014\",\n \"0.5417215\",\n \"0.5389273\",\n \"0.5385319\",\n \"0.53823715\",\n \"0.53608334\",\n \"0.5350842\",\n \"0.5325013\",\n \"0.5324093\",\n \"0.53186107\",\n \"0.5307615\",\n \"0.5303014\",\n \"0.5300838\",\n \"0.5296238\",\n \"0.5292857\",\n \"0.5291221\",\n \"0.5282675\",\n \"0.52644855\",\n \"0.52548665\",\n \"0.5253392\",\n \"0.52530366\",\n \"0.5241206\",\n \"0.5239949\",\n \"0.5238053\",\n \"0.5229733\",\n \"0.5214106\",\n \"0.5202829\",\n \"0.5195585\",\n \"0.5184195\",\n \"0.5172646\",\n \"0.51605767\",\n \"0.5148059\",\n \"0.51400894\",\n \"0.5135868\",\n \"0.51358485\",\n \"0.51358145\",\n \"0.5132701\",\n \"0.51205426\",\n \"0.51172316\",\n \"0.5108857\",\n \"0.50945365\",\n \"0.5087174\",\n \"0.50836754\",\n \"0.5079301\",\n \"0.50784755\",\n \"0.50663245\",\n \"0.5059835\",\n \"0.505474\",\n \"0.5052357\",\n \"0.5051662\",\n \"0.5042399\",\n \"0.50404537\",\n \"0.5036776\",\n \"0.5036536\",\n \"0.50353616\",\n \"0.50246084\",\n \"0.5022891\",\n \"0.5021086\",\n \"0.5021034\",\n \"0.50131553\",\n \"0.5011978\",\n \"0.49950886\",\n \"0.49923852\",\n \"0.49839252\",\n \"0.4976915\",\n \"0.4969501\",\n \"0.4968737\",\n \"0.4968196\",\n \"0.49600044\",\n \"0.4956715\",\n \"0.49446705\",\n \"0.49427888\",\n \"0.49364802\",\n \"0.4929312\",\n \"0.49276537\",\n \"0.4926511\",\n \"0.4924106\",\n \"0.491814\",\n \"0.491698\",\n \"0.49169424\",\n \"0.49164906\",\n \"0.49164748\",\n \"0.4915689\",\n \"0.49103296\",\n \"0.49092796\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":497,"cells":{"query":{"kind":"string","value":"one call per exposure/dither move"},"document":{"kind":"string","value":"def test_do_apogee_science_1_pair_B_open(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['apogee_science'])\n sopTester.updateModel('apogee', TestHelper.apogeeState['B_open'])\n self._do_apogee_science(3, 30, 0, 0, ditherPairs=1)"},"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 opd_dither(cfg):\n \n setpoint_new = pi.getINDI('PLC.UBCSettings.PLSetpoint')\n file_number = pi.getINDI('NOMIC.CamInfo.FIndex') # Get initial file number\n offsets = np.array(cfg['nomic_dither_opd_pattern']) * 5.0 * 180.0 / np.pi # input in rad at 11um, but commandet offsets in deg in K band\n pi.setINDI('NOMIC.EditFITS.Keyword=spdthpos;Value=0.0;Comment=setpoint dither position (offset from nominal setpoint) in rad')\n while True:\n for i_step in range(0, len(cfg['nomic_dither_opd_pattern'])):\n file_number = file_number + cfg['nomic_dither_opd_ndits'][i_step]\n try:\n pi.evalINDI ('\"NOMIC.CamInfo.FIndex\" >= %d' % file_number, timeout=900) # wait for cfg['nomic_dither_opd_ndits'][i] new files to arrive\n except:\n info('OPD dither offset timed out (more than 15 min since last offset)')\n print(' or was interrupted.')\n print(' Make sure to restart OPD dither pattern.')\n return()\n setpoint_old = pi.getINDI('PLC.UBCSettings.PLSetpoint') # ask for current setpoint\n if (setpoint_old - setpoint_new) > 2.9: # if expected setpoint is more than ~0.01 rad (at 11um) different from current setpoint\n info('Setpoint has changed between two dither positions.')\n setpoint_new = setpoint_old + offsets[i_step] # determine new setpoint\n pi.setINDI('NOMIC.EditFITS.Keyword=spdthpos;Value=' + str(np.sum(offsets[:i_step+1])) + ';Comment=setpoint dither position (offset from nominal setpoint) in rad')\n pi.setINDI('PLC.PLSetpoint.PLSetpoint=' + str(setpoint_new) + ';forNAC=0') # send a dither offset","def endexposureloop(self):\n self.max_exposures = self.current_exposure","def do_pixels(self):\n self.do_yurt_pixels()\n self.do_petal_strip_pixels()\n self.do_vase_pixels()","def run(self):\n openShutter = True\n actuateXed = False\n image_type = \"PPUMP\"\n\n wl = float(self.eo_config.get(\"PPUMP_WL\", 550))\n meas_flux = self.measured_flux(wl)\n seqno = 0\n for tokens in self.instructions:\n exptime = float(tokens[1])\n nframes = int(tokens[2])\n shifts = int(tokens[3])\n for iframe in range(nframes):\n self.image_clears()\n self.bias_image(seqno)\n self.take_image(seqno, exptime, openShutter, actuateXed,\n image_type)\n seqno += 1","def pixelMove(*args, **kwargs)->None:\n pass","def process(self, image):","def update_image(self):\n if self.filenames:\n pos = self.slider.value()\n proj, flat, dark, theta = dx.read_aps_32id(self.filenames, proj=(pos, pos+1))\n if self.ffc_correction:\n image = proj[0,:,:].astype(np.float)/flat[0,:,:].astype(np.float)\n else:\n image = proj[0,:,:].astype(np.float)\n self.image_item.setImage(image)","def warmup():\n print camera.CoolerOFF()\n camera.status.update()","def punched(self):\n if not self.dizzy:\n self.dizzy = 1\n self.original = self.image\n Chimp.count_punch += 1","def main():\n camera = picamera.PiCamera()\n camera.resolution = (RESOLUTIONX, RESOLUTIONY)\n camera.iso = 800\n time.sleep(2)\n while True:\n camera.capture('current-image.jpg')\n adapt_steering(navigation.get_xposition('current-image.jpg'))\n time.sleep(0.4)","def __call__(self, frame_num):\n # propagate and set the density\n self.img.set_array(\n np.abs(self.quant_sys.propagate(10)) ** 2\n )\n return self.img,","def continue_with_exposure(self):\r\n # Allocate space to give to scan_until_abort, and name the two\r\n # rows appropriately.\r\n self.data_pair = self.cam.get_new_array(n_images=2)\r\n self.pump_probe_data = self.data_pair[0]\r\n self.probe_only_data = self.data_pair[1]\r\n # Keep track of which image will be updated next\r\n self.next_data_has_pump = True\r\n\r\n # Tell self.thread what to do when the camera has new images\r\n self.cam.new_images.connect(self.send_new_images)\r\n\r\n # Get the current array of wavelengths from cam\r\n self.wavelen_arr = self.cam.get_wavelen_array()\r\n\r\n # Queue a call to cam.scan_until_abort\r\n self.startAcq.emit(self.data_pair)\r\n\r\n # Tell listeners (plotting widgets) to start displaying data too\r\n self.startDisplay.emit()","def run_observation(self):\n\n self._generate_direct_image() # to calibrate x_ref and y_ref\n\n num_frames = len(self.exp_start_times)\n progress = Progress(num_frames)\n self.progess = progress\n\n progress_line = 'Generating frames 0/{} done'.format(num_frames)\n progress.print_status_line(progress_line)\n progress.progress_line = progress_line\n\n for i, start_time in enumerate(self.exp_start_times):\n filenum = i + 1\n self._generate_exposure(start_time, filenum)\n\n progress.increment()\n progress_line = 'Generating frames {}/{} done'.format(filenum,\n num_frames)\n progress.print_status_line(progress_line)\n\n # so it can be retreived by exposure_generator\n progress.progress_line = progress_line","def __call__(self, img, target):\n if random.random() < 0.5:\n img = ImageEnhance.Brightness(img).enhance(0.5 + random.random())\n if random.random() < 0.5:\n img = ImageEnhance.Color(img).enhance(0.5 + random.random())\n if random.random() < 0.5:\n img = ImageEnhance.Contrast(img).enhance(0.5 + random.random())\n return img, target","def do_stuff(self):\n self.create_tourism_raster()","def sample_damaging(image):\r\n return crease_image(blotch_image(image, 100, True), 10, False)","def grass_drass():","def step(self,image):\r\n\r\n\t\tself.gray = image","def punched(self):\n if not self.dizzy:\n self.dizzy= 1\n self.original= self.image","def adjust_image_data(self):\r\n\r\n print('Adjusting image data: ')\r\n\r\n if self.removeFirstSequence: # used to remove the first trial from the sequence\r\n\r\n frames_per_rep = self.nFrames/self.nrepetitions\r\n\r\n self.imageData = self.imageData[frames_per_rep:, :, :]\r\n\r\n self.nFrames = self.imageData.shape[0]\r\n\r\n self.nrepetitions = int(self.nFrames/(self.period * self.framerate))\r\n\r\n self.times = np.arange(0, self.nFrames/self.framerate, 1.0/self.framerate)\r\n\r\n \r\n\r\n # first squeeze the image to 3d if it is 4d\r\n\r\n maxt = np.max(self.times) # find last image time\r\n\r\n sh = self.imageData.shape\r\n\r\n if len(sh) == 4:\r\n\r\n self.imageData = self.imageData.squeeze()\r\n\r\n sh = self.imageData.shape\r\n\r\n dt = np.mean(np.diff(self.times)) # get the mean dt\r\n\r\n n_Periods = int((maxt+dt)/self.period) # how many full periods in the image set - include the first?\r\n\r\n if self.nrepetitions > 0 and self.nrepetitions < n_Periods:\r\n\r\n n_Periods = self.nrepetitions\r\n\r\n n_PtsPerCycle = int(np.floor(self.period/dt)); # estimate image points in a stimulus cycle\r\n\r\n ndt = self.period/n_PtsPerCycle\r\n\r\n self.imageData = self.imageData[range(0, n_Periods*n_PtsPerCycle),:,:] # reduce to only what we need\r\n\r\n print (' Adjusted image info')\r\n\r\n print (\" # Periods: %d Pts/cycle: %d Cycle dt %8.4fs (%8.3fHz) Cycle: %7.4fs\" %(n_Periods, n_PtsPerCycle, ndt, 1.0/ndt, self.period))\r\n\r\n self.print_image_info()","def _do_expose_loop(self, fitsfile, seconds):\n log.debug(f\"Starting expose loop with {self.max_exposures} exposures\")\n while (self.current_exposure is not None and \n self.current_exposure < self.max_exposures):\n self.current_exposure += 1\n self.Expose(fitsfile, seconds)\n while self.process and self.process.poll() is None:\n sleep(5)\n if not self.process or self.process.returncode != 0:\n break\n \n self.current_exposure = None\n self.max_exposures = None","def on_run(self):\n self.set_illumination({'mode': 'breathe'})","def _generate_exposure(self, expstart, number):\n\n index_number = number - 1 # for zero indexing\n\n filename = '{:04d}_raw.fits'.format(number)\n\n exp_gen = ExposureGenerator(self.detector, self.grism, self.NSAMP,\n self.SAMPSEQ, self.SUBARRAY,\n self.planet, filename, expstart)\n\n if not self.spatial_scan:\n self.sample_rate = 1 * u.year # high number reverts to read times\n\n _, sample_mid_points, sample_durations, read_index = \\\n exp_gen._gen_scanning_sample_times(self.sample_rate)\n\n time_array = (sample_mid_points + expstart).to(u.day)\n\n if self.transmission_spectroscopy:\n star_norm_flux = self.generate_lightcurves(time_array)\n planet_depths = 1 - star_norm_flux\n else:\n planet_depths = None\n\n # x shifts - linear shift with exposure, second exposure shifted by\n # x_shifts, direct image and first exp will match.\n x_ref = self._try_index(self.x_ref, index_number)\n y_ref = self._try_index(self.y_ref, index_number)\n sky_background = self._try_index(self.sky_background, index_number)\n\n # X and Y Shifts\n x_ref += self.x_shifts * index_number\n y_ref += self.y_shifts * index_number\n x_jitter = self.x_jitter\n y_jitter = self.y_jitter\n\n if self._visit_trend:\n scale_factor = self._visit_trend.get_scale_factor(index_number)\n else:\n scale_factor = None\n\n if self.spatial_scan:\n exp_frame = exp_gen.scanning_frame(\n x_ref, y_ref, x_jitter, y_jitter,\n self.wl, self.stellar_flux, planet_depths,\n self.scan_speed, self.sample_rate, sample_mid_points,\n sample_durations, read_index, ssv_generator=self.ssv_gen,\n noise_mean=self.noise_mean, noise_std=self.noise_std,\n add_flat=self.add_flat, add_dark=self.add_dark,\n scale_factor=scale_factor, sky_background=sky_background,\n cosmic_rate=self.cosmic_rate,\n add_gain_variations=self.add_gain_variations,\n add_non_linear=self.add_non_linear,\n clip_values_det_limits=self.clip_values_det_limits,\n add_read_noise=self.add_read_noise,\n add_stellar_noise=self.add_stellar_noise,\n add_initial_bias=self.add_initial_bias,\n progress_bar=self.progess,\n threads=self.threads\n )\n else:\n exp_frame = exp_gen.staring_frame(\n x_ref, y_ref, x_jitter, y_jitter,\n self.wl, self.stellar_flux, planet_depths,\n sample_mid_points, sample_durations, read_index,\n noise_mean=self.noise_mean, noise_std=self.noise_std,\n add_flat=self.add_flat, add_dark=self.add_dark,\n scale_factor=scale_factor, sky_background=sky_background,\n cosmic_rate=self.cosmic_rate,\n add_gain_variations=self.add_gain_variations,\n add_non_linear=self.add_non_linear,\n clip_values_det_limits=self.clip_values_det_limits,\n add_read_noise=self.add_read_noise,\n add_stellar_noise=self.add_stellar_noise,\n add_initial_bias=self.add_initial_bias,\n progress_bar=self.progess,\n threads=self.threads\n )\n\n exp_frame.generate_fits(self.outdir, filename, ldcoeffs=self.ldcoeffs)\n\n return exp_frame","def process_walked_event(self, event):\n sprite = self.sprites[event.id][1]\n old_point = self.sprites[event.id][0]\n self.sprites[event.id][0] = event.point\n self.img[event.point.y, event.point.x] = self.sprite_colors[sprite]\n self.img[old_point.y, old_point.x] = self.sprite_colors[\"Background\"]","def main():\n folder = \"D:\\\\Noam10\\\\Documents\\\\Documents\\\\dither 2\"\n filename = \"kirigiri\"\n filetype = \".jpg\"\n input_file = folder + \"\\\\\" + filename + filetype\n for palette in paletteDict.keys():\n output_file = folder + \"\\\\\" + filename + \"(\" + palette + \").bmp\"\n Dither(input_file, output=output_file, palette=paletteDict[palette])\n print(output_file)","def analysis_dFF_map(self):\r\n\r\n \r\n\r\n print ('Starting dF/F analysis:')\r\n\r\n self.print_image_info()\r\n\r\n # smoothwin = int(self.imageData.shape[1]/8.)\r\n\r\n # get the average image and the average of the whole image over time\r\n\r\n avgimg = np.mean(self.imageData, axis=0) # get mean image for reference later: average across all time\r\n\r\n \r\n\r\n mpl.figure(99)\r\n\r\n mpl.imshow(avgimg, vmin=0, vmax=np.max(np.max(avgimg, axis=0), axis=0))\r\n\r\n # self.meanimagevalue = np.mean(np.mean(avgimg, axis=1), axis=0)\r\n\r\n # self.stdimg = np.std(self.imageData, axis= 0) # and standard deviation\r\n\r\n imgdatasm = scipy.ndimage.filters.gaussian_filter(self.imageData,[0,2,2],order=0,output=None,mode='reflect',cval=0.0,truncate=4.0)\r\n # field correction: smooth the average image, subtract it from the imagedata, then add back the mean value\r\n avgimgsm = scipy.ndimage.filters.gaussian_filter(avgimg, 2, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\r\n\r\n # avgimgsm = scipy.ndimage.filters.gaussian_filter(avgimg, smoothwin, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\r\n\r\n #self.imageData = (self.imageData-avgimgsm)+ self.meanimagevalue\r\n\r\n mpl.figure(98)\r\n mpl.imshow(avgimgsm,vmin=0, vmax=np.max(np.max(avgimgsm, axis=0), axis=0))\r\n mpl.figure(97)\r\n mpl.imshow(np.mean(imgdatasm,axis=0))\r\n self.n_times = self.timebase\r\n\r\n periodsize = int(self.period*self.framerate)\r\n print('periodsize: ',periodsize)\r\n\r\n # windowsize = int(self.freqperiod*self.framerate) # window size for every response\r\n\r\n # r = range(0, self.imageData.shape[0], windowsize)\r\n\r\n sig = np.reshape(imgdatasm, (self.nrepetitions, periodsize, \r\n\r\n self.imageData.shape[1], self.imageData.shape[2]), order='C')\r\n\r\n delresp=np.zeros([19,256,256])\r\n repback = np.mean(sig[:,1:4,:,:],axis=1)\r\n resp = np.mean(sig[:,5:9,:,:],axis=1)\r\n for counter in range(19):\r\n delresp[counter,:,:]=(resp[counter,:,:]-repback[counter,:,:])/repback[counter,:,:]\r\n quot=np.mean(delresp,axis=0)\r\n quot=-quot\r\n print ('shape of quot: ', np.shape(quot))\r\n # quot=(resp-repback)/repback\r\n # quot[quot>0]=0\r\n # quot=-1000*quot\r\n\r\n mpl.figure(7)\r\n mpl.imshow(quot,cmap=mpl.cm.binary)\r\n mpl.colorbar()\r\n\r\n quotsm = scipy.ndimage.filters.gaussian_filter(quot, 3, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\r\n mpl.figure(8)\r\n mpl.imshow(quotsm,cmap=mpl.cm.binary)\r\n mpl.colorbar()\r\n \r\n # bl = np.mean(sig[:, range(0, sig.shape[1], windowsize), :, :], axis=0)\r\n\r\n # bl = scipy.ndimage.filters.gaussian_filter(bl, smoothwin, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\r\n\r\n\r\n\r\n # print (' windowsize: ', windowsize)\r\n\r\n # print (' periodsize: ', periodsize)\r\n # mc = matplotlib.cm\r\n\r\n # only use sequential maps here\r\n\r\n # clist = [mc.Reds, mc.YlOrBr, mc.Oranges, mc.Greens, mc.GnBu, mc.Blues, mc.RdPu, mc.Purples,mc.Reds,mc.Greens,mc.Blues,mc.Reds,mc.Reds,mc.Reds,mc.Reds]\r\n # clist2 = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet', 'black','red','purple','green','blue','red','red','red','red']\r\n\r\n cs = {}\r\n\r\n # sigd = np.zeros((bl.shape[0], sig.shape[2], sig.shape[3]))\r\n# \r\n # localmax = {}\r\n\r\n # sigmax = 0.\r\n# \r\n # kernel = np.ones((5, 5))\r\n\r\n # psf = kernel / np.sum(kernel)\r\n\r\n # compute dF/F, and get maximum over all frequencies\r\n\r\n print (' sig shape: ', sig.shape)\r\n\r\n # print (' bl shape: ', bl.shape)\r\n\r\n # smax = np.zeros(bl.shape[0])\r\n\r\n # for i in range(bl.shape[0]):\r\n\r\n # sigd[i] = (np.mean(np.max(sig[:,range(i*windowsize, i*windowsize+windowsize),:,:], axis=0), axis=0) - bl[i,:,:])/bl[i,:,:]\r\n\r\n # sigd[i] = sigd[i]**2.0\r\n\r\n # smooth\r\n\r\n #sigd[i] = scipy.ndimage.filters.gaussian_filter(sigd[i], 1., order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\r\n\r\n # deconvolve\r\n\r\n # sigd[i] = restoration.richardson_lucy(sigd[i], psf, 5)\r\n\r\n# sm = sigd[i].max().max()\r\n\r\n# if sm > sigmax:\r\n\r\n# sigmax = sm\r\n\r\n# smax[i] = sm\r\n\r\n# print( ' i, sm: ', i, sm)\r\n\r\n# # now process for display\r\n\r\n# print (' sigd shape: ', sigd.shape)\r\n\r\n# wdat = np.mean(sig, axis=0)\r\n\r\n# wds = wdat.shape\r\n\r\n# print('wdat shape: ', wds)\r\n\r\n# # print (range(int(wds[1]/2.), int(3.*wds[1]/4.)), range(int(wds[2]/2.), int(3.*wds[2]/4.)))\r\n\r\n# print( 'reduced shape: ', wdat[:,range(int(wds[1]/2.),int(3.*wds[1]/4.)),:][:,:,range(int(wds[2]/2.), int(3.*wds[2]/4.))].shape)\r\n\r\n# wp = wdat[:,range(int(wds[1]/2.),int(3.*wds[1]/4.)),:][:,:,range(int(wds[2]/2.), int(3.*wds[2]/4.))]\r\n\r\n# wp = np.mean(np.mean(wdat, axis=1), axis=1)\r\n\r\n# mpl.figure(1)\r\n\r\n# mpl.plot(np.linspace(0., len(wp)*1./self.framerate, num=len(wp)), wp)\r\n\r\n\r\n\r\n# mpl.figure(2)\r\n\r\n# for i in range(sigd.shape[0]):\r\n\r\n# sigd[i][sigd[i] < self.threshold*sigmax] = 0.\r\n\r\n# # find center of mass of areas above threshold\r\n\r\n# # mass = sigd[i].copy()\r\n\r\n# # mass[sigd[i] > 0.] = 1.\r\n\r\n# # structuring_element = [[0,1,0],[1,1,1],[0,1,0]]\r\n\r\n# # segmentation, segments = scipy.ndimage.label(mass, structuring_element)\r\n\r\n# # coords = scipy.ndimage.center_of_mass(sigd[i], segmentation, range(1,segments+1))\r\n\r\n# # xcoords = np.array([x[1] for x in coords])\r\n\r\n# # ycoords = np.array([x[0] for x in coords])\r\n\r\n# # cs[i] = (xcoords, ycoords)\r\n\r\n\r\n\r\n# # Calculating local maxima\r\n\r\n# lm = skif.peak_local_max(sigd[i], min_distance=2, threshold_rel=0.25, exclude_border=False, \r\n\r\n# indices=True, num_peaks=10, footprint=None, labels=None)\r\n\r\n# localmax[i] = [(m[0], m[1], sigd[i][(m[0], m[1])]) for m in lm]\r\n\r\n# # print ('i, local max: ',i, localmax)\r\n\r\n# mpl.subplot(5,5,i+1)\r\n# print ('shape of sigd: ',[np.shape(sigd),i])\r\n\r\n# imga1 = mpl.imshow(sigd[i], cmap=clist[i], vmin=0, origin='lower')\r\n\r\n# if len(localmax[i]) > 0:\r\n\r\n# max_fr = np.max([m[2] for m in localmax[i]])\r\n\r\n# else:\r\n\r\n# continue\r\n\r\n# scattersize = 30.\r\n\r\n# for k, lm in enumerate(localmax[i]):\r\n\r\n# mpl.scatter(lm[1], lm[0], marker='o', c=clist2[i], edgecolors='k',\r\n\r\n# s=scattersize*lm[2]/max_fr, linewidths=0.125, alpha=0.5)\r\n\r\n# mpl.subplot(6,5,i+15+1)\r\n\r\n# wr = range(i*windowsize, i*windowsize+windowsize)\r\n\r\n# # print (' wr: len, min max: ', len(wr), min(wr), max(wr))\r\n\r\n# wmax = 0.\r\n\r\n# for lmax in localmax[i]: # was xcoords\r\n\r\n# wave = wdat[wr, lmax[0],lmax[1]]\r\n\r\n# wdff = (wave-wave[0])/wave[0]\r\n\r\n# if np.max(wdff) > wmax:\r\n\r\n# wmax = np.max(wdff)\r\n\r\n# mpl.plot(np.linspace(0., len(wave)*1./self.framerate, num=len(wave)),\r\n\r\n# wdff, color=clist2[i])\r\n\r\n# mpl.ylim(-0.1*wmax, wmax)\r\n\r\n# fig = mpl.figure(3)\r\n\r\n# for i in range(sigd.shape[0]):\r\n\r\n# if len(localmax[i]) == 0:\r\n\r\n# continue\r\n\r\n# max_fr = np.max([m[2] for m in localmax[i]])\r\n\r\n# for lm in localmax[i]:\r\n\r\n# mpl.scatter(lm[1], lm[0], marker='o', c=clist2[i], \r\n\r\n# s=scattersize*lm[2]/max_fr, alpha=0.5, edgecolors='k')\r\n\r\n# mpl.ylim(0, sigd.shape[2])\r\n\r\n# mpl.xlim(0, sigd.shape[1])\r\n\r\n# mpl.axis('equal')\r\n\r\n mpl.show()\r\n\r\n print (' DF/F analysis finished.\\n')","def expose_test(self):\n with self.lock:\n self.dark = 1\n self.tstart = time.time()\n self.timestamp = time.strftime(\"%Y-%m-%dT%H:%M:%S\", time.localtime(self.tstart))\n imagesize = (self.expArea[3] - self.expArea[1],\n self.expArea[2] - self.expArea[0])\n self.data = np.ones(shape=imagesize, dtype=np.uint16)\n self.tend = time.time()","def __init__(self, inifile, dry_run, output):\n\n config = ConfigParser()\n config.read(inifile)\n sequence = config['dithersequence']\n\n # Set up the output.\n self._output = output\n\n # Set up the file type and exposure sequence.\n self._location = sequence['location']\n self._filetype = sequence['filetype']\n self._date = sequence['date']\n self._exposures = [int(e) for e in sequence['exposures'].split()]\n\n if 'coordinates' not in config:\n raise ValueError('no coordinates set for dither!')\n \n coords = config['coordinates']\n self._dithertype = coords['dithertype']\n \n self._wcs = fits.getdata(coords['wcsfile'], 2)\n self._wcs = self._wcs[np.argsort(self._wcs['mjd_obs'])]\n self._central_exposure = int(sequence['centralexposure'])\n\n if coords['dithertype'] == 'telescope':\n fadir = coords['fiberassigndir']\n self._ditherfa = fits.getdata(os.path.join(\n fadir, 'fiberassign-%s.fits' % coords['ditheredtilenum']))\n self._unditherfa = fits.getdata(os.path.join(\n fadir, 'fiberassign-%s.fits' % coords['unditheredtilenum']))\n expnum = [int(fn.split('-')[1]) for fn in self._wcs['filename']]\n centralind = expnum.index(self._central_exposure)\n self._central_wcs = self._wcs[centralind]\n\n # Set the Tile ID for the output metadata.\n self._tileid = coords['unditheredtilenum']\n else:\n raise ValueError('not implemented')\n\n # Extract the list of exposures on disk.\n self._exposure_files = self._getfilenames()\n\n if not dry_run:\n # Construct fiber output.\n self._exposure_table = self._buildtable()","def phot_aperture(input_file):\n #set the original directory\n original_path = os.getcwd()\n save_path = input_file['save_path']\n planet = input_file['exoplanet']\n #radii = np.arange(input_file['apertures'][0],input_file['apertures'][1],0.1)\n radii = np.array(input_file['apertures'])\n #change to save data reduction directory\n os.chdir(save_path)\n if not os.path.exists('phot_results'):\n os.makedirs('phot_results')\n tempo = time.time()\n print 'Starting aperture photometry'\n print 'Saving results on: '+save_path+'/phot_results/'\n \n #check the number of objects to make the photometry\n N_obj = len(input_file['pxpositions'])/2.\n print 'Number of objects = ',N_obj\n positions = [] #create the positions variable (X,Y) in pixels unit on the CCD\n for i in range(len(input_file['pxpositions'])):\n if i % 2 == 0: #if the number is a even (or not a odd), the turple is created\n positions.append((input_file['pxpositions'][i],input_file['pxpositions'][i+1]))\n print 'Radius from ',radii[0],' to ',radii[-1],'\\n'\n \n skysection = input_file['skysection']\n skysection[0] = int(skysection[0])\n skysection[1] = int(skysection[1])\n \n images = sorted(glob.glob('AB'+planet+'*.fits'))\n for radius in radii:\n flux_data = []\n for i in range(len(images)):\n im = fits.getdata(images[i],header=False)\n im = array(im,dtype='Float64')\n \n # ERROR\n #Traceback (most recent call last):\n # File \"ExoTRed.py\", line 105, in <module>\n # exotred.phot_aperture(input_file)\n # File \"./sources/ExoTRed_core.py\", line 637, in phot_aperture \n # File \"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/background/background_2d.py\", line 329, in __init__\n # self._calc_bkg_bkgrms()\n # File \"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/background/background_2d.py\", line 686, in _calc_bkg_bkgrms\n # bkg = self._interpolate_meshes(self._bkg1d)\n # File \"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/background/background_2d.py\", line 575, in _interpolate_meshes\n # f = ShepardIDWInterpolator(yx, data)\n # File \"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/utils/interpolation.py\", line 138, in __init__\n # raise ValueError('The number of values must match the number '\n # ValueError: The number of values must match the number of coordinates.\n\n # bkg = background.background_2d.Background2D(im,tuple(skysection))\n # bkg_data = bkg.background\n # bkg_rms = bkg.background_rms\n\n # phot_table = aperture_photometry(im - bkg_data, CircularAperture(positions, radius),\n # error=bkg_rms, method ='center')#,effective_gain=float(input_file['gain']))\n ####### SUBSTITUTE ROUTINE\n window = 100\n sky_size = im.shape\n sky_mean = float(np.median(im[int(skysection[1]-window):int(skysection[1]+window),int(skysection[0]-window):int(skysection[0]+window)]))\n bkg = np.random.poisson(sky_mean,sky_size)\n apertures = CircularAperture(positions, radius)\n phot_table = aperture_photometry(im, apertures, error=bkg)\n #######\n phot_table_flux = np.array([]) #saving results of aperture photometry\n for j in range(len(phot_table['aperture_sum'])):\n phot_table_flux = np.concatenate((phot_table_flux,np.array([phot_table['aperture_sum'][j]])),axis=0)\n phot_table_flux = np.concatenate((phot_table_flux,np.array([phot_table['aperture_sum_err'][j]])),axis=0)\n flux = np.concatenate((phot_table_flux,np.array([images[i]])),axis=0)\n # flux = [phot_table['aperture_sum'][0], phot_table['aperture_sum'][1],phot_table['aperture_sum_err'][0],\n # phot_table['aperture_sum_err'][1],images[i]]\n flux_data.append(flux)\n flux_data = DataFrame(flux_data)#,columns=['hoststar','refstar','hoststar_err','refstar_err','image'])\n flux_data.to_csv('./phot_results/'+planet+'_flux_radius_'+str(radius)+'.csv',index=False)\n use.update_progress((float(np.where(radii == radius)[0])+1.)/len(radii))\n print 'Time total = ',abs(time.time()-tempo)/60.,' minutes'\n os.chdir(original_path)","def motion_extraction():\n # iterate through frames\n global frame_height, frame_width\n global limb_coords, init_coords\n frame_count = 0\n has_frames, frame = capture.read()\n\n while has_frames:\n img_out = frame.copy()\n img_out = insert_padding(img_out, 14*14, 12*14)\n\n if frame_count == 0:\n # change global values of height and width\n frame_height = frame_height + 14*14*2\n frame_width = frame_width + 12*14*2\n get_start_positions(img_out)\n img_out2 = segment_red(img_out, 200, 130)\n #erode(img_out2, 4, 6)\n remove_artifacts(img_out2)\n #enhance_contrast(img_out2)\n\n if frame_count > 0:\n get_motion(prev_frame, img_out2, frame_count)\n\n prev_frame = img_out2.copy()\n frame_count += 1\n has_frames, frame = capture.read()","def main():\n test_image = load_image()\n\n pixelate_image(\n normalize_image(test_image)\n )\n pass","def image_reduction(self, FF_name, BF_name, DF_name):\n print '--------------------------------------------------------------------- image_reduction'\n start_time = time.time() # Take time\n\n # Construct 3D cube of light-frames and flat-frames with dim(number, x-dim, y-dim):\n FF_files = sort(glob.glob('{}{}*'.format(self.path, FF_name)))\n BF_files = sort(glob.glob('{}{}*'.format(self.path, BF_name)))\n DF_files = sort(glob.glob('{}{}*'.format(self.path, DF_name)))\n\n # Load images into an array:\n if self.imgtype=='fits':\n FF_i = array([pyfits.getdata(str(files)) for files in FF_files])\n BF_i = array([pyfits.getdata(str(files)) for files in BF_files])\n DF_i = array([pyfits.getdata(str(files)) for files in DF_files])\n if self.imgtype=='rgb' : # Combine RGB:\n FF_i = sum(array([asarray(Image.open(str(files))) for files in FF_files]), axis=3)\n BF_i = sum(array([asarray(Image.open(str(files))) for files in BF_files]), axis=3)\n DF_i = sum(array([asarray(Image.open(str(files))) for files in DF_files]), axis=3) \n \n # Median correction images:\n FF = median(FF_i, axis=0) \n BF = median(BF_i, axis=0)\n DF = median(DF_i, axis=0)\n \n # Median correction images:\n BF = median(BF_i, axis=0) # Master bias \n # Correct for bias:\n FF_m_b = median(FF_i-BF, axis=0)\n FF_i_b = FF_i - BF\n DF_b_m = median(DF_i-BF, axis=0) # Dark Current\n # Scale dark to science frames:\n hdulist = fits.open('{}'.format(str(DF_files[0])))\n t_exp_DF = hdulist[0].header['EXPTIME'] # Exposure time (CHANGE HEADER NAME!!!)\n DF = self.t_exp_LF/t_exp_DF * DF_b_m # Master dark \n # Correct flats:\n FF = median(FF_i_b - DF, axis=0) # Master flat\n # Final correction:\n CF_i = (self.LF_i - BF - DF)/FF # Calibrated science images \n print 'Filter done in time: %0.5f s' %(time.time()-start_time)\n \n # Plot if you like:\n if self.plot==1:\n FITS(FF, 'linear', 3); plt.show() \n FITS(BF, 'linear', 3); plt.show()\n FITS(DF, 'linear', 3); plt.show() \n FITS(self.LF_i[0], 'linear', 2); plt.show()\n FITS(CF_i[0], 'linear', 2); plt.show()\n \n # Save if you like:\n if self.save==1:\n [imsave('{}CF_%02d.{}'.format(self.path, self.imgtype) %i, CF_i[i]) for i in range(self.n)]","def __call__(self, rgbd_img_batch, color_id):\n color = vis.id2color[color_id]\n lower, upper = np.array(hsv_range[color])\n #print('debug: rgbd_img_batch shape: ', rgbd_img_batch.shape)\n\n color_imgs, depth_imgs = rgbd_img_batch[:, :3, :, :], rgbd_img_batch[:, 3, :, :]\n color_imgs = color_imgs.permute(0, 2, 3, 1) # NHWC\n color_imgs_np = color_imgs.cpu().numpy()\n\n n = color_imgs.shape[0]\n\n\n pcds = []\n for idx in range(n):\n depth_img = depth_imgs[idx]\n hsv_img = cv2.cvtColor(color_imgs_np[idx].astype('uint8'), cv2.COLOR_RGB2HSV)\n mask = cv2.inRange(hsv_img, lower, upper)\n mask = torch.from_numpy(mask)\n if self.use_cuda:\n mask = mask.cuda()\n mask_index = mask > 0\n \n #print('debug: {} points detected'.format(mask_index.sum().item()))\n if mask_index.sum() > 0:\n x_pcd = self.x_pix * depth_img / self.camera_f\n y_pcd = self.y_pix * depth_img / self.camera_f\n\n # apply mask\n x_pcd = -x_pcd[mask_index]\n y_pcd = -y_pcd[mask_index]\n z_pcd = -depth_img[mask_index]\n pcd = torch.stack([x_pcd, y_pcd, z_pcd], dim=0)\n pcd = self.camera_mat.mm(pcd) + self.camera_pos\n pcd = pcd.transpose(0, 1)\n pcd = sample_pcd(pcd, self.num_points)\n else:\n \"\"\"no points detected\"\"\"\n print('Debug: pix2pcd warning: no point detected')\n pcd = get_random_pcd(self.num_points)\n\n pcds.append(pcd)\n pcds = torch.stack(pcds, dim=0)\n return pcds","def adjust(self, image):\n ...","def generate_movie(filename, x_size=640, y_size=360, numframes=150, dpi=100):\n global timeflag\n timeflag = 1\n\n # Functions for red, green, and blue channels - where the magic happens!\n red_function = build_random_function(7, 9)\n green_function = build_random_function(7, 9)\n blue_function = build_random_function(7, 9)\n print \"red_function:\\t\" + str(red_function)\n print \"green_function:\\t\" + str(green_function)\n print \"blue_function:\\t\" + str(blue_function)\n\n for n in range(1, numframes+1):\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n t = remap_interval(n, 0, numframes, -1, 1)\n pixels[i, j] = (\n color_map(evaluate_random_function(red_function, x, y, t)),\n color_map(evaluate_random_function(green_function, x, y, t)),\n color_map(evaluate_random_function(blue_function, x, y, t))\n )\n im.save(\"movie_images/\"+'%03d'%n+\".png\")\n\n os.system(\"echo 'yes'|avconv -r 24 -i movie_images/%03d.png -vb 20M myart.mp4\")\n\n \"\"\"fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.set_aspect('equal')\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n\n im = Image.new(\"RGB\", (x_size, y_size))\n\n def update_img(n):\n # Functions for red, green, and blue channels - where the magic happens!\n red_function = build_random_function(7, 9)\n green_function = build_random_function(7, 9)\n blue_function = build_random_function(7, 9)\n\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (\n color_map(evaluate_random_function(red_function, x, y, n)),\n color_map(evaluate_random_function(green_function, x, y, n)),\n color_map(evaluate_random_function(blue_function, x, y, n))\n )\n im.save(\"test.png\")\n return im\n ani = animation.FuncAnimation(fig, update_img, numframes, interval=24) #TODO: FIX THIS\n writer = animation.writers['avconv'](fps=24)\n\n ani.save(filename, writer=writer, dpi=dpi)\"\"\"","def timeWarp(destExposure, srcExposure, warpingControl):\n startTime = time.time()\n for nIter in range(1, MaxIter + 1):\n goodPix = afwMath.warpExposure(\n destExposure, srcExposure, warpingControl)\n endTime = time.time()\n if endTime - startTime > MaxTime:\n break\n\n return (endTime - startTime, nIter, goodPix)","def __call__(self, images, targets):\n pass","def prepare_output(self):\n self.output = np.copy(self.image)\n self._highlight_qr_codes()\n self._write_overlay_info()","def Advance():\n warp.step()","def doDrizSeparate(self, pars):\n \n # Start by applying input parameters to redefine\n # the output frame as necessary\n for p in self.assoc.parlist:\n\n # First do some cleaning up, in case you are restarting...\n fileutil.removeFile(p['outsingle'])\n if (p['outsweight'] != ''):\n fileutil.removeFile(p['outsweight'])\n\n # NB DO NOT USE \"tophat\" unless pixfrac is sufficiently\n # large (> sqrt(2))\n \n p['fillval'] = pars['fillval']\n \n # Pass in the new wt_scale value\n p['wt_scl'] = pars['wt_scl']\n\n if (p['single_driz_mask'] == None and self.static_mask != None):\n p['single_driz_mask'] = self.static_mask.getMask(p['image'].signature())\n \n # 'in_units' will always be counts given that the input is converted to 'electrons' in call cases\n p['in_units'] = 'counts'\n \n print(\"\\ndrizzle data='\"+p['data']+\"' outdata='\"+p['outsingle']+\"' outweig='\"+p['outsweight']+\n \"' in_mask='static_mask\"+\"' kernel='\"+p['kernel']+\n \"' outnx=\"+str(p['outnx'])+\" outny=\"+str(p['outny'])+\" xsh=\"+str(p['xsh'])+\" ysh=\"+str(p['ysh'])+\n \" scale=\"+str(p['scale'])+\" pixfrac=\"+str(p['pixfrac'])+\" rot=\"+str(p['rot'])+\n \" coeffs='\"+p['coeffs']+\"' wt_scl='\"+str(p['wt_scl'])+\"' align='center' shft_fr='output' shft_un='output'\"+\n \" out_un='\"+p['units']+\"' expkey='\"+\"EXPTIME\"+\"' fillval='\"+str(p['fillval'])+\"'\"+\n \" xgeoim='\"+p['xgeoim']+\"' ygeoim='\"+p['ygeoim']+\"'\\n\")\n\n # Perform separate drizzling now that all parameters have been setup...\n self.assoc.run(single=True,save=True,build=False)\n\n # Now that we are done with the static mask, delete it...\n del self.static_mask","def extract(self, files):\n for i in range(len(files)):\n print(files[i])\n img = cv2.imread('{}/{}'.format('{}/{}/{}'.format(DIR_2DST_Mask, self.patient, self.plan), files[i]), 0)\n\n \"\"\"\n Find the indices of array elements that are non-zero, i.e,\n find the pixels' positions that represents the respiratory\n functions (pixels in the respiratory function are brighter).\n \"\"\"\n color_pts = np.argwhere(img > 70)\n\n \"\"\"\n Sorts the pixels according to their x coordenate.\n Obs: np.argwhere inverts x and y, it's like (y, x), because of it,\n the parameter of itemgetter is 1 (to get x coordinate)\n \"\"\"\n lcolor_pts = sorted(color_pts.tolist(), key=itemgetter(1))\n\n \"\"\"\n If there is no pixel representing the respiratory function\n (i.e., lighter pixel) it creates an empty image (without any\n respiratory function)\n \"\"\"\n if len(lcolor_pts) == 0:\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\n\n cv2.imwrite('{}/{}/{}/{}'.format(\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\n\n # file = open(\n # '{}/{}/{}/points.txt'.format(DIR_2DST_Diaphragm, self.patient, self.plan), 'a')\n # file.write(\"{}:{}\\n\".format(files[i], []))\n # file.close()\n\n continue\n\n # Reverse the coordinates and store the result in lordered_pts list\n lordered_pts = []\n for j in range(len(lcolor_pts)):\n lordered_pts.append(lcolor_pts[j][::-1])\n\n \"\"\"\n Convert pixels coordinates into a tuples and check which column\n has pixels that corresponding to diaphragmatic level\n Obs. There are some columns that doesnt have any pixel that\n correpond to diaphragmatic level.\n \"\"\"\n # Columns that have a pixel corresponding diaphragmatic level\n lcolumn_available = []\n for j in range(len(lordered_pts)):\n lordered_pts[j] = tuple(lordered_pts[j])\n lcolumn_available.append(lordered_pts[j][0])\n lcolumn_available = list(set(lcolumn_available))\n # print(\"Ordered points: \", lordered_pts)\n # print(\"Columns available: \", lcolumn_available)\n\n \"\"\"\n If there is not enough columns to build a respiratory pattern,\n create a blank image\n \"\"\"\n if len(lcolumn_available) < 20:\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\n cv2.imwrite('{}/{}/{}/{}'.format(\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\n continue\n\n \"\"\"\n If there are no pixel that corresponding diaphragmatic level in the\n first column, assign to it the value of the second y coordinate\n \"\"\"\n if lcolumn_available[0] is not 0:\n y = max(\n [x for x in lordered_pts if x[0] == lcolumn_available[0]],\n key=itemgetter(1))[1]\n lordered_pts.insert(0, (0, y))\n lcolumn_available.insert(0, 0)\n\n \"\"\"\n If there are no pixel that corresponding diaphragmatic level in the\n last column, assign to it the value of the penultimate y coordinate\n available\n \"\"\"\n if lcolumn_available[-1] is not 49:\n lordered_pts.append(\n (49, lordered_pts[len(lcolumn_available)][1]))\n lcolumn_available.append(49)\n\n \"\"\"\n Get the biggest y value in each column that represents the\n diaphragmatic level\n \"\"\"\n column = 0\n lcolumn = []\n ldiaphragm_pts = []\n for j in range(50):\n # Get the column's points\n lcolumn = [x for x in lordered_pts if x[0] == column]\n # print('{}: {}'.format(j, lcolumn))\n\n if len(lcolumn) > 0:\n ldiaphragm_pts.append(\n max(lcolumn, key=itemgetter(1))) # Get the biggest y\n else:\n # Get the y value from the previous column\n lcolumn_available.insert(column, column)\n ldiaphragm_pts.append((column, ldiaphragm_pts[-1][1]))\n column += 1\n lcolumn = []\n\n # Draw diaphragmatic level\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\n j = 0\n while(j < len(lcolumn_available) - 1):\n cv2.line(\n diaphragmatic_lvl,\n ldiaphragm_pts[j], ldiaphragm_pts[j + 1],\n (0, 0, 255), 1)\n j = j + 1\n\n lcolumn_available = []\n\n print(\"Diaphragmatic's points: \", ldiaphragm_pts)\n cv2.imshow('Diaphragmatic level', diaphragmatic_lvl)\n cv2.waitKey(0)\n cv2.destroyAllWindows()\n cv2.imwrite('{}/{}/{}/{}'.format(\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\n\n # file = open('{}/{}/{}/points.txt'.format(DIR_2DST_Diaphragm, self.patient, self.plan), 'a')\n # file.write(\"{}:{}\\n\".format(files[i], ldiaphragm_pts))\n # file.close()\n\n # return ldiaphragm_pts","def sweep_image_model():\n for c1 in [4, 8, 16]:\n for c2 in [2, 4]:\n for c3 in [2, 4]:\n for c4 in [1, 2]:\n flags = flag_reader.read_flag()\n print(c1)\n flags.channel_list = c1 * np.array([1, c2, c2*c3, c2*c3*c4])\n print('channel list = ', flags.channel_list)\n flags.last_dim = flags.channel_list[-1]\n flags.model_name = flags.data_set + '_channel_' + str(flags.channel_list).replace('[','').replace(']','').replace(' ','_') + \\\n '_dim_last_' + str(flags.last_dim) + '_ind_' + str(flags.comp_ind) + \\\n '_lr_{}_decay_{}_reg_{}_bs_{}'.format(flags.lr, flags.lr_decay_rate, flags.reg_scale, flags.batch_size)\n print(flags.model_name)\n training_from_flag(flags)","def pre_processing_image(img):\n\n #print(img.shape)\n # apply gamma correction and show the images\n #adjusted = adjust_gamma(img, gamma=0.65)\n\n adjusted = exposure.adjust_gamma(img, gamma=1.65)\n #print(adjusted.shape)\n\n # log transform of image\n\n logarithmic_corrected = exposure.adjust_log(adjusted, 1)\n #print(logarithmic_corrected.shape)\n\n # denoising\n #dst2 = cv2.fastNlMeansDenoisingColored(logarithmic_corrected, None, 10, 10, 7, 21)\n #print(dst2.shape)\n dst2 = logarithmic_corrected\n return dst2","def exposure(frameType, expTime):\n\n blobEvent.clear() \n\n # set the specified frame type\n if frameType.lower() == 'light':\n ccd_frame[0].s = PyIndi.ISS_ON\n ccd_frame[1].s = PyIndi.ISS_OFF\n ccd_frame[2].s = PyIndi.ISS_OFF\n ccd_frame[3].s = PyIndi.ISS_OFF \n indiclient.sendNewSwitch(ccd_frame)\n elif frameType.lower() == 'bias':\n ccd_frame[0].s = PyIndi.ISS_OFF\n ccd_frame[1].s = PyIndi.ISS_ON\n ccd_frame[2].s = PyIndi.ISS_OFF\n ccd_frame[3].s = PyIndi.ISS_OFF \n indiclient.sendNewSwitch(ccd_frame)\n elif frameType.lower() == 'dark':\n ccd_frame[0].s = PyIndi.ISS_OFF\n ccd_frame[1].s = PyIndi.ISS_OFF\n ccd_frame[2].s = PyIndi.ISS_ON\n ccd_frame[3].s = PyIndi.ISS_OFF \n indiclient.sendNewSwitch(ccd_frame)\n elif frameType.lower() == 'flat':\n ccd_frame[0].s = PyIndi.ISS_OFF\n ccd_frame[1].s = PyIndi.ISS_OFF\n ccd_frame[2].s = PyIndi.ISS_OFF\n ccd_frame[3].s = PyIndi.ISS_ON \n indiclient.sendNewSwitch(ccd_frame)\n\n # set the value for the next exposure\n ccd_exposure[0].value=expTime\n\n indiclient.sendNewNumber(ccd_exposure)\n\n # wait for the exposure\n blobEvent.wait()\n\n for blob in ccd_ccd1:\n # pyindi-client adds a getblobdata() method to IBLOB item\n # for accessing the contents of the blob, which is a bytearray in Python\n image_data=blob.getblobdata()\n\n # write the byte array out to a FITS file\n global imgNum\n global imgName\n imgNum += 1\n fileName = fileDir+'raw-'+str(imgNum).zfill(8)+'.fits'\n f = open(fileName, 'wb')\n f.write(image_data)\n f.close()\n imgName = fileName\n \n return fileName","def forward_test(self, img, img_metas, **kwargs):","def main():\n original = SimpleImage('images/mt-rainier.jpg')\n original.show()\n reflected = make_reflected('images/mt-rainier.jpg')\n reflected.show()","def run(self):\n\n # need to think about outpath\n\n # Make sure all files are here and okay...\n\n if not self.config.galfile_pixelized:\n raise ValueError(\"Code only runs with pixelized galfile.\")\n\n self.config.check_files(check_zredfile=True, check_bkgfile=True, check_bkgfile_components=True, check_parfile=True, check_zlambdafile=True)\n\n # Compute the border size\n\n self.config.border = self.config.compute_border()\n\n self.config.d.hpix = [self.pixel]\n self.config.d.nside = self.nside\n self.config.d.outbase = '%s_%d_%05d' % (self.config.outbase, self.nside, self.pixel)\n\n # Do the run\n self.config.start_file_logging()\n self.config.logger.info(\"Running redMaPPer on pixel %d\" % (self.pixel))\n\n firstpass = RunFirstPass(self.config)\n\n if not os.path.isfile(firstpass.filename):\n firstpass.run()\n firstpass.output(savemembers=False, withversion=False)\n else:\n self.config.logger.info(\"Firstpass file %s already present. Skipping...\" % (firstpass.filename))\n\n self.config.catfile = firstpass.filename\n\n # Clear out the firstpass memory\n del firstpass\n\n like = RunLikelihoods(self.config)\n\n if not os.path.isfile(like.filename):\n like.run()\n like.output(savemembers=False, withversion=False)\n else:\n self.config.logger.info(\"Likelihood file %s already present. Skipping...\" % (like.filename))\n\n self.config.catfile = like.filename\n\n # Clear out the likelihood memory\n del like\n\n perc = RunPercolation(self.config)\n\n if not os.path.isfile(perc.filename):\n perc.run()\n perc.output(savemembers=True, withversion=False)\n else:\n self.config.logger.info(\"Percolation file %s already present. Skipping...\" % (perc.filename))\n\n self.config.stop_file_logging()","def use_effect(self):\n if self.preview_name in FILTERS:\n photo = Image.open(self.path.url[1:])\n preview = photo.filter(FILTERS.get(self.preview_name))\n preview.save(self.path.url[1:])","def update(self):\r\n\r\n # Update the vision frames in the system\r\n self._system.update()\r\n\r\n # Create blank PIL images to hold the video streams\r\n layered = PIL.Image.new('RGBA', (400, 400))\r\n stacked = PIL.Image.new('RGBA', (200, 800))\r\n control = PIL.Image.new('RGBA', (600, 800))\r\n\r\n focalpoint = self._system[self._appString[\"device\"].get()].focalpoint()\r\n # print(focalpoint)\r\n\r\n # Get each vision key and vision for the selected device\r\n visionList = [(visionKey, vision) for visionKey, vision in self._system[self._appString[\"device\"].get()]]\r\n\r\n # Loop through each vision in the vision list\r\n for i, (visionKey, vision) in enumerate(visionList):\r\n\r\n # Grab the frames from the vision when it is \"curr\"\r\n frameList = [frame for frameKey, frame in vision if frameKey==self._appString[\"frame\"].get()]\r\n\r\n # Loop through each frame in the frame list\r\n for frame in frameList:\r\n\r\n # Get the properties and turn the image into RGBA\r\n ratio, size = vision.properties()\r\n rgbFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA)\r\n\r\n # print(rgbFrame.shape)\r\n width, height, channels = rgbFrame.shape\r\n\r\n # Paste the images together in layered\r\n\r\n imgFrame = PIL.Image.fromarray(cv2.resize(rgbFrame, (int(400 * ratio), int(400 * ratio))))\r\n layered.paste(imgFrame, (int(200 * (1 - ratio)), int(200 * (1 - ratio))))\r\n\r\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200 / width)), int(200 * (1 - ratio) - focalpoint[1] * (200 / height))))\r\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200 // width)), int(200 * (1 - ratio) - focalpoint[1] * (200 // height))))\r\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (ratio ** -1)), int(200 * (1 - ratio) - focalpoint[1] * (ratio ** -1))))\r\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200/width) / ratio), int(200 * (1 - ratio) - focalpoint[1] * (200/height) / ratio)))\r\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200 / width)), int(200 * (1 - ratio) - focalpoint[1] * (200 / height))))\r\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (ratio ** -1) / 200), int(200 * (1 - ratio) - focalpoint[1] * (ratio ** -1) / 200)))\r\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (400//width * (1- ratio))), int(200 * (1 - ratio) - focalpoint[1] * (400//height * (1 - ratio)))))\r\n\r\n # Paste the images together in stacked\r\n imgFrame = PIL.Image.fromarray(cv2.resize(rgbFrame, (200, 200)))\r\n stacked.paste(imgFrame, (0, 200 * i))\r\n\r\n # Add the stacked image to the canvas\r\n self._pilFrames[\"stacked\"] = PIL.ImageTk.PhotoImage(image=stacked)\r\n self._appCanvas[\"stacked\"].create_image(100, 0, image=self._pilFrames[\"stacked\"], anchor=tkinter.NW)\r\n\r\n # Add the layered image to the canvas\r\n self._pilFrames[\"layered\"] = PIL.ImageTk.PhotoImage(image=layered)\r\n self._appCanvas[\"layered\"].create_image(0, 0, image=self._pilFrames[\"layered\"], anchor=tkinter.NW)\r\n\r\n # Add the control image to the canvas\r\n imgFrame = cv2.cvtColor(self._system[self._appString[\"device\"].get()][self._appString[\"vision\"].get()][self._appString[\"frame\"].get()], cv2.COLOR_BGR2RGBA)\r\n control = PIL.Image.fromarray(cv2.resize(imgFrame, (600, 600)))\r\n self._pilFrames[\"control\"] = PIL.ImageTk.PhotoImage(image=control)\r\n self._appCanvas[\"control\"].create_image(100, 90, image=self._pilFrames[\"control\"], anchor=tkinter.NW)\r\n\r\n # Continue to update with a delay of 15\r\n self.after(15, self.update)","def update(self):\n if (self.j + self.step >= self.image.shape[0]) and (self.i + self.step >= self.image.shape[1]):\n self.no_more_crops = True\n elif self.i + self.step >= self.image.shape[1]:\n self.i = 0\n self.j += self.step\n else:\n self.i += self.step","def transform(self, previousimage):","def step(self, amt=1):\n \n # For checking if all the animations have their framse looked at\n #activewormind = [i for i, x in enumerate(self._idlelist) if x == False]\n #print \"Worm {} at {:5g}\".format(activewormind, 1000*(time.time() - starttime))\n # save times activated for each worm \n [self.timedata[i].append(1000*(time.time() - starttime)) for i, x in enumerate(self._idlelist) if x == False]\n \n #self._led.buffer = [0] * 480\n self._led.pixheights = [-100] * self._led.numLEDs\n #print type(self._led.buffer)\n for ledcopy in self._ledcopies:\n # self._led.buffer = map(ixor, self._led.buffer, ledcopy.buffer)\n # use pixheights but assume all buffers same size\n # print ledcopy.driver[0].pixheights\n for pix in range(self._led.numLEDs):\n #for ledcopy in self._ledcopies:\n if self._led.pixheights[pix] == ledcopy.driver[0].pixheights[pix]:\n for i in range(3):\n self._led.buffer[3*pix + i] ^= ledcopy.buffer[3*pix + i]\n elif self._led.pixheights[pix] < ledcopy.driver[0].pixheights[pix]:\n for i in range(3):\n self._led.buffer[3*pix + i] = ledcopy.buffer[3*pix + i]\n self._led.pixheights[pix] = ledcopy.driver[0].pixheights[pix] \n self._step += 1","def process(image):\n pass","def cleanup(self):\n self.subpixel, self.pixel = self.stepup(self.subpixel, self.pixel, AxisDistance.pixelsize)\n self.pixel, self.tile = self.stepup(self.pixel, self.tile, AxisDistance.tilesize)","def process_died_event(self, event):\n old_point = self.sprites[event.id][0]\n self.img[old_point.y, old_point.x] = self.sprite_colors[\"Background\"]\n del self.sprites[event.id]","def aperphot(fn, timekey=None, pos=[0,0], dap=[2,4,6], mask=None, verbose=False, nanval=999, resamp=None, retfull=False):\n # 2009-09-14 10:49 IJC: Created\n # 2010-01-15 14:20 IJC: Added numpy \"_string\" check\n # 2011-12-29 12:01 IJMC: Added peak pixel values to photometry report.\n # 2012-01-25 11:26 IJMC: Adding \"resamp\" option -- thanks to\n # K. Stevenson and J. Harrington of UCF for\n # the suggestion.\n # 2012-02-26 11:53 IJMC: Now return 'ntarg' and 'nsky' -- number of pixels used.\n # 2012-06-07 08:27 IJMC: 'peak' values are now corrected for the\n # resampling factor.\n # 2012-07-03 10:35 IJMC: Fixed a key bug: frames were not\n # correctly background-subtracted when\n # applying partial-pixel resampling.\n # 2012-10-19 13:41 IJMC: Documented 'retfull' option; changed default.\n # 2013-03-20 09:21 IJMC: More error-checking for saving header\n # keywords. Thanks to A. Weigel @\n # ETH-Zurich for catching this!\n\n from numpy import meshgrid, median,isfinite,sort,ndarray,string_\n import numpy as np\n import pyfits\n #from analysis import fixval\n from os import path\n from scipy import interpolate\n\n thisobs = phot()\n x0, y0 = pos\n dap_targ, dap_skyinner, dap_skyouter = dap\n if resamp is None or resamp<1:\n resamp = 1\n else:\n resamp = float(resamp)\n \n # Determine size:\n if isinstance(fn,str):\n nx = pyfits.getval(fn, 'NAXIS1')\n ny = pyfits.getval(fn, 'NAXIS2')\n elif isinstance(fn,ndarray):\n nx,ny = fn.shape\n\n nx0, ny0 = nx, ny\n nx = ((nx - 1)*resamp + 1.) # Avoid resampling at pixel locations\n ny = ((ny - 1)*resamp + 1.) # outside the original boundaries.\n\n # Generate or load masks:\n if mask==None:\n xx,yy = meshgrid(np.arange(ny)/resamp, np.arange(nx)/resamp)\n mask_targ = makemask(xx, yy, (x0, y0, dap_targ))\n mask_s1 = makemask(xx, yy, (x0,y0, dap_skyinner))\n mask_s2 = makemask(xx, yy, (x0,y0, dap_skyouter))\n mask_sky = mask_s2 - mask_s1\n else:\n mask_targ = mask==1\n mask_sky = mask==2\n if resamp>1:\n print \"In aperphot, resamp>1 and user-specified mask passed in... beware!\"\n\n # Load data frame:\n thisobs = phot()\n if isinstance(fn,ndarray):\n frame = fn\n elif isinstance(fn, str) or isinstance(fn,string_):\n if not path.isfile(fn):\n print \"file %s not found! exiting...\" % fn\n return thisobs\n frame = pyfits.getdata(fn)\n fixval(frame, nanval)\n\n # Resample data frame\n if resamp>1:\n frame0 = frame.copy()\n xx0 = range(nx0)\n yy0 = range(ny0)\n x1,y1 = np.arange(nx)/resamp, np.arange(ny)/resamp\n rectspline = interpolate.fitpack2.RectBivariateSpline(xx0, yy0, frame0, kx=1, ky=1, s=0)\n frame = rectspline(x1, y1)\n\n #from pylab import *\n #pdb.set_trace()\n # Measure background and aperture photometry\n thisbg, thisebg = estbg(frame, mask=mask_sky, plotalot=verbose, rout=[3,99])\n thisphot = (mask_targ*(frame - thisbg)).sum() /resamp/resamp\n peak = frame.max()\n peak_targ = (mask_targ * frame).max()\n peak_annulus = (mask_sky * frame).max()\n\n thisobs.bg=thisbg\n thisobs.ebg=thisebg\n thisobs.bgstr='phot.estbg: SDOM on bg histogram mean & dispersion after outlier rejection'\n thisobs.phot=thisphot\n thisobs.photstr='by-hand background-subtracted aperture photometry'\n thisobs.ntarg = mask_targ.sum()/resamp/resamp\n thisobs.nsky = mask_sky.sum()/resamp/resamp\n\n thisobs.peak = peak\n thisobs.peak_targ = peak_targ\n thisobs.peak_annulus = peak_annulus\n thisobs.peakstr = 'peak pixel value in frame'\n thisobs.peak_targstr = 'peak pixel value in target aperture'\n thisobs.peak_annulusstr = 'peak pixel value in sky annulus'\n thisobs.position = pos\n thisobs.positionstr = 'user-specified, zero-indexed pixel coordinates.'\n if isinstance(fn, str):\n header = pyfits.getheader(fn)\n if not timekey==None:\n if timekey in header: \n thisobs.time=header['timekey']\n thisobs.timestr='heliocentric modified julian date'\n if 'object' in header: thisobs.object = header['object']\n if 'exptime' in header: thisobs.exptime = header['exptime']\n thisobs.aper = dap\n thisobs.aperstr = 'target, inner, outer aperture diameters, in pixels.'\n thisobs.filename=fn\n thisobs.resamp = resamp\n if retfull:\n thisobs.mask_targ = mask_targ\n thisobs.mask_sky = mask_sky\n thisobs.frame = frame\n\n if verbose:\n from pylab import figure, colorbar\n from nsdata import imshow\n figure(); imshow(frame*mask_targ); colorbar()\n figure(); imshow(frame*mask_sky); colorbar()\n\n return thisobs","def start(self):\n self.frame = 0\n self._init_level(1)\n self.reward = 0\n self.pcontinue = 1\n self.ghost_speed = self.ghost_speed_init\n return self._make_image(), self.reward, self.pcontinue","def hook_func(module, input, output):\n image_name = get_image_name_for_hook(module)\n data = output.clone().detach()\n data = data.permute(1, 0, 2, 3)\n vutil.save_image(data, image_name, pad_value=0.5)","def augment(self, image):\n pass","def post_process(self):\n\t\ti_s = 0\n\t\ti_e = 0\n\t\tif self.trans_t_dict[0][1] == 0:\n\t\t\tif len(self.noise_itv) == 0:\n\t\t\t\tself.trans_t_dict[0][1] = self.fake_start_offset\n\t\t\telse:\n\t\t\t\tself.trans_t_dict[0][1] = self.noise_itv[0][1] # start_offset\n\t\t\tself.trans_t_dict[0][2] = 0.1\n\t\tif self.trans_t_dict[len(self.trans_t_dict)-1][1] == 0:\n\t\t\tif len(self.noise_itv) == 0:\n\t\t\t\tself.trans_t_dict[len(self.trans_t_dict)-1][1] = self.fake_end_offset\n\t\t\telse:\n\t\t\t\tself.trans_t_dict[len(self.trans_t_dict)-1][1] = self.noise_itv[-1][0] # end_offset\n\t\t\tself.trans_t_dict[len(self.trans_t_dict)-1][2] = 0.1\n\n\t\twhile i_s < len(self.trans_t_dict):\n\t\t\twhile i_s < len(self.trans_t_dict) and self.trans_t_dict[i_s][1] != 0:\n\t\t\t\ti_s += 1\n\t\t\tif i_s == len(self.trans_t_dict):\n\t\t\t\ti_e = len(self.trans_t_dict)\n\t\t\tif i_s < len(self.trans_t_dict):\n\t\t\t\ti_s -= 1\n\t\t\t\ti_e = i_s + 1\n\t\t\t\twhile i_e < len(self.trans_t_dict) and self.trans_t_dict[i_e][1] == 0:\n\t\t\t\t\ti_e += 1\n\t\t\t\tif i_e == len(self.trans_t_dict):\n\t\t\t\t\tbreak\n\n\t\t\t\t# incorperate the noise inverval\n\t\t\t\ts_time = self.trans_t_dict[i_s][1]\n\t\t\t\te_time = self.trans_t_dict[i_e][1]\n\t\t\t\t\"\"\"\n\t\t\t\tfor ts in self.noise_itv:\n\t\t\t\t\tif len(ts) == 2:\t\t\t\t\t\t\n\t\t\t\t\t\ttime1 = ts[0]\n\t\t\t\t\t\ttime2 = ts[1]\n\t\t\t\t\t\tif s_time < time1 and time2 < e_time:\n\t\t\t\t\t\t\te_time = min(e_time, time1)\n\t\t\t\t\telse:\n\t\t\t\t\t\ttime0 = ts[0]\n\t\t\t\t\t\tif s_time < time0 and time0 < e_time:\n\t\t\t\t\t\t\te_time = min(e_time, time0)\n\t\t\t\t\"\"\"\n\t\t\t\tchar_len = 0\n\t\t\t\tfor i in range(i_s, i_e):\n\t\t\t\t\tchar_len += len(self.trans_t_dict[i][0])\n\t\t\t\t# ratio = float(self.trans_t_dict[i_e][1]-self.trans_t_dict[i_s][1]) / float(char_len)\n\t\t\t\tratio = float(e_time - s_time) / float(char_len)\n\t\t\t\tchar_len = 0\n\t\t\t\t# s_time = self.trans_t_dict[i_s][1]\n\t\t\t\tfor i in range(i_s+1, i_e):\n\t\t\t\t\tchar_len += len(self.trans_t_dict[i-1][0])\n\t\t\t\t\tself.trans_t_dict[i][1] = s_time + char_len * ratio\n\t\t\t\t\tself.trans_t_dict[i][2] = len(self.trans_t_dict[i][0]) * ratio\n\t\t\ti_s = i_e","def apply_filter(self, image):\n pass","def preprocess(args):\n \n # Set up options\n src = args.src\n dest = args.dest\n collect_path = args.collect_path\n formats = args.formats\n ref_img_path = args.ref_img_path\n width = args.width\n debug = args.debug\n if debug:\n print args.__dict__\n # Make necessary directories if there is not.\n if not os.path.exists(dest):\n os.mkdir(dest)\n if not os.path.exists(collect_path):\n os.mkdir(collect_path)\n\n # Open referce image and trying to find the face in it.\n try:\n ref_img_origin = Image.open(os.path.abspath(ref_img_path))\n except IOError as e:\n print \"[IOError] Can't open the reference imgae: {}\".format(ref_img_path)\n print \"[Info] Terminating....\"\n return 1\n\n face_ref_coor, degree_ref = segment_tools.faces_positions(ref_img_origin)\n \n # Only one face is allowed in referece image. Raise error if it isn't.\n # Crop the origin image to get the face image.\n if face_ref_coor.shape[0] > 1:\n raise MultiFaceError(\"Detect multiple faces in reference image. There should be only one face.\")\n face_ref = segment_tools.crop_img(ref_img_origin, face_ref_coor[0], offset = True)\n\n # Adjust that image to make eyes lie on horizontal line.\n try:\n eye_angle = face_align_tools.eyes_horizon_angle(face_ref)\n except segment_tools.NotDetectedError:\n print \"[NotDetectedError] This reference image is not good enough. The program can't make the eyes horizontal.\"\n print \"[NotDetectedError] Pleas use another reference image.\"\n print \"Terminating....\"\n return 1\n\n total_degree = eye_angle + degree_ref\n img_ref_rotated = ref_img_origin.rotate(total_degree, resample = Image.CUBIC)\n face_ref_coor, _ = segment_tools.faces_positions(img_ref_rotated)\n face_ref = segment_tools.crop_img(img_ref_rotated, face_ref_coor[0], offset = True)\n \n # Resize the reference face to desired witdh (but preserve the width/heigh ratio.)\n ref_width, ref_heigh = face_ref.size\n face_ref = face_ref.resize((width, ref_heigh*width/ref_width))\n if debug:\n face_ref.show()\n \n ref_file_name = os.path.basename(ref_img_path)\n face_ref.save(os.path.join(os.path.abspath(dest), \"ref_\" + ref_file_name))\n print \"[Info] Complete preprocess of reference image.\"\n\n # Walk through the source directory.\n print \"[Info] Start processing files in {src}.\".format(src = os.path.abspath(src))\n for rel_path, dir_names, file_names in os.walk(os.path.abspath(src)):\n for filename in file_names:\n if np.any(map(filename.endswith, formats)):\n file_path = os.path.join(os.path.abspath(rel_path), filename)\n print \"[Info] Start processing {file_path}.\".format(file_path = file_path)\n try:\n target_img_origin = Image.open(file_path)\n except IOError as e:\n print \"[IOError] Can not open {}\".format(file_path)\n print \"[Info] Passing this image.\"\n continue\n \n # Try to find faces in target image. If don't, copy it to collection directory.\n try:\n faces_target_coors, degree_target = segment_tools.faces_positions(target_img_origin)\n except segment_tools.NotDetectedError as e:\n print \"[NotDetectedError] Does not find any face in {filename}. Collect it into {collect_path}\".format(filename = filename, collect_path = collect_path)\n target_img_origin.save(os.path.join(os.path.abspath(collect_path), filename))\n continue # Brake loop for not finding any face in the picture.\n\n # Adjust all found faces to make them just.\n target_img_rotated = target_img_origin.rotate(degree_target, resample = Image.CUBIC)\n for face_coor in faces_target_coors:\n temp_img = segment_tools.crop_img(target_img_rotated, face_coor, offset=True)\n try:\n eyes_degree = face_align_tools.eyes_horizon_angle(temp_img)\n except segment_tools.NotDetectedError:\n eyes_degree = 0\n face_target = temp_img.rotate(eyes_degree)\n temp_file_name = random_prefix() + filename\n if debug:\n face_target.show()\n face_target.save(os.path.join(os.path.abspath(dest), temp_file_name))\n temp_aligned_file_name = \"aligned_\" + temp_file_name\n try:\n face_target_aligned = face_align_tools.face_align(face_ref, face_target)\n face_target_aligned.save(os.path.join(os.path.abspath(dest), temp_aligned_file_name))\n except segment_tools.NotDetectedError:\n print \"[AlignError] Can't align face. Moving to {collection}.\".format(collection = collect_path)\n face_target.save(os.path.join(os.path.abspath(collect_path), \"not_aligned_\" + temp_file_name))\n print \"[Info] Saving {}\".format(os.path.join(os.path.abspath(collect_path), \"not_aligned_\" + temp_file_name))\n continue\n masked_target_img = segment_tools.mask_img(target_img_rotated, faces_target_coors)\n\n if debug:\n masked_target_img.show()\n masked_target_img.save(\"masked.jpg\")\n \n try:\n while True:\n temp_face_coors, temp_degree = segment_tools.faces_positions(masked_target_img)\n temp_img = masked_target_img.rotate(temp_degree, resample = Image.CUBIC)\n if debug:\n print \"temp_face_coors\", temp_face_coors\n print \"[Info] Multiple faces are found in {file_path}\".format(file_path = file_path)\n for face_coor in temp_face_coors:\n temp_face = segment_tools.crop_img(temp_img, face_coor, offset = True)\n eye_angle = face_align_tools.eyes_horizon_angle(temp_face)\n face_target = temp_face.rotate(eye_angle, resample = Image.CUBIC)\n if debug:\n face_target.show()\n face_target_aligned = face_align_tools.face_align(face_ref, face_target)\n temp_file_name = random_prefix() + filename\n temp_aligned_file_name = \"aligned_\" + temp_file_name\n print \"[Info] Sucessful aligned {}\".format(temp_file_name)\n if debug:\n masked_target_img.show()\n except segment_tools.NotDetectedError:\n file_path = os.path.join(os.path.abspath(rel_path), filename)\n print \"[Info] Complete searching faces in {file_path}\".format(file_path = file_path)","def test_rolling_before_analysis(self):\n cheese = TomoCheese.from_demo_images()\n cheese.analyze()\n original_roi_1 = copy.copy(cheese.module.rois[\"1\"].pixel_value)\n for img in cheese.dicom_stack:\n img.roll(direction=\"x\", amount=20)\n cheese.analyze()\n new_roi_1 = cheese.module.rois[\"1\"].pixel_value\n assert math.isclose(original_roi_1, new_roi_1, abs_tol=3)","def test_do_manga_dither_after_sequence(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['boss_science'])\n dither = 'N'\n cmdState = self.actorState.doMangaSequence\n cmdState.reinitialize(self.cmd)\n cmdState.count = 1\n cmdState.dithers = 'NSE'\n cmdState.reset_ditherSeq()\n self.cmd.verbose = False\n masterThread.do_apogeemanga_sequence(self.cmd, cmdState, myGlobals.actorState)\n self.cmd.reset()\n self.cmd.verbose = self.verbose\n self._do_manga_dither(4, 28, 0, 0, dither=dither)","def augmenter(x, y):\n # Note that we only use fliprots along axis=(1,2), i.e. the yx axis\n # as 3D microscopy acquisitions are usually not axially symmetric\n x, y = random_fliprot(x, y, axis=(1, 2))\n x = random_intensity_change(x)\n return x, y","def go():\n ##########\n #\n # MB19284\n #\n ##########\n\n ##########\n # Kp-band reduction\n ##########\n\n target = 'mb19284'\n sci_files = ['i200822_a011{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\n sci_files += ['i200822_a012{0:03d}_flip'.format(ii) for ii in range(2, 25+1)]\n sky_files = ['i200822_a018{0:03d}_flip'.format(ii) for ii in range(2, 6+1)]\n refSrc = [917.75, 1033.5] # This is the target\n # Alternative star to try (bright star to bottom of target): [1015, 581.9]\n \n sky.makesky(sky_files, target, 'kp_tdOpen', instrument=osiris)\n data.clean(sci_files, target, 'kp_tdOpen', refSrc, refSrc, field=target, instrument=osiris)\n data.calcStrehl(sci_files, 'kp_tdOpen', field=target, instrument=osiris)\n data.combine(sci_files, 'kp_tdOpen', epoch, field=target,\n trim=0, weight='strehl', submaps=3, instrument=osiris)\n\n ##########\n #\n # KB200101\n #\n ##########\n\n ##########\n # Kp-band reduction\n ##########\n\n # -- If you have more than one position angle, make sure to\n # clean them seperatly.\n # -- Strehl and Ref src should be the pixel coordinates of a bright\n # (but non saturated) source in the first exposure of sci_files.\n # -- If you use the OSIRIS image, you must include the full filename in the list. \n target = 'kb200101'\n sci_files = ['i200822_a014{0:03d}_flip'.format(ii) for ii in range(2, 28+1)]\n sci_files += ['i200822_a015{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\n sci_files += ['i200822_a016{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\n sky_files = ['i200822_a017{0:03d}_flip'.format(ii) for ii in range(2, 6+1)]\n refSrc = [975, 1006] # This is the target\n # Alternative star to try (bright star to right of target): [1158, 994]\n \n sky.makesky(sky_files, target, 'kp_tdOpen', instrument=osiris)\n data.clean(sci_files, target, 'kp_tdOpen', refSrc, refSrc, field=target, instrument=osiris)\n data.calcStrehl(sci_files, 'kp_tdOpen', field=target, instrument=osiris)\n data.combine(sci_files, 'kp_tdOpen', epoch, field=target,\n trim=1, weight='strehl', submaps=3, instrument=osiris)","def main():\n NAME = os.path.basename(__file__).split(\".\")[0]\n\n with its.device.ItsSession() as cam:\n\n props = cam.get_camera_properties()\n\n white_level = float(props['android.sensor.info.whiteLevel'])\n black_levels = props['android.sensor.blackLevelPattern']\n idxs = its.image.get_canonical_cfa_order(props)\n black_levels = [black_levels[i] for i in idxs]\n\n # Expose for the scene with min sensitivity\n sens_min, sens_max = props['android.sensor.info.sensitivityRange']\n s_ae,e_ae,awb_gains,awb_ccm,_ = cam.do_3a(get_results=True)\n s_e_prod = s_ae * e_ae\n\n # Make the image brighter since the script looks at linear Bayer\n # raw patches rather than gamma-encoded YUV patches (and the AE\n # probably under-exposes a little for this use-case).\n s_e_prod *= 2\n\n # Capture raw frames across the full sensitivity range.\n NUM_SENS_STEPS = 15\n sens_step = int((sens_max - sens_min - 1) / float(NUM_SENS_STEPS))\n reqs = []\n sens = []\n for s in range(sens_min, sens_max, sens_step):\n e = int(s_e_prod / float(s))\n req = its.objects.manual_capture_request(s, e)\n req[\"android.colorCorrection.transform\"] = \\\n its.objects.float_to_rational(awb_ccm)\n req[\"android.colorCorrection.gains\"] = awb_gains\n reqs.append(req)\n sens.append(s)\n\n caps = cam.do_capture(reqs, cam.CAP_RAW)\n\n # A list of the (x,y) coords of the center pixel of a collection of\n # patches of a color checker chart. Each patch should be uniform,\n # however the actual color doesn't matter. Note that the coords are\n # relative to the *converted* RGB image, which is 1/2 x 1/2 of the\n # full size; convert back to full.\n img = its.image.convert_capture_to_rgb_image(caps[0], props=props)\n patches = its.image.get_color_checker_chart_patches(img, NAME+\"_debug\")\n patches = [(2*x,2*y) for (x,y) in sum(patches,[])]\n\n lines = []\n for (s,cap) in zip(sens,caps):\n # For each capture, compute the mean value in each patch, for each\n # Bayer plane; discard patches where pixels are close to clamped.\n # Also compute the variance.\n CLAMP_THRESH = 0.2\n planes = its.image.convert_capture_to_planes(cap, props)\n points = []\n for i,plane in enumerate(planes):\n plane = (plane * white_level - black_levels[i]) / (\n white_level - black_levels[i])\n for j,(x,y) in enumerate(patches):\n tile = plane[y/2-16:y/2+16:,x/2-16:x/2+16:,::]\n mean = its.image.compute_image_means(tile)[0]\n var = its.image.compute_image_variances(tile)[0]\n if (mean > CLAMP_THRESH and mean < 1.0-CLAMP_THRESH):\n # Each point is a (mean,variance) tuple for a patch;\n # for a given ISO, there should be a linear\n # relationship between these values.\n points.append((mean,var))\n\n # Fit a line to the points, with a line equation: y = mx + b.\n # This line is the relationship between mean and variance (i.e.)\n # between signal level and noise, for this particular sensor.\n # In the DNG noise model, the gradient (m) is \"S\", and the offset\n # (b) is \"O\".\n points.sort()\n xs = [x for (x,y) in points]\n ys = [y for (x,y) in points]\n m,b = numpy.polyfit(xs, ys, 1)\n lines.append((s,m,b))\n print s, \"->\", m, b\n\n # TODO: Clean up these checks (which currently fail in some cases).\n # Some sanity checks:\n # * Noise levels should increase with brightness.\n # * Extrapolating to a black image, the noise should be positive.\n # Basically, the \"b\" value should correspnd to the read noise,\n # which is the noise level if the sensor was operating in zero\n # light.\n #assert(m > 0)\n #assert(b >= 0)\n\n # Draw a plot.\n pylab.plot(xs, ys, 'r')\n pylab.plot([0,xs[-1]],[b,m*xs[-1]+b],'b')\n matplotlib.pyplot.savefig(\"%s_plot_mean_vs_variance.png\" % (NAME))\n\n # Now fit a line across the (m,b) line parameters for each sensitivity.\n # The gradient (m) params are fit to the \"S\" line, and the offset (b)\n # params are fit to the \"O\" line, both as a function of sensitivity.\n gains = [d[0] for d in lines]\n Ss = [d[1] for d in lines]\n Os = [d[2] for d in lines]\n mS,bS = numpy.polyfit(gains, Ss, 1)\n mO,bO = numpy.polyfit(gains, Os, 1)\n\n # Plot curve \"O\" as 10x, so it fits in the same scale as curve \"S\".\n pylab.plot(gains, [10*o for o in Os], 'r')\n pylab.plot([gains[0],gains[-1]],\n [10*mO*gains[0]+10*bO, 10*mO*gains[-1]+10*bO], 'b')\n pylab.plot(gains, Ss, 'r')\n pylab.plot([gains[0],gains[-1]], [mS*gains[0]+bS, mS*gains[-1]+bS], 'b')\n matplotlib.pyplot.savefig(\"%s_plot_S_O.png\" % (NAME))\n\n print \"\"\"\n /* Generated test code to dump a table of data for external validation\n * of the noise model parameters.\n */\n #include <stdio.h>\n #include <assert.h>\n double compute_noise_model_entry_S(int sens);\n double compute_noise_model_entry_O(int sens);\n int main(void) {\n int sens;\n for (sens = %d; sens <= %d; sens += 100) {\n double o = compute_noise_model_entry_O(sens);\n double s = compute_noise_model_entry_S(sens);\n printf(\"%%d,%%lf,%%lf\\\\n\", sens, o, s);\n }\n return 0;\n }\n\n /* Generated functions to map a given sensitivity to the O and S noise\n * model parameters in the DNG noise model.\n */\n double compute_noise_model_entry_S(int sens) {\n double s = %e * sens + %e;\n return s < 0.0 ? 0.0 : s;\n }\n double compute_noise_model_entry_O(int sens) {\n double o = %e * sens + %e;\n return o < 0.0 ? 0.0 : o;\n }\n \"\"\"%(sens_min,sens_max,mS,bS,mO,bO)","def prepro(I):\n# I = env.reset() # Use this to verify, whats happening\n# plt.imshow(I)\n I = I[35:195] # crop and keep only the play area\n I = I[::2,::2,0] # downsample by factor of 2, take every second row and column, and take only \"R\" component out of RGB image\n I[I == 144] = 0 # erase background (background type 1)\n I[I == 109] = 0 # erase background (background type 2)\n I[I != 0] = 1 # everything else (but paddles, ball) just set to 1\n return I.astype(np.float).ravel() # convert to 1D array and return","def forward(self, x): \n pal1_sources = list()\n pal2_sources = list()\n loc_pal1 = list()\n conf_pal1 = list()\n loc_pal2 = list()\n conf_pal2 = list()\n\n # apply vgg up to conv3_3 relu\n for k in range(16):\n x = self.vgg[k](x)\n\n of1 = x\n s = self.L2Normof1(of1)\n pal1_sources.append(s)\n \n # apply vgg up to conv4_3 relu\n for k in range(16, 23):\n x = self.vgg[k](x)\n\n of2 = x\n s = self.L2Normof2(of2)\n pal1_sources.append(s)\n\n # apply vgg up to conv5_3 relu\n for k in range(23, 30):\n x = self.vgg[k](x)\n of3 = x\n s = self.L2Normof3(of3)\n pal1_sources.append(s)\n\n # apply vgg up to fc7\n for k in range(30, len(self.vgg)):\n x = self.vgg[k](x)\n of4 = x\n pal1_sources.append(of4)\n \n # apply extra layers and cache source layer outputs\n for k in range(2):\n x = F.relu(self.extras[k](x), inplace=True)\n of5 = x\n pal1_sources.append(of5)\n for k in range(2, 4):\n x = F.relu(self.extras[k](x), inplace=True)\n of6 = x\n pal1_sources.append(of6)\n\n ## fpn module\n \"\"\"\n lfpn6 = self.fpn_topdown6(of6)\n lfpn5 = self._upsample_product(self.fpn_topdown5(of6), self.fpn_latlayer5(of5))\n lfpn4 = self._upsample_product(self.fpn_topdown4(of5), self.fpn_latlayer4(of4))\n lfpn3 = self._upsample_product(self.fpn_topdown3(of4), self.fpn_latlayer3(of3))\n lfpn2 = self._upsample_product(self.fpn_topdown2(of3), self.fpn_latlayer2(of2))\n lfpn1 = self._upsample_product(self.fpn_topdown1(of2), self.fpn_latlayer1(of1))\n\n\n ef1 = self.fpn_fem3_3(lfpn1)\n ef1 = self.L2Normef1(ef1)\n ef2 = self.fpn_fem4_3(lfpn2)\n ef2 = self.L2Normef2(ef2)\n ef3 = self.fpn_fem5_3(lfpn3)\n ef3 = self.L2Normef3(ef3)\n\n ef4 = self.fpn_fem7(lfpn4)\n ef5 = self.fpn_fem6_2(lfpn5)\n ef6 = self.fpn_fem7_2(lfpn6)\n \"\"\"\n\n conv7 = F.relu(self.fpn_topdown[0](of6), inplace=True)\n x = F.relu(self.fpn_topdown[1](conv7), inplace=True)\n conv6 = F.relu(self._upsample_product(x, self.fpn_latlayer[0](of5)), inplace=True)\n\n x = F.relu(self.fpn_topdown[2](conv6), inplace=True)\n convfc7_2 = F.relu(self._upsample_product(x, self.fpn_latlayer[1](of4)), inplace=True)\n\n x = F.relu(self.fpn_topdown[3](convfc7_2), inplace=True)\n conv5 = F.relu(self._upsample_product(x, self.fpn_latlayer[2](of3)), inplace=True)\n\n x = F.relu(self.fpn_topdown[4](conv5), inplace=True)\n conv4 = F.relu(self._upsample_product(x, self.fpn_latlayer[3](of2)), inplace=True)\n\n x = F.relu(self.fpn_topdown[5](conv4), inplace=True)\n conv3 = F.relu(self._upsample_product(x, self.fpn_latlayer[4](of1)), inplace=True)\n\n ef1 = self.fpn_fem[0](conv3)\n ef1 = self.L2Normef1(ef1)\n ef2 = self.fpn_fem[1](conv4)\n ef2 = self.L2Normef2(ef2)\n ef3 = self.fpn_fem[2](conv5)\n ef3 = self.L2Normef3(ef3)\n ef4 = self.fpn_fem[3](convfc7_2)\n ef5 = self.fpn_fem[4](conv6)\n ef6 = self.fpn_fem[5](conv7)\n\n pal2_sources = (ef1, ef2, ef3, ef4, ef5, ef6)\n\n ## first shot \n for (x, l, c) in zip(pal1_sources, self.loc_pal1, self.conf_pal1):\n loc_pal1.append(l(x).permute(0, 2, 3, 1).contiguous())\n conf_pal1.append(c(x).permute(0, 2, 3, 1).contiguous())\n \n ## second shot\n for (x, l, c) in zip(pal2_sources, self.loc_pal2, self.conf_pal2):\n loc_pal2.append(l(x).permute(0, 2, 3, 1).contiguous())\n conf_pal2.append(c(x).permute(0, 2, 3, 1).contiguous())\n\n # first shot\n loc_pal1 = torch.cat([o.view(o.size(0), -1) for o in loc_pal1], 1)\n conf_pal1 = torch.cat([o.view(o.size(0), -1) for o in conf_pal1], 1)\n \n # second shot\n loc_pal2 = torch.cat([o.view(o.size(0), -1) for o in loc_pal2], 1)\n conf_pal2 = torch.cat([o.view(o.size(0), -1) for o in conf_pal2], 1)\n\n if self.phase == 'test':\n # 测试时， 仅使用shot2 的输出\n output = self.detect(\n loc_pal2.view(loc_pal2.size(0), -1, 4),\n self.softmax(conf_pal2.view(conf_pal2.size(0), -1,\n self.num_classes)), # conf preds\n )\n else:\n ## 训练时，使用shot1 和 shot2 的输出\n output = (\n loc_pal1.view(loc_pal1.size(0), -1, 4),\n conf_pal1.view(conf_pal1.size(0), -1, self.num_classes),\n loc_pal2.view(loc_pal2.size(0), -1, 4),\n conf_pal2.view(conf_pal2.size(0), -1, self.num_classes))\n return output","def forward_dummy(self, img):\n output = self.generator(img)\n return output","def noiseReduction(self):\n pass","def __getitem__(self, index):\n A_path = self.A_paths[index % self.A_size] # make sure index is within then range\n #if self.opt.serial_batches: # make sure index is within then range\n \n\n A_img = Image.open(A_path).convert('L')\n \n A = self.transform_A(A_img)\n # B20 = self.transform_B(B20_img)\n #B2 = self.transform_B(B2_img)\n\n\n index_B50 = index % self.B50_size\n B50_path = self.B50_paths[index_B50]\n B50_img = Image.open(B50_path).convert('L')\n B50 = self.transform_B(B50_img)\n\n\n\n index_B100 = index % self.B100_size\n B100_path = self.B100_paths[index_B100]\n B100_img = Image.open(B100_path).convert('L')\n B100 = self.transform_B(B100_img)\n\n index_B150 = index % self.B150_size\n B150_path = self.B150_paths[index_B150]\n B150_img = Image.open(B150_path).convert('L')\n B150 = self.transform_B(B150_img)\n\n\n \n\n index_m0 = 0\n m0_path = self.m0_paths[index_m0]\n m0_img = Image.open(m0_path).convert('L')\n m0 = self.transform_B(m0_img)\n \n index_m50 = 0\n m50_path = self.m50_paths[index_m50]\n m50_img = Image.open(m50_path).convert('L')\n m50 = self.transform_B(m50_img)\n\n index_m100 = 0\n m100_path = self.m100_paths[index_m100]\n m100_img = Image.open(m100_path).convert('L')\n m100 = self.transform_B(m100_img)\n\n index_m150 = 0\n m150_path = self.m150_paths[index_m150]\n m150_img = Image.open(m150_path).convert('L')\n m150 = self.transform_B(m150_img)\n\n\n\n return {'A': A, 'B50': B50,'B100': B100, 'B150': B150, 'A_paths': A_path, 'B50_paths': B50_path,'B100_paths': B100_path, 'B150_paths': B150_path, 'm0':m0, 'm50':m50,'m100':m100, 'm150':m150}","def Resampler(name):\n\n def resample_average(path, dsquery, dstile, image_format):\n for i in range(1, dstile.RasterCount+1):\n res = gdal.RegenerateOverview(dsquery.GetRasterBand(i), dstile.GetRasterBand(i), \"average\")\n if res != 0:\n raise ImageOutputException(\"RegenerateOverview() failed with error %d\" % res)\n\n gdal_write(path, dstile, image_format)\n\n def resample_antialias(path, dsquery, dstile, image_format):\n querysize = dsquery.RasterXSize\n tilesize = dstile.RasterXSize\n\n array = numpy.zeros((querysize, querysize, 4), numpy.uint8)\n for i in range(dstile.RasterCount):\n array[:,:,i] = gdalarray.BandReadAsArray(dsquery.GetRasterBand(i+1), 0, 0, querysize, querysize)\n im = Image.fromarray(array, 'RGBA') # Always four bands\n im1 = im.resize((tilesize,tilesize), Image.ANTIALIAS)\n\n if os.path.exists(path):\n im0 = Image.open(path)\n im1 = Image.composite(im1, im0, im1)\n\n ensure_dir_exists(path)\n\n if image_format == \"JPEG\":\n im1.save(path, image_format, quality=jpeg_quality)\n else:\n im1.save(path, image_format)\n\n\n if name == \"average\":\n return resample_average\n elif name == \"antialias\":\n return resample_antialias\n\n resampling_methods = {\n \"near\" : gdal.GRA_NearestNeighbour,\n \"bilinear\" : gdal.GRA_Bilinear,\n \"cubic\" : gdal.GRA_Cubic,\n \"cubicspline\" : gdal.GRA_CubicSpline,\n \"lanczos\" : gdal.GRA_Lanczos\n }\n\n resampling_method = resampling_methods[name]\n\n def resample_gdal(path, dsquery, dstile, image_format):\n querysize = dsquery.RasterXSize\n tilesize = dstile.RasterXSize\n\n dsquery.SetGeoTransform( (0.0, tilesize / float(querysize), 0.0, 0.0, 0.0, tilesize / float(querysize)) )\n dstile.SetGeoTransform( (0.0, 1.0, 0.0, 0.0, 0.0, 1.0) )\n\n res = gdal.ReprojectImage(dsquery, dstile, None, None, resampling_method)\n if res != 0:\n raise ImageOutputException(\"ReprojectImage() failed with error %d\" % res)\n\n gdal_write(path, dstile, image_format)\n\n return resample_gdal","def exposure():\n def r(x):\n return x/6e4\n\n def w(x):\n return int(x*6e4)\n return r, w","def process_frame(self, downsize):\n # if (not hasattr(downsize,'shape')) and (not hasattr(downsize,'len')):\n # downsize = np.array(downsize)\n\n if type(downsize) != np.ndarray:\n raise TypeError\n\n if not downsize.any():\n raise ValueError\n\n if self.pre_resize:\n downsize = cv2.resize(downsize, (0, 0), fx=self.resize_factor, fy=self.resize_factor)\n\n self.frame_history.append(downsize)\n\n # Remove no longer needed frames from memory\n self.frame_history = self.frame_history[-(self.LMC_rec_depth):]\n downsize = signal.lfilter(self.b, self.a, self.frame_history, axis=0)[-1]\n\n # Center surround antagonism kernel applied.\n\n downsize = cv2.filter2D(downsize, -1, self.CSKernel)\n\n # RTC filter.\n u_pos = deepcopy(downsize)\n u_neg = deepcopy(downsize)\n u_pos[u_pos < 0] = 0\n u_neg[u_neg > 0] = 0\n u_neg = -u_neg\n\n # On first step, instead of computing just save the images.\n if self.t == self.T0:\n self.v_pos_prev = deepcopy(u_pos)\n self.v_neg_prev = deepcopy(u_neg)\n self.u_pos_prev = deepcopy(u_pos)\n self.u_neg_prev = deepcopy(u_neg)\n\n # Do everything for pos == ON.\n tau_pos = u_pos - self.u_pos_prev\n tau_pos[tau_pos >= 0] = 0.001\n tau_pos[tau_pos < 0] = 0.1\n mult_pos = self.rtc_exp(self.dt, tau_pos)\n v_pos = -(mult_pos - 1) * u_pos + mult_pos * self.v_pos_prev\n self.v_pos_prev = deepcopy(v_pos)\n\n # Do everything for neg == OFF.\n tau_neg = u_neg - self.u_neg_prev\n tau_neg[tau_neg >= 0] = 0.001\n tau_neg[tau_neg < 0] = 0.1\n mult_neg = self.rtc_exp(self.dt, tau_neg)\n v_neg = -(mult_neg - 1) * u_neg + mult_neg * self.v_neg_prev\n self.v_neg_prev = deepcopy(v_neg)\n\n # keep track of previous u.\n self.u_pos_prev = deepcopy(u_pos)\n self.u_neg_prev = deepcopy(u_neg)\n\n # Subtract v from u to give the output of each channel.\n out_pos = u_pos - v_pos\n out_neg = u_neg - v_neg\n\n # Now apply yet another filter to both parts.\n out_pos = cv2.filter2D(out_pos, -1, self.H_filter)\n out_neg = cv2.filter2D(out_neg, -1, self.H_filter)\n out_pos[out_pos < 0] = 0\n out_neg[out_neg < 0] = 0\n\n if self.t == self.T0:\n self.out_neg_prev = deepcopy(out_neg)\n\n # Delay off channel.\n out_neg = signal.lfilter(self.b1, self.a1, [self.out_neg_prev, out_neg], axis=0)[-1]\n self.out_neg_prev = out_neg\n downsize = out_neg * out_pos\n\n # Show image.\n downsize *= self.gain\n downsize = np.tanh(downsize)\n\n # Threshold.\n downsize[downsize < self.threshold] = 0\n\n if not self.pre_resize:\n downsize = cv2.resize(downsize, (0, 0), fx=self.resize_factor, fy=self.resize_factor)\n\n self.t += self.dt\n\n return downsize","def manipulations(path):\r\n\r\n print (\"\\n Working on %s\\n\" %(path))\r\n\r\n # Creates a folder with the results for the current image\r\n if not os.path.exists(\"Results\\\\%s\" %(path)):\r\n os.makedirs(\"Results\\\\%s\" %(path))\r\n\r\n # The variations made of the image\r\n func.pixelImage(path, 10, 10)\r\n func.animate(path)\r\n func.colorScale(path, 0)\r\n func.colorScale(path, 1)\r\n func.colorScale(path, 2)\r\n func.scan(path, 280)\r\n func.greyImage(path)\r\n func.colorSteps(path, 1)\r\n func.inverted(path)","def generate_images_pred(self, inputs, outputs):\n for scale in self.scales:\n disp = outputs[(\"disp\", scale)]\n disp = F.interpolate(\n disp, [self.height, self.width], mode=\"bilinear\", align_corners=False)\n source_scale = 0\n\n _, depth = disp_to_depth(disp, self.min_depth, self.max_depth)\n\n outputs[(\"depth\", 0, scale)] = depth\n\n for i, frame_id in enumerate(self.frame_ids[1:]):\n\n T = outputs[(\"cam_T_cam\", 0, frame_id)]\n\n # from the authors of https://arxiv.org/abs/1712.00175\n # mean-normalized inverse depth from [62] to discourage shrinking of the estimated depth\n\n axisangle = outputs[(\"axisangle\", 0, frame_id)]\n translation = outputs[(\"translation\", 0, frame_id)]\n\n inv_depth = 1 / depth\n mean_inv_depth = inv_depth.mean(3, True).mean(2, True)\n\n T = transformation_from_parameters(\n axisangle[:, 0], translation[:, 0] * mean_inv_depth[:, 0], frame_id < 0)\n\n cam_points = self.backproject_depth[source_scale](\n depth, inputs[(\"inv_K\", source_scale)])\n pix_coords = self.project_3d[source_scale](\n cam_points, inputs[(\"K\", source_scale)], T)\n\n outputs[(\"sample\", frame_id, scale)] = pix_coords\n\n outputs[(\"color\", frame_id, scale)] = F.grid_sample(\n inputs[(\"color\", frame_id, source_scale)],\n outputs[(\"sample\", frame_id, scale)],\n padding_mode=\"border\")\n\n outputs[(\"color_identity\", frame_id, scale)] = \\\n inputs[(\"color\", frame_id, source_scale)]","def des_image(exptime=100,mag=None, Nstar=1,ccd=None,seeing=[0.9,0.,0.],npix=npix,zenith=0,filter='r', theta=0., phi=0,corrector='corrector',x=None,y=None,z=None,suband=None,regular=False,setbkg=True):\n gain = 0.21 # convert electrons to ADU\n zeropoint = 26.794176 # r band, from Nikolay\n \n if setbkg == False:\n skyphoton = 0.\n else:\n skyphoton = 8.460140*exptime\n bkg = skyphoton*gain\n res = genImgV(filename=None,Nstar=Nstar,ccd=ccd,seeing=seeing,npix=npix,zenith=zenith,filter=filter, theta=theta, phi=phi,corrector=corrector,x=x,y=y,z=z,suband=suband,regular=regular)\n if Nstar == 1:\n objectphoton = exptime*10**(0.4*(zeropoint - mag))\n psf = res[0][0][4:].reshape(npix,npix)\n img = (psf * objectphoton + skyphoton)*gain\n img = rebin(img,(40,40))\n psf = rebin(psf,(40,40))\n img = img + add_imageNoise(img)\n if Nstar > 1:\n img = []\n psf = []\n magg = []\n for i in range(Nstar):\n if type(mag) == list:\n rng = abs(mag[1] - mag[0])\n magi = min(mag)+np.random.rand()*rng\n objectphoton = exptime*10**(0.4*(zeropoint - magi))\n psfi = res[0][i][4:].reshape(npix,npix)\n imgi = (psfi * objectphoton + skyphoton)*gain\n imgi = imgi+np.sqrt(imgi)\n imgi = rebin(imgi,(40,40))\n psfi = rebin(psfi,(40,40))\n imgi = imgi + add_imageNoise(imgi)\n img.append(imgi)\n psf.append(psfi)\n magg.append(magi)\n return img,bkg,psf,magg","def main():\n logging.basicConfig() # create a baseconfiguration s.t. we cann now log \n cycle = 0\n while True:\n\n logging.info(f\"{time.now()} - Start cycle {cycle}\") # changed from print to info \n do_unstable_magick(cycle)\n logging.info(f\"{time.nos()} - Finished cycle {cycle}\")","def _aperture_to_photopoint_(self, *args, **kwargs):\n\n if not self.has_sky():\n return super(GALEX,self)._aperture_to_photopoint_( *args, **kwargs )\n\n datacps, bkgdcps = args\n datacounts = datacps[0]*self.exposuretime\n bkgdcounts = bkgdcps[0]*self.exposuretime\n \n # ------------------\n # - One Photopoint\n if len(np.atleast_1d(datacounts))==1:\n return get_photopoint(lbda=self.lbda,\n datacounts=np.atleast_1d(datacounts)[0],\n bkgdcounts=np.atleast_1d(bkgdcounts)[0],\n exptime=self.exposuretime,\n source=\"image\",mjd=self.mjd,\n zp=self.mab0,\n bandname=self.bandname,\n instrument_name=self.instrument_name)\n # -----------------------\n # - Several Photopoints\n return [get_photopoint(lbda=self.lbda,\n datacounts=datacounts_,\n bkgdcounts=bkgdcounts_,\n exptime=self.exposuretime,\n source=\"image\",mjd=self.mjd,\n zp=self.mab0,bandname=self.bandname,\n instrument_name=self.instrument_name)\n for datacounts_,bkgdcounts_ in zip(datacounts,bkgdcounts)]","def features_combine():\n\n\n\t# PROCESSING AUDIO","def process_image(image):\r\n image = random_brightness(image)\r\n image = crop_image(image)\r\n image = resize(image)\r\n return image","def process_sound_map():\n pass","def update_channels(imgs, msks, **settings):\n\n\tshp = imgs.shape\n\tnew_imgs = np.zeros((shp[0],shp[1],shp[2], settings['IN_CHANNEL_NO']))\n\tnew_msks = np.zeros((shp[0],shp[1],shp[2], settings['OUT_CHANNEL_NO']))\n\n\tif settings['MODE']==1:\n\t\tnew_imgs[:,:,:,0] = imgs[:,:,:,2] # flair\n\t\tnew_msks[:,:,:,0] = msks[:,:,:,0]+msks[:,:,:,1]+msks[:,:,:,2]+msks[:,:,:,3]\n\t\tprint('-'*10,' Whole tumor', '-'*10)\n\n\telif settings['MODE'] == 2:\n\t\t#core (non enhancing)\n\t\tnew_imgs[:,:,:,0] = imgs[:,:,:,0] # t1 post\n\t\tnew_msks[:,:,:,0] = msks[:,:,:,3]\n\t\tprint('-'*10,' Predicing enhancing tumor', '-'*10)\n\n\telif settings['MODE'] == 3:\n\t\t#core (non enhancing)\n\t\tnew_imgs[:,:,:,0] = imgs[:,:,:,1]# t2 post\n\t\tnew_msks[:,:,:,0] = msks[:,:,:,0]+msks[:,:,:,2]+msks[:,:,:,3] # active core\n\t\tprint('-'*10,' Predicing active Core', '-'*10)\n\n\telse:\n\t\tnew_msks[:,:,:,0] = msks[:,:,:,0]+msks[:,:,:,1]+msks[:,:,:,2]+msks[:,:,:,3]\n\n\treturn new_imgs.astype(np.float32), new_msks.astype(np.float32)","def preprocess_images():\n \n # Set up the lists to collect the images and measurements\n images = []\n measurements = []\n \n # Set up the path to the data files \n data_sets_path = 'data'\n data_sets = [os.path.join(data_sets_path, i) for i\n in os.listdir(data_sets_path)]\n \n # Step through the data folders and collect the images\n # and the steering angles\n for data_set in data_sets:\n lines = []\n \n # Open up the csv file of image paths and steering angles\n with open(os.path.join(data_set,\n 'driving_log.csv')) as csvfile:\n reader = csv.reader(csvfile)\n for line in reader:\n lines.append(line)\n for line in lines:\n source_path = line[0]\n filename = source_path.split('\\\\')[-1]\n current_path = os.path.join(data_set, 'IMG',\n filename)\n \n # Import each image and change it to RGB\n BGR_image = cv2.imread(current_path)\n image = cv2.cvtColor(BGR_image, cv2.COLOR_BGR2RGB)\n rows, cols, depth = image.shape\n flipped_image = cv2.flip(image, 1)\n \n # Create a scaled version of the image\n scale = [0.9, 1.1]\n zoomfactor = random.choice(scale)\n scale_matrix = cv2.getRotationMatrix2D((cols/2, rows/2),\n 0, zoomfactor)\n scaled_image = cv2.warpAffine(image, scale_matrix,\n (cols, rows))\n\n # Append the images to the image list\n images.append(image)\n images.append(scaled_image)\n images.append(flipped_image)\n \n # Append the steering angle to the measurements list\n measurement = float(line[3])\n measurements.append(measurement)\n measurements.append(measurement)\n measurements.append(-1*measurement)\n \n return images, measurements","def measure(self, imgage, previous=None):","def run():\n scene = lm.scene_object()\n copy_latest_low()\n copy_latest_high()","def main():\n cam = Realsense()\n # cam.access_intr_and_extr()\n profile = cam.pipeline.start(cam.config)\n depth_sensor = profile.get_device().first_depth_sensor()\n depth_scale = depth_sensor.get_depth_scale()\n align_to = rs.stream.color\n align = rs.align(align_to)\n\n objp = np.zeros((3*4,3), np.float32)\n objp[:,:2] = np.mgrid[0:4,0:3].T.reshape(-1,2)\n axis = np.float32([[1,0,0], [0,1,0], [0,0,-1]]).reshape(-1,3)\n # print(objp)\n\n try:\n while (True):\n # detect ArUco markers in RGB images\n frames = cam.pipeline.wait_for_frames()\n aligned_frames = align.process(frames)\n color_frame = aligned_frames.get_color_frame()\n color_image = np.asanyarray(color_frame.get_data()) \n frame = color_image\n font = cv2.FONT_HERSHEY_SIMPLEX\n corners, ids, rvecs, tvecs = cam.detect_markers_realsense(frame)\n \n if np.all(ids != None): # if markers are detected\n for i in range(0, ids.size):\n aruco.drawAxis(frame, cam.newcameramtx, cam.dist, rvecs[i],\n tvecs[i], 0.1) # Draw axis\n aruco.drawDetectedMarkers(frame, corners) # draw square around markers\n\n ###### DRAW ID #####\n strg = ''\n for i in range(0, ids.size):\n strg += str(ids[i][0])+', '\n\n cv2.putText(frame, \"Id: \" + strg, (0,25), font, 1, (0,255,0), 2,\n cv2.LINE_AA)\n\n\t ###### Output marker positions in camera frame ######\n \t # output tvec\n y0 = 60\n dy = 40\n for i in range(0, ids.size):\n y = y0 + i*dy\n cv2.putText(frame, str(tvecs[i][0]), (0, y), font, 1, (0,255,0),\n 2, cv2.LINE_AA)\n\n else:\n ##### DRAW \"NO IDS\" #####\n cv2.putText(frame, \"No Ids\", (0,64), font, 1, (0,255,0), 2,\n cv2.LINE_AA)\n\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n ret, corners = cv2.findChessboardCorners(gray, (4,3), None)\n if ret == True:\n corners2 = cv2.cornerSubPix(gray, corners,(11,11), (-1,-1),\n cam.criteria)\n corners2 = corners2[::-1]\n # print(corners2)\n # print(objp)\n frame = cv2.drawChessboardCorners(frame, (4,3), corners2, ret)\n # Find the rotation and translation vectors.\n _, rvecs, tvecs = cv2.solvePnP(objp, corners2, cam.newcameramtx,\n cam.dist)\n rot, _ = cv2.Rodrigues(rvecs)\n # print(rot)\n # project 3D points to image plane\n imgpts, jac = cv2.projectPoints(axis, rvecs, tvecs,\n cam.newcameramtx, cam.dist)\n frame = draw(frame, corners2, imgpts)\n\n # Display the resulting frame\n cv2.imshow('frame',frame)\n cv2.waitKey(5)\n\n # When everything done, release the capture\n cv2.destroyAllWindows()\n\n finally:\n cam.pipeline.stop()","def update_anim(frame, self):\n self.step()\n self.im.set_data(self.array)\n self.im2.set_data(self.array2)","def augment():\n print(\"augmenting......\")\n path1 = '../trainp1/'\n path2 = '../trainp2/'\n # path of pair1 and pair2 similar to img & mask task for segmentation\n p = Augmentor.Pipeline(path1) # pair1\n p.ground_truth(path2) # pair2\n p.rotate(probability=0.3, max_left_rotation=3, max_right_rotation=3) \n p.flip_left_right(probability=0.2) \n p.random_distortion(0.5, 2, 2, 2)\n p.zoom(probability=0.5, min_factor=0.95, max_factor=1.05)\n p.process()","def main():\n NAME = os.path.basename(__file__).split(\".\")[0]\n\n # Pass/fail thresholds\n MIN_AVG_FRAME_DELTA = 30 # at least 30ms delta between frames\n MAX_VAR_FRAME_DELTA = 0.01 # variance of frame deltas\n MAX_FRAME_DELTA_JITTER = 0.3 # max ms gap from the average frame delta\n\n with its.device.ItsSession() as cam:\n props = cam.get_camera_properties()\n if not its.caps.manual_sensor(props):\n print \"Test skipped\"\n return\n\n req, fmt = its.objects.get_fastest_manual_capture_settings(props)\n caps = cam.do_capture([req]*50, [fmt])\n\n # Print out the millisecond delta between the start of each exposure\n tstamps = [c['metadata']['android.sensor.timestamp'] for c in caps]\n deltas = [tstamps[i]-tstamps[i-1] for i in range(1,len(tstamps))]\n deltas_ms = [d/1000000.0 for d in deltas]\n avg = sum(deltas_ms) / len(deltas_ms)\n var = sum([d*d for d in deltas_ms]) / len(deltas_ms) - avg * avg\n range0 = min(deltas_ms) - avg\n range1 = max(deltas_ms) - avg\n print \"Average:\", avg\n print \"Variance:\", var\n print \"Jitter range:\", range0, \"to\", range1\n\n # Draw a plot.\n pylab.plot(range(len(deltas_ms)), deltas_ms)\n matplotlib.pyplot.savefig(\"%s_deltas.png\" % (NAME))\n\n # Test for pass/fail.\n assert(avg > MIN_AVG_FRAME_DELTA)\n assert(var < MAX_VAR_FRAME_DELTA)\n assert(abs(range0) < MAX_FRAME_DELTA_JITTER)\n assert(abs(range1) < MAX_FRAME_DELTA_JITTER)","def expose(self):\n\n ## Determine type of exposure (exp, series, stack)\n exptype = str(self.exptypeComboBox.currentText())\n mode = self.modedict[exptype]\n\n ## Get exposure parameters\n if mode == \"bias\":\n exptime = 0.0\n else:\n exptime = self.exptimeSpinBox.value()\n imcount = self.imstackSpinBox.value()\n seqnum = self.imnumSpinBox.value()\n mintime = self.minexpSpinBox.value()\n maxtime = self.maxexpSpinBox.value()\n step = self.tstepSpinBox.value()\n\n ## Determine filter kwargs\n if self.filterToggleButton.isChecked():\n kwargs = {'filter_name' : str(self.filterComboBox.currentText())}\n else:\n kwargs = {'monowl' : self.monoSpinBox.value()}\n\n if self.testimCheckBox.isChecked():\n title = 'test'\n else:\n title = str(self.imtitleLineEdit.text())\n\n ## Build filepath\n filepath = os.path.join(str(self.imfilenameLineEdit.text()),title)\n \n ## Check if single exposure\n if exptype in [\"Exposure\", \"Dark\", \"Bias\"]:\n\n ## Perform exposure\n self.logger.info(\"Starting {0}s {1} image.\".format(exptime, exptype))\n self.image_start.emit(1)\n\n try:\n filename = exposure.im_acq(mode, filepath, exptime, seqnum, **kwargs)\n self.image_taken.emit(1)\n except subprocess.CalledProcessError:\n self.logger.exception(\"Error in executable {0}_acq. Image not taken.\".format(mode))\n except OSError:\n self.logger.exception(\"Executable {0}_acq not found. Image not taken\".format(mode))\n except IOError:\n self.logger.exception(\"File already exits. Image not taken.\")\n else:\n self.logger.info(\"Exposure {0} finished successfully.\".format(filename))\n self.seqnum_inc.emit(seqnum)\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename,\n '-zoom', 'to', 'fit', '-cmap', 'b'])\n\n ## Check if a stack of exposures of same type\n elif exptype in [\"Exposure Stack\", \"Dark Stack\", \"Bias Stack\"]:\n\n total = seqnum + imcount\n self.logger.info(\"Starting {0}s {1} stack.\".format(exptime, exptype))\n self.image_start.emit(imcount)\n\n try:\n for i in range(seqnum, total):\n self.logger.info(\"Starting image {0} of {1}.\".format(i+1-seqnum, imcount))\n filename = exposure.im_acq(mode, filepath, exptime, i, **kwargs)\n self.logger.info(\"Exposure {0} finished successfully.\".format(filename))\n self.image_taken.emit(i+1-seqnum)\n self.seqnum_inc.emit(i)\n except subprocess.CalledProcessError:\n self.logger.exception(\"Error in executable {0}_acq. Image not taken.\".format(mode))\n except OSError:\n self.logger.exception(\"Executable {0}_acq not found. Image not taken.\".format(mode))\n except IOError:\n self.logger.exception(\"File already exists. Image not taken.\")\n else:\n self.logger.info(\"Exposure stack finished successfully.\")\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename, '-zoom', 'to', 'fit', '-cmap', 'b'])\n \n ## Check if a series of exposures of increase exposure time\n elif exptype in [\"Exposure Series\", \"Dark Series\"]:\n\n ## Parameter checks\n if mintime > maxtime:\n self.logger.warning(\"Minimum time must be less than Maximum time. Series not started.\")\n return\n elif step <= 0:\n self.logger.warning(\"Time step must be greater than 0. Series not started.\")\n return\n\n ## Construct array of exposure times\n t = mintime\n time_array = []\n while t <= maxtime:\n time_array.append(t)\n t += step\n \n ## Perform series\n self.logger.info(\"Starting {0} series with mintime {1}, maxtime {2}, and step {3}.\".format(exptype, mintime, maxtime, step))\n self.image_start.emit(len(time_array))\n \n try:\n for i, time in enumerate(time_array):\n self.logger.info(\"Starting {0}s {1} image.\".format(time, mode))\n filename = exposure.im_acq(mode, filepath, time, seqnum, **kwargs)\n self.logger.info(\"Exposure {0} finished successfully.\".format(filename))\n self.image_taken.emit(i+1)\n except subprocess.CalledProcessError:\n self.logger.exception(\"Error in executable {0}_acq. Image not taken.\".format(mode))\n except OSError:\n self.logger.exception(\"Executable {0}_acq not found. Image not taken.\".format(mode))\n except IOError:\n self.logger.exception(\"File already exists. Image not taken.\")\n else:\n self.logger.info(\"Exposure series finished successfully.\")\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename, '-zoom', 'to', 'fit', '-cmap', 'b'])\n self.seqnum_inc.emit(seqnum)","def problem2():\n\n data = loaddata(\"data/bayerdata.npy\")\n r, g, b = separatechannels(data)\n\n img = assembleimage(r, g, b)\n display_image(img)\n\n img_interpolated = interpolate(r, g, b)\n display_image(img_interpolated)","def upscale_main_side(output_img):\n #Fixing pixel which y % 2 != 1\n outputx, outputy = output_img.size\n for oy in range(0, outputy-1, 2):\n for ox in range(1, outputx, 2):\n pixel1 = output_img.getpixel((ox-1, oy))\n p1 = pixel1[0]\n p2 = pixel1[1]\n p3 = pixel1[2]\n if ox == outputx-1 :\n output_img.putpixel((ox, oy), (p1, p2, p3))\n else:\n pixel2 = output_img.getpixel((ox+1, oy))\n P1 = pixel2[0]\n P2 = pixel2[1]\n P3 = pixel2[2]\n output_img.putpixel((ox, oy), (int((p1+P1)/2), int((p2+P2)/2), int((p3+P3)/2)))\n #print(f'pixel:{ox, oy} output:{output_img.getpixel((ox,oy))}')\n #Fixing pixel which y % 2 == 1\n for oy in range(1, outputy-1, 2):\n for ox in range(0, outputx):\n pixel1 = output_img.getpixel((ox, oy-1))\n p1 = pixel1[0]\n p2 = pixel1[1]\n p3 = pixel1[2]\n if oy == outputx:\n output_img.putpixel((ox, oy), (p1, p2, p3))\n break\n else:\n pixel2 = output_img.getpixel((ox, oy+1))\n P1 = pixel2[0]\n P2 = pixel2[1]\n P3 = pixel2[2]\n output_img.putpixel((ox, oy), (int((p1+P1)/2), int((p2+P2)/2), int((p3+P3)/2)))\n #print(f'pixel:{ox, oy} output:{output_img.getpixel((ox,oy))}')\n #Save image \n result_img = output_path+'/output.'+working_img.format.lower()\n output_img.save(result_img)\n print('Upscale finished..!')\n output_img.show()","def run(self):\n #calculate platescale of first input image\n try:\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.cd)\n pscale = np.sqrt(np.abs(det))*3600.\n except:\n try:\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.pc)\n pscale = np.sqrt(np.abs(det))*3600.\n except:\n pscale = self.datain[0].header['PIXSCAL']\n #filtering out images which are too far away from the others\n #passing images added to a list of (image, WCS) tuples\n '''\n image_centers = []\n for f in self.datain:\n image_centers.append((f.header['CRVAL1'], f.header['CRVAL2']))\n filtered_datain = []\n dist_list = [[[0]*(len(image_centers)-1)]*len(image_centers)]\n for i in range(len(image_centers)):\n for j in range(len(image_centers)-1):\n dist_list[i][j+1] = np.sqrt((image_)**2+()**2)\n '''\n #calculations necessary for updating wcs information\n px = []\n py = []\n \n #in order to avoid NaN interactions, creating weight map\n weights=[]\n for f in self.datain:\n weights.append((np.where(np.isnan(f.image) == True, 0, 1)))\n \n for f in self.datain:\n px.extend(wcs.WCS(f.header).calc_footprint()[:,0])\n py.extend(wcs.WCS(f.header).calc_footprint()[:,1])\n x0 = (max(px)+min(px))/2.\n y0 = (max(py)+min(py))/2.\n sx = (max(px)-min(px))*np.cos(y0/180*np.pi) # arcsec\n sy = (max(py)-min(py)) # arcsec\n size = (sx*3600+self.getarg('pad')*2, sy*3600+self.getarg('pad')*2)\n xpix = size[0]//pscale\n ypix = size[1]//pscale\n cdelt = [pscale/3600.]*2\n \n #create self.dataout and give it a copy of an input's header\n self.dataout = DataFits(config = self.config)\n self.dataout.header = self.datain[0].header.copy()\n \n #update header wcs information\n self.log.info('Creating new WCS header')\n \n self.dataout.header['CRPIX1'] = xpix/2\n self.dataout.header['CRPIX2'] = ypix/2\n self.dataout.header['CRVAL1'] = x0\n self.dataout.header['CRVAL2'] = y0\n self.dataout.header['CD1_1'] = -cdelt[0]\n self.dataout.header['CD1_2'] = self.dataout.header['CD2_1'] = 0.\n self.dataout.header['CD2_2'] = cdelt[1]\n self.dataout.header['NAXIS1'] = int(xpix)\n self.dataout.header['NAXIS2'] = int(ypix)\n self.dataout.header['CTYPE1'] = 'RA---TAN-SIP'\n self.dataout.header['CTYPE2'] = 'DEC--TAN-SIP'\n self.dataout.header['RADESYS'] = 'ICRS'\n self.dataout.header['EQUINOX'] = 2000\n self.dataout.header['LATPOLE'] = self.datain[0].header['CRVAL2']\n self.dataout.header['LONPOLE'] = 180\n self.dataout.header['PIXASEC'] = pscale\n \n theta_rad = np.deg2rad(self.getarg('outangle'))\n rot_matrix = np.array([[np.cos(theta_rad), -np.sin(theta_rad)], \n [np.sin(theta_rad), np.cos(theta_rad)]])\n rot_cd = np.dot(rot_matrix, np.array([[self.dataout.header['CD1_1'], 0.],[0., self.dataout.header['CD2_2']]]))\n for i in [0,1]:\n for j in [0,1]:\n self.dataout.header['CD{0:d}_{1:d}'.format(i+1, j+1)] = rot_cd[i,j]\n \n #check drizzle arguments\n if self.getarg('kernel') == 'smoothing':\n kernel = 'lanczos3'\n elif self.getarg('kernel') in ['square', 'point', 'gaussian', 'tophat']:\n kernel = self.getarg('kernel')\n else:\n self.log.error('Kernel name not recognized, using default')\n kernel = 'square'\n if self.getarg('drizzleweights') == 'uniform':\n driz_wt = ''\n elif self.getarg('drizzleweights') in ['exptime', 'expsq']:\n driz_wt = self.getarg('drizzleweights')\n else:\n self.log.error('Drizzle weighting not recognized, using default')\n driz_wt = ''\n \n #create drizzle object and add input images\n fullwcs = wcs.WCS(self.dataout.header)\n self.log.info('Starting drizzle')\n driz = drz.Drizzle(outwcs = fullwcs, pixfrac=self.getarg('pixfrac'), \\\n kernel=kernel, fillval='10000', wt_scl=driz_wt)\n for i,f in enumerate(self.datain):\n self.log.info('Adding %s to drizzle stack' % f.filename)\n driz.add_image(f.imgdata[0], wcs.WCS(f.header), inwht=weights[i])\n \n try:\n fillval=float(self.getarg('fillval'))\n except:\n fillval=np.nan\n self.log.error('Fillvalue not recognized or missing, using default')\n \n #creates output fits file from drizzle output\n self.dataout.imageset(np.where(driz.outsci == 10000, fillval, driz.outsci))\n self.dataout.imageset(driz.outwht,'OutWeight', self.dataout.header)\n self.dataout.filename = self.datain[0].filename\n\n #add history\n self.dataout.setheadval('HISTORY','Coadd: %d files combined with %s kernel, pixfrac %f at %f times resolution' \\\n % (len(self.datain), kernel, self.getarg('pixfrac'), self.getarg('resolution')))","def run(self, src, dest):\n self.logger.debug('Start the blurring. src=\"%s\", dest=\"%s\"', src, dest)\n create_frames(src, self.work['frames'])\n data = self.analyze()\n\n for frame_no, frame in enumerate(self.work.files('frames')):\n basename = os.path.basename(frame)\n areas = []\n for values in data:\n for sector in values['sectors']:\n if frame_no in range(sector[0]-self.offset, sector[1]+self.offset):\n areas.append(values['area'])\n break\n if areas:\n self.blur.blur_image(frame, areas, os.path.join(self.work['cleaned'], basename))\n else:\n copyfile(frame, os.path.join(self.work['cleaned'], basename))\n save_frames(self.work['cleaned'], dest)","def camera(self):\n self.spectrum = self.spectrum","def degrade_image(im, psf, downsample, shift_range):\n\n shift = np.random.randint(shift_range[0], shift_range[1], (1, 2))[0]\n\n # Add shift\n im = fourier_shift(np.fft.fftn(im), shift)\n im = np.fft.ifftn(im).real\n\n # Blur and downsample\n im = convolve2d(im, psf)\n im = downscale_local_mean(im, (downsample, downsample))\n\n return im","def testSmallSrc(self):\n fromWcs = afwGeom.makeSkyWcs(\n crpix=lsst.geom.Point2D(0, 0),\n crval=lsst.geom.SpherePoint(359, 0, lsst.geom.degrees),\n cdMatrix=afwGeom.makeCdMatrix(scale=1.0e-8*lsst.geom.degrees),\n )\n fromExp = afwImage.ExposureF(afwImage.MaskedImageF(1, 1), fromWcs)\n\n toWcs = afwGeom.makeSkyWcs(\n crpix=lsst.geom.Point2D(0, 0),\n crval=lsst.geom.SpherePoint(358, 0, lsst.geom.degrees),\n cdMatrix=afwGeom.makeCdMatrix(scale=1.1e-8*lsst.geom.degrees),\n )\n toExp = afwImage.ExposureF(afwImage.MaskedImageF(10, 10), toWcs)\n\n warpControl = afwMath.WarpingControl(\"lanczos3\")\n # if a bug described in ticket #2441 is present, this will raise an\n # exception:\n numGoodPix = afwMath.warpExposure(toExp, fromExp, warpControl)\n self.assertEqual(numGoodPix, 0)\n self.assertTrue(np.all(np.isnan(toExp.image.array)))\n self.assertTrue(np.all(np.isinf(toExp.variance.array)))\n noDataBitMask = afwImage.Mask.getPlaneBitMask(\"NO_DATA\")\n self.assertTrue(np.all(toExp.mask.array == noDataBitMask))","def _image(self):\n print(\"imaging\")\n self.images.append(self.device_control.image())\n yield","def dither_img(img,num_pxl,bw_threshold=128):\n\n img_copy = np.copy(img)\n img_copy[img_copy >= bw_threshold] = 255\n img_copy[img_copy < bw_threshold] = 0\n\n h = img_copy.shape[0]\n w = img_copy.shape[1]\n\n coordinates_0 = np.where(img_copy == 0)\n coordinates_0 = tuple(zip(coordinates_0[0],coordinates_0[1]))\n\n coordinates_255 = np.where(img_copy == 255)\n coordinates_255 = tuple(zip(coordinates_255[0],coordinates_255[1]))\n\n if num_pxl == 0:\n return img_copy\n\n selected_coordinates_0 = random.sample(coordinates_0,min(num_pxl,min(len(coordinates_0),len(coordinates_255))))\n selected_coordinates_255 = random.sample(coordinates_255,min(num_pxl,min(len(coordinates_0),len(coordinates_255))))\n\n selected_coordinates_0 = tuple(zip(*selected_coordinates_0))\n selected_coordinates_255 = tuple(zip(*selected_coordinates_255))\n\n img_copy[selected_coordinates_0[0],selected_coordinates_0[1]] = 255\n img_copy[selected_coordinates_255[0],selected_coordinates_255[1]] = 0\n\n return img_copy"],"string":"[\n \"def opd_dither(cfg):\\n \\n setpoint_new = pi.getINDI('PLC.UBCSettings.PLSetpoint')\\n file_number = pi.getINDI('NOMIC.CamInfo.FIndex') # Get initial file number\\n offsets = np.array(cfg['nomic_dither_opd_pattern']) * 5.0 * 180.0 / np.pi # input in rad at 11um, but commandet offsets in deg in K band\\n pi.setINDI('NOMIC.EditFITS.Keyword=spdthpos;Value=0.0;Comment=setpoint dither position (offset from nominal setpoint) in rad')\\n while True:\\n for i_step in range(0, len(cfg['nomic_dither_opd_pattern'])):\\n file_number = file_number + cfg['nomic_dither_opd_ndits'][i_step]\\n try:\\n pi.evalINDI ('\\\"NOMIC.CamInfo.FIndex\\\" >= %d' % file_number, timeout=900) # wait for cfg['nomic_dither_opd_ndits'][i] new files to arrive\\n except:\\n info('OPD dither offset timed out (more than 15 min since last offset)')\\n print(' or was interrupted.')\\n print(' Make sure to restart OPD dither pattern.')\\n return()\\n setpoint_old = pi.getINDI('PLC.UBCSettings.PLSetpoint') # ask for current setpoint\\n if (setpoint_old - setpoint_new) > 2.9: # if expected setpoint is more than ~0.01 rad (at 11um) different from current setpoint\\n info('Setpoint has changed between two dither positions.')\\n setpoint_new = setpoint_old + offsets[i_step] # determine new setpoint\\n pi.setINDI('NOMIC.EditFITS.Keyword=spdthpos;Value=' + str(np.sum(offsets[:i_step+1])) + ';Comment=setpoint dither position (offset from nominal setpoint) in rad')\\n pi.setINDI('PLC.PLSetpoint.PLSetpoint=' + str(setpoint_new) + ';forNAC=0') # send a dither offset\",\n \"def endexposureloop(self):\\n self.max_exposures = self.current_exposure\",\n \"def do_pixels(self):\\n self.do_yurt_pixels()\\n self.do_petal_strip_pixels()\\n self.do_vase_pixels()\",\n \"def run(self):\\n openShutter = True\\n actuateXed = False\\n image_type = \\\"PPUMP\\\"\\n\\n wl = float(self.eo_config.get(\\\"PPUMP_WL\\\", 550))\\n meas_flux = self.measured_flux(wl)\\n seqno = 0\\n for tokens in self.instructions:\\n exptime = float(tokens[1])\\n nframes = int(tokens[2])\\n shifts = int(tokens[3])\\n for iframe in range(nframes):\\n self.image_clears()\\n self.bias_image(seqno)\\n self.take_image(seqno, exptime, openShutter, actuateXed,\\n image_type)\\n seqno += 1\",\n \"def pixelMove(*args, **kwargs)->None:\\n pass\",\n \"def process(self, image):\",\n \"def update_image(self):\\n if self.filenames:\\n pos = self.slider.value()\\n proj, flat, dark, theta = dx.read_aps_32id(self.filenames, proj=(pos, pos+1))\\n if self.ffc_correction:\\n image = proj[0,:,:].astype(np.float)/flat[0,:,:].astype(np.float)\\n else:\\n image = proj[0,:,:].astype(np.float)\\n self.image_item.setImage(image)\",\n \"def warmup():\\n print camera.CoolerOFF()\\n camera.status.update()\",\n \"def punched(self):\\n if not self.dizzy:\\n self.dizzy = 1\\n self.original = self.image\\n Chimp.count_punch += 1\",\n \"def main():\\n camera = picamera.PiCamera()\\n camera.resolution = (RESOLUTIONX, RESOLUTIONY)\\n camera.iso = 800\\n time.sleep(2)\\n while True:\\n camera.capture('current-image.jpg')\\n adapt_steering(navigation.get_xposition('current-image.jpg'))\\n time.sleep(0.4)\",\n \"def __call__(self, frame_num):\\n # propagate and set the density\\n self.img.set_array(\\n np.abs(self.quant_sys.propagate(10)) ** 2\\n )\\n return self.img,\",\n \"def continue_with_exposure(self):\\r\\n # Allocate space to give to scan_until_abort, and name the two\\r\\n # rows appropriately.\\r\\n self.data_pair = self.cam.get_new_array(n_images=2)\\r\\n self.pump_probe_data = self.data_pair[0]\\r\\n self.probe_only_data = self.data_pair[1]\\r\\n # Keep track of which image will be updated next\\r\\n self.next_data_has_pump = True\\r\\n\\r\\n # Tell self.thread what to do when the camera has new images\\r\\n self.cam.new_images.connect(self.send_new_images)\\r\\n\\r\\n # Get the current array of wavelengths from cam\\r\\n self.wavelen_arr = self.cam.get_wavelen_array()\\r\\n\\r\\n # Queue a call to cam.scan_until_abort\\r\\n self.startAcq.emit(self.data_pair)\\r\\n\\r\\n # Tell listeners (plotting widgets) to start displaying data too\\r\\n self.startDisplay.emit()\",\n \"def run_observation(self):\\n\\n self._generate_direct_image() # to calibrate x_ref and y_ref\\n\\n num_frames = len(self.exp_start_times)\\n progress = Progress(num_frames)\\n self.progess = progress\\n\\n progress_line = 'Generating frames 0/{} done'.format(num_frames)\\n progress.print_status_line(progress_line)\\n progress.progress_line = progress_line\\n\\n for i, start_time in enumerate(self.exp_start_times):\\n filenum = i + 1\\n self._generate_exposure(start_time, filenum)\\n\\n progress.increment()\\n progress_line = 'Generating frames {}/{} done'.format(filenum,\\n num_frames)\\n progress.print_status_line(progress_line)\\n\\n # so it can be retreived by exposure_generator\\n progress.progress_line = progress_line\",\n \"def __call__(self, img, target):\\n if random.random() < 0.5:\\n img = ImageEnhance.Brightness(img).enhance(0.5 + random.random())\\n if random.random() < 0.5:\\n img = ImageEnhance.Color(img).enhance(0.5 + random.random())\\n if random.random() < 0.5:\\n img = ImageEnhance.Contrast(img).enhance(0.5 + random.random())\\n return img, target\",\n \"def do_stuff(self):\\n self.create_tourism_raster()\",\n \"def sample_damaging(image):\\r\\n return crease_image(blotch_image(image, 100, True), 10, False)\",\n \"def grass_drass():\",\n \"def step(self,image):\\r\\n\\r\\n\\t\\tself.gray = image\",\n \"def punched(self):\\n if not self.dizzy:\\n self.dizzy= 1\\n self.original= self.image\",\n \"def adjust_image_data(self):\\r\\n\\r\\n print('Adjusting image data: ')\\r\\n\\r\\n if self.removeFirstSequence: # used to remove the first trial from the sequence\\r\\n\\r\\n frames_per_rep = self.nFrames/self.nrepetitions\\r\\n\\r\\n self.imageData = self.imageData[frames_per_rep:, :, :]\\r\\n\\r\\n self.nFrames = self.imageData.shape[0]\\r\\n\\r\\n self.nrepetitions = int(self.nFrames/(self.period * self.framerate))\\r\\n\\r\\n self.times = np.arange(0, self.nFrames/self.framerate, 1.0/self.framerate)\\r\\n\\r\\n \\r\\n\\r\\n # first squeeze the image to 3d if it is 4d\\r\\n\\r\\n maxt = np.max(self.times) # find last image time\\r\\n\\r\\n sh = self.imageData.shape\\r\\n\\r\\n if len(sh) == 4:\\r\\n\\r\\n self.imageData = self.imageData.squeeze()\\r\\n\\r\\n sh = self.imageData.shape\\r\\n\\r\\n dt = np.mean(np.diff(self.times)) # get the mean dt\\r\\n\\r\\n n_Periods = int((maxt+dt)/self.period) # how many full periods in the image set - include the first?\\r\\n\\r\\n if self.nrepetitions > 0 and self.nrepetitions < n_Periods:\\r\\n\\r\\n n_Periods = self.nrepetitions\\r\\n\\r\\n n_PtsPerCycle = int(np.floor(self.period/dt)); # estimate image points in a stimulus cycle\\r\\n\\r\\n ndt = self.period/n_PtsPerCycle\\r\\n\\r\\n self.imageData = self.imageData[range(0, n_Periods*n_PtsPerCycle),:,:] # reduce to only what we need\\r\\n\\r\\n print (' Adjusted image info')\\r\\n\\r\\n print (\\\" # Periods: %d Pts/cycle: %d Cycle dt %8.4fs (%8.3fHz) Cycle: %7.4fs\\\" %(n_Periods, n_PtsPerCycle, ndt, 1.0/ndt, self.period))\\r\\n\\r\\n self.print_image_info()\",\n \"def _do_expose_loop(self, fitsfile, seconds):\\n log.debug(f\\\"Starting expose loop with {self.max_exposures} exposures\\\")\\n while (self.current_exposure is not None and \\n self.current_exposure < self.max_exposures):\\n self.current_exposure += 1\\n self.Expose(fitsfile, seconds)\\n while self.process and self.process.poll() is None:\\n sleep(5)\\n if not self.process or self.process.returncode != 0:\\n break\\n \\n self.current_exposure = None\\n self.max_exposures = None\",\n \"def on_run(self):\\n self.set_illumination({'mode': 'breathe'})\",\n \"def _generate_exposure(self, expstart, number):\\n\\n index_number = number - 1 # for zero indexing\\n\\n filename = '{:04d}_raw.fits'.format(number)\\n\\n exp_gen = ExposureGenerator(self.detector, self.grism, self.NSAMP,\\n self.SAMPSEQ, self.SUBARRAY,\\n self.planet, filename, expstart)\\n\\n if not self.spatial_scan:\\n self.sample_rate = 1 * u.year # high number reverts to read times\\n\\n _, sample_mid_points, sample_durations, read_index = \\\\\\n exp_gen._gen_scanning_sample_times(self.sample_rate)\\n\\n time_array = (sample_mid_points + expstart).to(u.day)\\n\\n if self.transmission_spectroscopy:\\n star_norm_flux = self.generate_lightcurves(time_array)\\n planet_depths = 1 - star_norm_flux\\n else:\\n planet_depths = None\\n\\n # x shifts - linear shift with exposure, second exposure shifted by\\n # x_shifts, direct image and first exp will match.\\n x_ref = self._try_index(self.x_ref, index_number)\\n y_ref = self._try_index(self.y_ref, index_number)\\n sky_background = self._try_index(self.sky_background, index_number)\\n\\n # X and Y Shifts\\n x_ref += self.x_shifts * index_number\\n y_ref += self.y_shifts * index_number\\n x_jitter = self.x_jitter\\n y_jitter = self.y_jitter\\n\\n if self._visit_trend:\\n scale_factor = self._visit_trend.get_scale_factor(index_number)\\n else:\\n scale_factor = None\\n\\n if self.spatial_scan:\\n exp_frame = exp_gen.scanning_frame(\\n x_ref, y_ref, x_jitter, y_jitter,\\n self.wl, self.stellar_flux, planet_depths,\\n self.scan_speed, self.sample_rate, sample_mid_points,\\n sample_durations, read_index, ssv_generator=self.ssv_gen,\\n noise_mean=self.noise_mean, noise_std=self.noise_std,\\n add_flat=self.add_flat, add_dark=self.add_dark,\\n scale_factor=scale_factor, sky_background=sky_background,\\n cosmic_rate=self.cosmic_rate,\\n add_gain_variations=self.add_gain_variations,\\n add_non_linear=self.add_non_linear,\\n clip_values_det_limits=self.clip_values_det_limits,\\n add_read_noise=self.add_read_noise,\\n add_stellar_noise=self.add_stellar_noise,\\n add_initial_bias=self.add_initial_bias,\\n progress_bar=self.progess,\\n threads=self.threads\\n )\\n else:\\n exp_frame = exp_gen.staring_frame(\\n x_ref, y_ref, x_jitter, y_jitter,\\n self.wl, self.stellar_flux, planet_depths,\\n sample_mid_points, sample_durations, read_index,\\n noise_mean=self.noise_mean, noise_std=self.noise_std,\\n add_flat=self.add_flat, add_dark=self.add_dark,\\n scale_factor=scale_factor, sky_background=sky_background,\\n cosmic_rate=self.cosmic_rate,\\n add_gain_variations=self.add_gain_variations,\\n add_non_linear=self.add_non_linear,\\n clip_values_det_limits=self.clip_values_det_limits,\\n add_read_noise=self.add_read_noise,\\n add_stellar_noise=self.add_stellar_noise,\\n add_initial_bias=self.add_initial_bias,\\n progress_bar=self.progess,\\n threads=self.threads\\n )\\n\\n exp_frame.generate_fits(self.outdir, filename, ldcoeffs=self.ldcoeffs)\\n\\n return exp_frame\",\n \"def process_walked_event(self, event):\\n sprite = self.sprites[event.id][1]\\n old_point = self.sprites[event.id][0]\\n self.sprites[event.id][0] = event.point\\n self.img[event.point.y, event.point.x] = self.sprite_colors[sprite]\\n self.img[old_point.y, old_point.x] = self.sprite_colors[\\\"Background\\\"]\",\n \"def main():\\n folder = \\\"D:\\\\\\\\Noam10\\\\\\\\Documents\\\\\\\\Documents\\\\\\\\dither 2\\\"\\n filename = \\\"kirigiri\\\"\\n filetype = \\\".jpg\\\"\\n input_file = folder + \\\"\\\\\\\\\\\" + filename + filetype\\n for palette in paletteDict.keys():\\n output_file = folder + \\\"\\\\\\\\\\\" + filename + \\\"(\\\" + palette + \\\").bmp\\\"\\n Dither(input_file, output=output_file, palette=paletteDict[palette])\\n print(output_file)\",\n \"def analysis_dFF_map(self):\\r\\n\\r\\n \\r\\n\\r\\n print ('Starting dF/F analysis:')\\r\\n\\r\\n self.print_image_info()\\r\\n\\r\\n # smoothwin = int(self.imageData.shape[1]/8.)\\r\\n\\r\\n # get the average image and the average of the whole image over time\\r\\n\\r\\n avgimg = np.mean(self.imageData, axis=0) # get mean image for reference later: average across all time\\r\\n\\r\\n \\r\\n\\r\\n mpl.figure(99)\\r\\n\\r\\n mpl.imshow(avgimg, vmin=0, vmax=np.max(np.max(avgimg, axis=0), axis=0))\\r\\n\\r\\n # self.meanimagevalue = np.mean(np.mean(avgimg, axis=1), axis=0)\\r\\n\\r\\n # self.stdimg = np.std(self.imageData, axis= 0) # and standard deviation\\r\\n\\r\\n imgdatasm = scipy.ndimage.filters.gaussian_filter(self.imageData,[0,2,2],order=0,output=None,mode='reflect',cval=0.0,truncate=4.0)\\r\\n # field correction: smooth the average image, subtract it from the imagedata, then add back the mean value\\r\\n avgimgsm = scipy.ndimage.filters.gaussian_filter(avgimg, 2, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\\r\\n\\r\\n # avgimgsm = scipy.ndimage.filters.gaussian_filter(avgimg, smoothwin, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\\r\\n\\r\\n #self.imageData = (self.imageData-avgimgsm)+ self.meanimagevalue\\r\\n\\r\\n mpl.figure(98)\\r\\n mpl.imshow(avgimgsm,vmin=0, vmax=np.max(np.max(avgimgsm, axis=0), axis=0))\\r\\n mpl.figure(97)\\r\\n mpl.imshow(np.mean(imgdatasm,axis=0))\\r\\n self.n_times = self.timebase\\r\\n\\r\\n periodsize = int(self.period*self.framerate)\\r\\n print('periodsize: ',periodsize)\\r\\n\\r\\n # windowsize = int(self.freqperiod*self.framerate) # window size for every response\\r\\n\\r\\n # r = range(0, self.imageData.shape[0], windowsize)\\r\\n\\r\\n sig = np.reshape(imgdatasm, (self.nrepetitions, periodsize, \\r\\n\\r\\n self.imageData.shape[1], self.imageData.shape[2]), order='C')\\r\\n\\r\\n delresp=np.zeros([19,256,256])\\r\\n repback = np.mean(sig[:,1:4,:,:],axis=1)\\r\\n resp = np.mean(sig[:,5:9,:,:],axis=1)\\r\\n for counter in range(19):\\r\\n delresp[counter,:,:]=(resp[counter,:,:]-repback[counter,:,:])/repback[counter,:,:]\\r\\n quot=np.mean(delresp,axis=0)\\r\\n quot=-quot\\r\\n print ('shape of quot: ', np.shape(quot))\\r\\n # quot=(resp-repback)/repback\\r\\n # quot[quot>0]=0\\r\\n # quot=-1000*quot\\r\\n\\r\\n mpl.figure(7)\\r\\n mpl.imshow(quot,cmap=mpl.cm.binary)\\r\\n mpl.colorbar()\\r\\n\\r\\n quotsm = scipy.ndimage.filters.gaussian_filter(quot, 3, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\\r\\n mpl.figure(8)\\r\\n mpl.imshow(quotsm,cmap=mpl.cm.binary)\\r\\n mpl.colorbar()\\r\\n \\r\\n # bl = np.mean(sig[:, range(0, sig.shape[1], windowsize), :, :], axis=0)\\r\\n\\r\\n # bl = scipy.ndimage.filters.gaussian_filter(bl, smoothwin, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\\r\\n\\r\\n\\r\\n\\r\\n # print (' windowsize: ', windowsize)\\r\\n\\r\\n # print (' periodsize: ', periodsize)\\r\\n # mc = matplotlib.cm\\r\\n\\r\\n # only use sequential maps here\\r\\n\\r\\n # clist = [mc.Reds, mc.YlOrBr, mc.Oranges, mc.Greens, mc.GnBu, mc.Blues, mc.RdPu, mc.Purples,mc.Reds,mc.Greens,mc.Blues,mc.Reds,mc.Reds,mc.Reds,mc.Reds]\\r\\n # clist2 = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet', 'black','red','purple','green','blue','red','red','red','red']\\r\\n\\r\\n cs = {}\\r\\n\\r\\n # sigd = np.zeros((bl.shape[0], sig.shape[2], sig.shape[3]))\\r\\n# \\r\\n # localmax = {}\\r\\n\\r\\n # sigmax = 0.\\r\\n# \\r\\n # kernel = np.ones((5, 5))\\r\\n\\r\\n # psf = kernel / np.sum(kernel)\\r\\n\\r\\n # compute dF/F, and get maximum over all frequencies\\r\\n\\r\\n print (' sig shape: ', sig.shape)\\r\\n\\r\\n # print (' bl shape: ', bl.shape)\\r\\n\\r\\n # smax = np.zeros(bl.shape[0])\\r\\n\\r\\n # for i in range(bl.shape[0]):\\r\\n\\r\\n # sigd[i] = (np.mean(np.max(sig[:,range(i*windowsize, i*windowsize+windowsize),:,:], axis=0), axis=0) - bl[i,:,:])/bl[i,:,:]\\r\\n\\r\\n # sigd[i] = sigd[i]**2.0\\r\\n\\r\\n # smooth\\r\\n\\r\\n #sigd[i] = scipy.ndimage.filters.gaussian_filter(sigd[i], 1., order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\\r\\n\\r\\n # deconvolve\\r\\n\\r\\n # sigd[i] = restoration.richardson_lucy(sigd[i], psf, 5)\\r\\n\\r\\n# sm = sigd[i].max().max()\\r\\n\\r\\n# if sm > sigmax:\\r\\n\\r\\n# sigmax = sm\\r\\n\\r\\n# smax[i] = sm\\r\\n\\r\\n# print( ' i, sm: ', i, sm)\\r\\n\\r\\n# # now process for display\\r\\n\\r\\n# print (' sigd shape: ', sigd.shape)\\r\\n\\r\\n# wdat = np.mean(sig, axis=0)\\r\\n\\r\\n# wds = wdat.shape\\r\\n\\r\\n# print('wdat shape: ', wds)\\r\\n\\r\\n# # print (range(int(wds[1]/2.), int(3.*wds[1]/4.)), range(int(wds[2]/2.), int(3.*wds[2]/4.)))\\r\\n\\r\\n# print( 'reduced shape: ', wdat[:,range(int(wds[1]/2.),int(3.*wds[1]/4.)),:][:,:,range(int(wds[2]/2.), int(3.*wds[2]/4.))].shape)\\r\\n\\r\\n# wp = wdat[:,range(int(wds[1]/2.),int(3.*wds[1]/4.)),:][:,:,range(int(wds[2]/2.), int(3.*wds[2]/4.))]\\r\\n\\r\\n# wp = np.mean(np.mean(wdat, axis=1), axis=1)\\r\\n\\r\\n# mpl.figure(1)\\r\\n\\r\\n# mpl.plot(np.linspace(0., len(wp)*1./self.framerate, num=len(wp)), wp)\\r\\n\\r\\n\\r\\n\\r\\n# mpl.figure(2)\\r\\n\\r\\n# for i in range(sigd.shape[0]):\\r\\n\\r\\n# sigd[i][sigd[i] < self.threshold*sigmax] = 0.\\r\\n\\r\\n# # find center of mass of areas above threshold\\r\\n\\r\\n# # mass = sigd[i].copy()\\r\\n\\r\\n# # mass[sigd[i] > 0.] = 1.\\r\\n\\r\\n# # structuring_element = [[0,1,0],[1,1,1],[0,1,0]]\\r\\n\\r\\n# # segmentation, segments = scipy.ndimage.label(mass, structuring_element)\\r\\n\\r\\n# # coords = scipy.ndimage.center_of_mass(sigd[i], segmentation, range(1,segments+1))\\r\\n\\r\\n# # xcoords = np.array([x[1] for x in coords])\\r\\n\\r\\n# # ycoords = np.array([x[0] for x in coords])\\r\\n\\r\\n# # cs[i] = (xcoords, ycoords)\\r\\n\\r\\n\\r\\n\\r\\n# # Calculating local maxima\\r\\n\\r\\n# lm = skif.peak_local_max(sigd[i], min_distance=2, threshold_rel=0.25, exclude_border=False, \\r\\n\\r\\n# indices=True, num_peaks=10, footprint=None, labels=None)\\r\\n\\r\\n# localmax[i] = [(m[0], m[1], sigd[i][(m[0], m[1])]) for m in lm]\\r\\n\\r\\n# # print ('i, local max: ',i, localmax)\\r\\n\\r\\n# mpl.subplot(5,5,i+1)\\r\\n# print ('shape of sigd: ',[np.shape(sigd),i])\\r\\n\\r\\n# imga1 = mpl.imshow(sigd[i], cmap=clist[i], vmin=0, origin='lower')\\r\\n\\r\\n# if len(localmax[i]) > 0:\\r\\n\\r\\n# max_fr = np.max([m[2] for m in localmax[i]])\\r\\n\\r\\n# else:\\r\\n\\r\\n# continue\\r\\n\\r\\n# scattersize = 30.\\r\\n\\r\\n# for k, lm in enumerate(localmax[i]):\\r\\n\\r\\n# mpl.scatter(lm[1], lm[0], marker='o', c=clist2[i], edgecolors='k',\\r\\n\\r\\n# s=scattersize*lm[2]/max_fr, linewidths=0.125, alpha=0.5)\\r\\n\\r\\n# mpl.subplot(6,5,i+15+1)\\r\\n\\r\\n# wr = range(i*windowsize, i*windowsize+windowsize)\\r\\n\\r\\n# # print (' wr: len, min max: ', len(wr), min(wr), max(wr))\\r\\n\\r\\n# wmax = 0.\\r\\n\\r\\n# for lmax in localmax[i]: # was xcoords\\r\\n\\r\\n# wave = wdat[wr, lmax[0],lmax[1]]\\r\\n\\r\\n# wdff = (wave-wave[0])/wave[0]\\r\\n\\r\\n# if np.max(wdff) > wmax:\\r\\n\\r\\n# wmax = np.max(wdff)\\r\\n\\r\\n# mpl.plot(np.linspace(0., len(wave)*1./self.framerate, num=len(wave)),\\r\\n\\r\\n# wdff, color=clist2[i])\\r\\n\\r\\n# mpl.ylim(-0.1*wmax, wmax)\\r\\n\\r\\n# fig = mpl.figure(3)\\r\\n\\r\\n# for i in range(sigd.shape[0]):\\r\\n\\r\\n# if len(localmax[i]) == 0:\\r\\n\\r\\n# continue\\r\\n\\r\\n# max_fr = np.max([m[2] for m in localmax[i]])\\r\\n\\r\\n# for lm in localmax[i]:\\r\\n\\r\\n# mpl.scatter(lm[1], lm[0], marker='o', c=clist2[i], \\r\\n\\r\\n# s=scattersize*lm[2]/max_fr, alpha=0.5, edgecolors='k')\\r\\n\\r\\n# mpl.ylim(0, sigd.shape[2])\\r\\n\\r\\n# mpl.xlim(0, sigd.shape[1])\\r\\n\\r\\n# mpl.axis('equal')\\r\\n\\r\\n mpl.show()\\r\\n\\r\\n print (' DF/F analysis finished.\\\\n')\",\n \"def expose_test(self):\\n with self.lock:\\n self.dark = 1\\n self.tstart = time.time()\\n self.timestamp = time.strftime(\\\"%Y-%m-%dT%H:%M:%S\\\", time.localtime(self.tstart))\\n imagesize = (self.expArea[3] - self.expArea[1],\\n self.expArea[2] - self.expArea[0])\\n self.data = np.ones(shape=imagesize, dtype=np.uint16)\\n self.tend = time.time()\",\n \"def __init__(self, inifile, dry_run, output):\\n\\n config = ConfigParser()\\n config.read(inifile)\\n sequence = config['dithersequence']\\n\\n # Set up the output.\\n self._output = output\\n\\n # Set up the file type and exposure sequence.\\n self._location = sequence['location']\\n self._filetype = sequence['filetype']\\n self._date = sequence['date']\\n self._exposures = [int(e) for e in sequence['exposures'].split()]\\n\\n if 'coordinates' not in config:\\n raise ValueError('no coordinates set for dither!')\\n \\n coords = config['coordinates']\\n self._dithertype = coords['dithertype']\\n \\n self._wcs = fits.getdata(coords['wcsfile'], 2)\\n self._wcs = self._wcs[np.argsort(self._wcs['mjd_obs'])]\\n self._central_exposure = int(sequence['centralexposure'])\\n\\n if coords['dithertype'] == 'telescope':\\n fadir = coords['fiberassigndir']\\n self._ditherfa = fits.getdata(os.path.join(\\n fadir, 'fiberassign-%s.fits' % coords['ditheredtilenum']))\\n self._unditherfa = fits.getdata(os.path.join(\\n fadir, 'fiberassign-%s.fits' % coords['unditheredtilenum']))\\n expnum = [int(fn.split('-')[1]) for fn in self._wcs['filename']]\\n centralind = expnum.index(self._central_exposure)\\n self._central_wcs = self._wcs[centralind]\\n\\n # Set the Tile ID for the output metadata.\\n self._tileid = coords['unditheredtilenum']\\n else:\\n raise ValueError('not implemented')\\n\\n # Extract the list of exposures on disk.\\n self._exposure_files = self._getfilenames()\\n\\n if not dry_run:\\n # Construct fiber output.\\n self._exposure_table = self._buildtable()\",\n \"def phot_aperture(input_file):\\n #set the original directory\\n original_path = os.getcwd()\\n save_path = input_file['save_path']\\n planet = input_file['exoplanet']\\n #radii = np.arange(input_file['apertures'][0],input_file['apertures'][1],0.1)\\n radii = np.array(input_file['apertures'])\\n #change to save data reduction directory\\n os.chdir(save_path)\\n if not os.path.exists('phot_results'):\\n os.makedirs('phot_results')\\n tempo = time.time()\\n print 'Starting aperture photometry'\\n print 'Saving results on: '+save_path+'/phot_results/'\\n \\n #check the number of objects to make the photometry\\n N_obj = len(input_file['pxpositions'])/2.\\n print 'Number of objects = ',N_obj\\n positions = [] #create the positions variable (X,Y) in pixels unit on the CCD\\n for i in range(len(input_file['pxpositions'])):\\n if i % 2 == 0: #if the number is a even (or not a odd), the turple is created\\n positions.append((input_file['pxpositions'][i],input_file['pxpositions'][i+1]))\\n print 'Radius from ',radii[0],' to ',radii[-1],'\\\\n'\\n \\n skysection = input_file['skysection']\\n skysection[0] = int(skysection[0])\\n skysection[1] = int(skysection[1])\\n \\n images = sorted(glob.glob('AB'+planet+'*.fits'))\\n for radius in radii:\\n flux_data = []\\n for i in range(len(images)):\\n im = fits.getdata(images[i],header=False)\\n im = array(im,dtype='Float64')\\n \\n # ERROR\\n #Traceback (most recent call last):\\n # File \\\"ExoTRed.py\\\", line 105, in <module>\\n # exotred.phot_aperture(input_file)\\n # File \\\"./sources/ExoTRed_core.py\\\", line 637, in phot_aperture \\n # File \\\"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/background/background_2d.py\\\", line 329, in __init__\\n # self._calc_bkg_bkgrms()\\n # File \\\"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/background/background_2d.py\\\", line 686, in _calc_bkg_bkgrms\\n # bkg = self._interpolate_meshes(self._bkg1d)\\n # File \\\"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/background/background_2d.py\\\", line 575, in _interpolate_meshes\\n # f = ShepardIDWInterpolator(yx, data)\\n # File \\\"/home/walter/bin/anaconda3/envs/iraf27/lib/python2.7/site-packages/photutils/utils/interpolation.py\\\", line 138, in __init__\\n # raise ValueError('The number of values must match the number '\\n # ValueError: The number of values must match the number of coordinates.\\n\\n # bkg = background.background_2d.Background2D(im,tuple(skysection))\\n # bkg_data = bkg.background\\n # bkg_rms = bkg.background_rms\\n\\n # phot_table = aperture_photometry(im - bkg_data, CircularAperture(positions, radius),\\n # error=bkg_rms, method ='center')#,effective_gain=float(input_file['gain']))\\n ####### SUBSTITUTE ROUTINE\\n window = 100\\n sky_size = im.shape\\n sky_mean = float(np.median(im[int(skysection[1]-window):int(skysection[1]+window),int(skysection[0]-window):int(skysection[0]+window)]))\\n bkg = np.random.poisson(sky_mean,sky_size)\\n apertures = CircularAperture(positions, radius)\\n phot_table = aperture_photometry(im, apertures, error=bkg)\\n #######\\n phot_table_flux = np.array([]) #saving results of aperture photometry\\n for j in range(len(phot_table['aperture_sum'])):\\n phot_table_flux = np.concatenate((phot_table_flux,np.array([phot_table['aperture_sum'][j]])),axis=0)\\n phot_table_flux = np.concatenate((phot_table_flux,np.array([phot_table['aperture_sum_err'][j]])),axis=0)\\n flux = np.concatenate((phot_table_flux,np.array([images[i]])),axis=0)\\n # flux = [phot_table['aperture_sum'][0], phot_table['aperture_sum'][1],phot_table['aperture_sum_err'][0],\\n # phot_table['aperture_sum_err'][1],images[i]]\\n flux_data.append(flux)\\n flux_data = DataFrame(flux_data)#,columns=['hoststar','refstar','hoststar_err','refstar_err','image'])\\n flux_data.to_csv('./phot_results/'+planet+'_flux_radius_'+str(radius)+'.csv',index=False)\\n use.update_progress((float(np.where(radii == radius)[0])+1.)/len(radii))\\n print 'Time total = ',abs(time.time()-tempo)/60.,' minutes'\\n os.chdir(original_path)\",\n \"def motion_extraction():\\n # iterate through frames\\n global frame_height, frame_width\\n global limb_coords, init_coords\\n frame_count = 0\\n has_frames, frame = capture.read()\\n\\n while has_frames:\\n img_out = frame.copy()\\n img_out = insert_padding(img_out, 14*14, 12*14)\\n\\n if frame_count == 0:\\n # change global values of height and width\\n frame_height = frame_height + 14*14*2\\n frame_width = frame_width + 12*14*2\\n get_start_positions(img_out)\\n img_out2 = segment_red(img_out, 200, 130)\\n #erode(img_out2, 4, 6)\\n remove_artifacts(img_out2)\\n #enhance_contrast(img_out2)\\n\\n if frame_count > 0:\\n get_motion(prev_frame, img_out2, frame_count)\\n\\n prev_frame = img_out2.copy()\\n frame_count += 1\\n has_frames, frame = capture.read()\",\n \"def main():\\n test_image = load_image()\\n\\n pixelate_image(\\n normalize_image(test_image)\\n )\\n pass\",\n \"def image_reduction(self, FF_name, BF_name, DF_name):\\n print '--------------------------------------------------------------------- image_reduction'\\n start_time = time.time() # Take time\\n\\n # Construct 3D cube of light-frames and flat-frames with dim(number, x-dim, y-dim):\\n FF_files = sort(glob.glob('{}{}*'.format(self.path, FF_name)))\\n BF_files = sort(glob.glob('{}{}*'.format(self.path, BF_name)))\\n DF_files = sort(glob.glob('{}{}*'.format(self.path, DF_name)))\\n\\n # Load images into an array:\\n if self.imgtype=='fits':\\n FF_i = array([pyfits.getdata(str(files)) for files in FF_files])\\n BF_i = array([pyfits.getdata(str(files)) for files in BF_files])\\n DF_i = array([pyfits.getdata(str(files)) for files in DF_files])\\n if self.imgtype=='rgb' : # Combine RGB:\\n FF_i = sum(array([asarray(Image.open(str(files))) for files in FF_files]), axis=3)\\n BF_i = sum(array([asarray(Image.open(str(files))) for files in BF_files]), axis=3)\\n DF_i = sum(array([asarray(Image.open(str(files))) for files in DF_files]), axis=3) \\n \\n # Median correction images:\\n FF = median(FF_i, axis=0) \\n BF = median(BF_i, axis=0)\\n DF = median(DF_i, axis=0)\\n \\n # Median correction images:\\n BF = median(BF_i, axis=0) # Master bias \\n # Correct for bias:\\n FF_m_b = median(FF_i-BF, axis=0)\\n FF_i_b = FF_i - BF\\n DF_b_m = median(DF_i-BF, axis=0) # Dark Current\\n # Scale dark to science frames:\\n hdulist = fits.open('{}'.format(str(DF_files[0])))\\n t_exp_DF = hdulist[0].header['EXPTIME'] # Exposure time (CHANGE HEADER NAME!!!)\\n DF = self.t_exp_LF/t_exp_DF * DF_b_m # Master dark \\n # Correct flats:\\n FF = median(FF_i_b - DF, axis=0) # Master flat\\n # Final correction:\\n CF_i = (self.LF_i - BF - DF)/FF # Calibrated science images \\n print 'Filter done in time: %0.5f s' %(time.time()-start_time)\\n \\n # Plot if you like:\\n if self.plot==1:\\n FITS(FF, 'linear', 3); plt.show() \\n FITS(BF, 'linear', 3); plt.show()\\n FITS(DF, 'linear', 3); plt.show() \\n FITS(self.LF_i[0], 'linear', 2); plt.show()\\n FITS(CF_i[0], 'linear', 2); plt.show()\\n \\n # Save if you like:\\n if self.save==1:\\n [imsave('{}CF_%02d.{}'.format(self.path, self.imgtype) %i, CF_i[i]) for i in range(self.n)]\",\n \"def __call__(self, rgbd_img_batch, color_id):\\n color = vis.id2color[color_id]\\n lower, upper = np.array(hsv_range[color])\\n #print('debug: rgbd_img_batch shape: ', rgbd_img_batch.shape)\\n\\n color_imgs, depth_imgs = rgbd_img_batch[:, :3, :, :], rgbd_img_batch[:, 3, :, :]\\n color_imgs = color_imgs.permute(0, 2, 3, 1) # NHWC\\n color_imgs_np = color_imgs.cpu().numpy()\\n\\n n = color_imgs.shape[0]\\n\\n\\n pcds = []\\n for idx in range(n):\\n depth_img = depth_imgs[idx]\\n hsv_img = cv2.cvtColor(color_imgs_np[idx].astype('uint8'), cv2.COLOR_RGB2HSV)\\n mask = cv2.inRange(hsv_img, lower, upper)\\n mask = torch.from_numpy(mask)\\n if self.use_cuda:\\n mask = mask.cuda()\\n mask_index = mask > 0\\n \\n #print('debug: {} points detected'.format(mask_index.sum().item()))\\n if mask_index.sum() > 0:\\n x_pcd = self.x_pix * depth_img / self.camera_f\\n y_pcd = self.y_pix * depth_img / self.camera_f\\n\\n # apply mask\\n x_pcd = -x_pcd[mask_index]\\n y_pcd = -y_pcd[mask_index]\\n z_pcd = -depth_img[mask_index]\\n pcd = torch.stack([x_pcd, y_pcd, z_pcd], dim=0)\\n pcd = self.camera_mat.mm(pcd) + self.camera_pos\\n pcd = pcd.transpose(0, 1)\\n pcd = sample_pcd(pcd, self.num_points)\\n else:\\n \\\"\\\"\\\"no points detected\\\"\\\"\\\"\\n print('Debug: pix2pcd warning: no point detected')\\n pcd = get_random_pcd(self.num_points)\\n\\n pcds.append(pcd)\\n pcds = torch.stack(pcds, dim=0)\\n return pcds\",\n \"def adjust(self, image):\\n ...\",\n \"def generate_movie(filename, x_size=640, y_size=360, numframes=150, dpi=100):\\n global timeflag\\n timeflag = 1\\n\\n # Functions for red, green, and blue channels - where the magic happens!\\n red_function = build_random_function(7, 9)\\n green_function = build_random_function(7, 9)\\n blue_function = build_random_function(7, 9)\\n print \\\"red_function:\\\\t\\\" + str(red_function)\\n print \\\"green_function:\\\\t\\\" + str(green_function)\\n print \\\"blue_function:\\\\t\\\" + str(blue_function)\\n\\n for n in range(1, numframes+1):\\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n x = remap_interval(i, 0, x_size, -1, 1)\\n y = remap_interval(j, 0, y_size, -1, 1)\\n t = remap_interval(n, 0, numframes, -1, 1)\\n pixels[i, j] = (\\n color_map(evaluate_random_function(red_function, x, y, t)),\\n color_map(evaluate_random_function(green_function, x, y, t)),\\n color_map(evaluate_random_function(blue_function, x, y, t))\\n )\\n im.save(\\\"movie_images/\\\"+'%03d'%n+\\\".png\\\")\\n\\n os.system(\\\"echo 'yes'|avconv -r 24 -i movie_images/%03d.png -vb 20M myart.mp4\\\")\\n\\n \\\"\\\"\\\"fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.set_aspect('equal')\\n ax.get_xaxis().set_visible(False)\\n ax.get_yaxis().set_visible(False)\\n\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n\\n def update_img(n):\\n # Functions for red, green, and blue channels - where the magic happens!\\n red_function = build_random_function(7, 9)\\n green_function = build_random_function(7, 9)\\n blue_function = build_random_function(7, 9)\\n\\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n x = remap_interval(i, 0, x_size, -1, 1)\\n y = remap_interval(j, 0, y_size, -1, 1)\\n pixels[i, j] = (\\n color_map(evaluate_random_function(red_function, x, y, n)),\\n color_map(evaluate_random_function(green_function, x, y, n)),\\n color_map(evaluate_random_function(blue_function, x, y, n))\\n )\\n im.save(\\\"test.png\\\")\\n return im\\n ani = animation.FuncAnimation(fig, update_img, numframes, interval=24) #TODO: FIX THIS\\n writer = animation.writers['avconv'](fps=24)\\n\\n ani.save(filename, writer=writer, dpi=dpi)\\\"\\\"\\\"\",\n \"def timeWarp(destExposure, srcExposure, warpingControl):\\n startTime = time.time()\\n for nIter in range(1, MaxIter + 1):\\n goodPix = afwMath.warpExposure(\\n destExposure, srcExposure, warpingControl)\\n endTime = time.time()\\n if endTime - startTime > MaxTime:\\n break\\n\\n return (endTime - startTime, nIter, goodPix)\",\n \"def __call__(self, images, targets):\\n pass\",\n \"def prepare_output(self):\\n self.output = np.copy(self.image)\\n self._highlight_qr_codes()\\n self._write_overlay_info()\",\n \"def Advance():\\n warp.step()\",\n \"def doDrizSeparate(self, pars):\\n \\n # Start by applying input parameters to redefine\\n # the output frame as necessary\\n for p in self.assoc.parlist:\\n\\n # First do some cleaning up, in case you are restarting...\\n fileutil.removeFile(p['outsingle'])\\n if (p['outsweight'] != ''):\\n fileutil.removeFile(p['outsweight'])\\n\\n # NB DO NOT USE \\\"tophat\\\" unless pixfrac is sufficiently\\n # large (> sqrt(2))\\n \\n p['fillval'] = pars['fillval']\\n \\n # Pass in the new wt_scale value\\n p['wt_scl'] = pars['wt_scl']\\n\\n if (p['single_driz_mask'] == None and self.static_mask != None):\\n p['single_driz_mask'] = self.static_mask.getMask(p['image'].signature())\\n \\n # 'in_units' will always be counts given that the input is converted to 'electrons' in call cases\\n p['in_units'] = 'counts'\\n \\n print(\\\"\\\\ndrizzle data='\\\"+p['data']+\\\"' outdata='\\\"+p['outsingle']+\\\"' outweig='\\\"+p['outsweight']+\\n \\\"' in_mask='static_mask\\\"+\\\"' kernel='\\\"+p['kernel']+\\n \\\"' outnx=\\\"+str(p['outnx'])+\\\" outny=\\\"+str(p['outny'])+\\\" xsh=\\\"+str(p['xsh'])+\\\" ysh=\\\"+str(p['ysh'])+\\n \\\" scale=\\\"+str(p['scale'])+\\\" pixfrac=\\\"+str(p['pixfrac'])+\\\" rot=\\\"+str(p['rot'])+\\n \\\" coeffs='\\\"+p['coeffs']+\\\"' wt_scl='\\\"+str(p['wt_scl'])+\\\"' align='center' shft_fr='output' shft_un='output'\\\"+\\n \\\" out_un='\\\"+p['units']+\\\"' expkey='\\\"+\\\"EXPTIME\\\"+\\\"' fillval='\\\"+str(p['fillval'])+\\\"'\\\"+\\n \\\" xgeoim='\\\"+p['xgeoim']+\\\"' ygeoim='\\\"+p['ygeoim']+\\\"'\\\\n\\\")\\n\\n # Perform separate drizzling now that all parameters have been setup...\\n self.assoc.run(single=True,save=True,build=False)\\n\\n # Now that we are done with the static mask, delete it...\\n del self.static_mask\",\n \"def extract(self, files):\\n for i in range(len(files)):\\n print(files[i])\\n img = cv2.imread('{}/{}'.format('{}/{}/{}'.format(DIR_2DST_Mask, self.patient, self.plan), files[i]), 0)\\n\\n \\\"\\\"\\\"\\n Find the indices of array elements that are non-zero, i.e,\\n find the pixels' positions that represents the respiratory\\n functions (pixels in the respiratory function are brighter).\\n \\\"\\\"\\\"\\n color_pts = np.argwhere(img > 70)\\n\\n \\\"\\\"\\\"\\n Sorts the pixels according to their x coordenate.\\n Obs: np.argwhere inverts x and y, it's like (y, x), because of it,\\n the parameter of itemgetter is 1 (to get x coordinate)\\n \\\"\\\"\\\"\\n lcolor_pts = sorted(color_pts.tolist(), key=itemgetter(1))\\n\\n \\\"\\\"\\\"\\n If there is no pixel representing the respiratory function\\n (i.e., lighter pixel) it creates an empty image (without any\\n respiratory function)\\n \\\"\\\"\\\"\\n if len(lcolor_pts) == 0:\\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\\n\\n cv2.imwrite('{}/{}/{}/{}'.format(\\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\\n\\n # file = open(\\n # '{}/{}/{}/points.txt'.format(DIR_2DST_Diaphragm, self.patient, self.plan), 'a')\\n # file.write(\\\"{}:{}\\\\n\\\".format(files[i], []))\\n # file.close()\\n\\n continue\\n\\n # Reverse the coordinates and store the result in lordered_pts list\\n lordered_pts = []\\n for j in range(len(lcolor_pts)):\\n lordered_pts.append(lcolor_pts[j][::-1])\\n\\n \\\"\\\"\\\"\\n Convert pixels coordinates into a tuples and check which column\\n has pixels that corresponding to diaphragmatic level\\n Obs. There are some columns that doesnt have any pixel that\\n correpond to diaphragmatic level.\\n \\\"\\\"\\\"\\n # Columns that have a pixel corresponding diaphragmatic level\\n lcolumn_available = []\\n for j in range(len(lordered_pts)):\\n lordered_pts[j] = tuple(lordered_pts[j])\\n lcolumn_available.append(lordered_pts[j][0])\\n lcolumn_available = list(set(lcolumn_available))\\n # print(\\\"Ordered points: \\\", lordered_pts)\\n # print(\\\"Columns available: \\\", lcolumn_available)\\n\\n \\\"\\\"\\\"\\n If there is not enough columns to build a respiratory pattern,\\n create a blank image\\n \\\"\\\"\\\"\\n if len(lcolumn_available) < 20:\\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\\n cv2.imwrite('{}/{}/{}/{}'.format(\\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\\n continue\\n\\n \\\"\\\"\\\"\\n If there are no pixel that corresponding diaphragmatic level in the\\n first column, assign to it the value of the second y coordinate\\n \\\"\\\"\\\"\\n if lcolumn_available[0] is not 0:\\n y = max(\\n [x for x in lordered_pts if x[0] == lcolumn_available[0]],\\n key=itemgetter(1))[1]\\n lordered_pts.insert(0, (0, y))\\n lcolumn_available.insert(0, 0)\\n\\n \\\"\\\"\\\"\\n If there are no pixel that corresponding diaphragmatic level in the\\n last column, assign to it the value of the penultimate y coordinate\\n available\\n \\\"\\\"\\\"\\n if lcolumn_available[-1] is not 49:\\n lordered_pts.append(\\n (49, lordered_pts[len(lcolumn_available)][1]))\\n lcolumn_available.append(49)\\n\\n \\\"\\\"\\\"\\n Get the biggest y value in each column that represents the\\n diaphragmatic level\\n \\\"\\\"\\\"\\n column = 0\\n lcolumn = []\\n ldiaphragm_pts = []\\n for j in range(50):\\n # Get the column's points\\n lcolumn = [x for x in lordered_pts if x[0] == column]\\n # print('{}: {}'.format(j, lcolumn))\\n\\n if len(lcolumn) > 0:\\n ldiaphragm_pts.append(\\n max(lcolumn, key=itemgetter(1))) # Get the biggest y\\n else:\\n # Get the y value from the previous column\\n lcolumn_available.insert(column, column)\\n ldiaphragm_pts.append((column, ldiaphragm_pts[-1][1]))\\n column += 1\\n lcolumn = []\\n\\n # Draw diaphragmatic level\\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\\n j = 0\\n while(j < len(lcolumn_available) - 1):\\n cv2.line(\\n diaphragmatic_lvl,\\n ldiaphragm_pts[j], ldiaphragm_pts[j + 1],\\n (0, 0, 255), 1)\\n j = j + 1\\n\\n lcolumn_available = []\\n\\n print(\\\"Diaphragmatic's points: \\\", ldiaphragm_pts)\\n cv2.imshow('Diaphragmatic level', diaphragmatic_lvl)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\\n cv2.imwrite('{}/{}/{}/{}'.format(\\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\\n\\n # file = open('{}/{}/{}/points.txt'.format(DIR_2DST_Diaphragm, self.patient, self.plan), 'a')\\n # file.write(\\\"{}:{}\\\\n\\\".format(files[i], ldiaphragm_pts))\\n # file.close()\\n\\n # return ldiaphragm_pts\",\n \"def sweep_image_model():\\n for c1 in [4, 8, 16]:\\n for c2 in [2, 4]:\\n for c3 in [2, 4]:\\n for c4 in [1, 2]:\\n flags = flag_reader.read_flag()\\n print(c1)\\n flags.channel_list = c1 * np.array([1, c2, c2*c3, c2*c3*c4])\\n print('channel list = ', flags.channel_list)\\n flags.last_dim = flags.channel_list[-1]\\n flags.model_name = flags.data_set + '_channel_' + str(flags.channel_list).replace('[','').replace(']','').replace(' ','_') + \\\\\\n '_dim_last_' + str(flags.last_dim) + '_ind_' + str(flags.comp_ind) + \\\\\\n '_lr_{}_decay_{}_reg_{}_bs_{}'.format(flags.lr, flags.lr_decay_rate, flags.reg_scale, flags.batch_size)\\n print(flags.model_name)\\n training_from_flag(flags)\",\n \"def pre_processing_image(img):\\n\\n #print(img.shape)\\n # apply gamma correction and show the images\\n #adjusted = adjust_gamma(img, gamma=0.65)\\n\\n adjusted = exposure.adjust_gamma(img, gamma=1.65)\\n #print(adjusted.shape)\\n\\n # log transform of image\\n\\n logarithmic_corrected = exposure.adjust_log(adjusted, 1)\\n #print(logarithmic_corrected.shape)\\n\\n # denoising\\n #dst2 = cv2.fastNlMeansDenoisingColored(logarithmic_corrected, None, 10, 10, 7, 21)\\n #print(dst2.shape)\\n dst2 = logarithmic_corrected\\n return dst2\",\n \"def exposure(frameType, expTime):\\n\\n blobEvent.clear() \\n\\n # set the specified frame type\\n if frameType.lower() == 'light':\\n ccd_frame[0].s = PyIndi.ISS_ON\\n ccd_frame[1].s = PyIndi.ISS_OFF\\n ccd_frame[2].s = PyIndi.ISS_OFF\\n ccd_frame[3].s = PyIndi.ISS_OFF \\n indiclient.sendNewSwitch(ccd_frame)\\n elif frameType.lower() == 'bias':\\n ccd_frame[0].s = PyIndi.ISS_OFF\\n ccd_frame[1].s = PyIndi.ISS_ON\\n ccd_frame[2].s = PyIndi.ISS_OFF\\n ccd_frame[3].s = PyIndi.ISS_OFF \\n indiclient.sendNewSwitch(ccd_frame)\\n elif frameType.lower() == 'dark':\\n ccd_frame[0].s = PyIndi.ISS_OFF\\n ccd_frame[1].s = PyIndi.ISS_OFF\\n ccd_frame[2].s = PyIndi.ISS_ON\\n ccd_frame[3].s = PyIndi.ISS_OFF \\n indiclient.sendNewSwitch(ccd_frame)\\n elif frameType.lower() == 'flat':\\n ccd_frame[0].s = PyIndi.ISS_OFF\\n ccd_frame[1].s = PyIndi.ISS_OFF\\n ccd_frame[2].s = PyIndi.ISS_OFF\\n ccd_frame[3].s = PyIndi.ISS_ON \\n indiclient.sendNewSwitch(ccd_frame)\\n\\n # set the value for the next exposure\\n ccd_exposure[0].value=expTime\\n\\n indiclient.sendNewNumber(ccd_exposure)\\n\\n # wait for the exposure\\n blobEvent.wait()\\n\\n for blob in ccd_ccd1:\\n # pyindi-client adds a getblobdata() method to IBLOB item\\n # for accessing the contents of the blob, which is a bytearray in Python\\n image_data=blob.getblobdata()\\n\\n # write the byte array out to a FITS file\\n global imgNum\\n global imgName\\n imgNum += 1\\n fileName = fileDir+'raw-'+str(imgNum).zfill(8)+'.fits'\\n f = open(fileName, 'wb')\\n f.write(image_data)\\n f.close()\\n imgName = fileName\\n \\n return fileName\",\n \"def forward_test(self, img, img_metas, **kwargs):\",\n \"def main():\\n original = SimpleImage('images/mt-rainier.jpg')\\n original.show()\\n reflected = make_reflected('images/mt-rainier.jpg')\\n reflected.show()\",\n \"def run(self):\\n\\n # need to think about outpath\\n\\n # Make sure all files are here and okay...\\n\\n if not self.config.galfile_pixelized:\\n raise ValueError(\\\"Code only runs with pixelized galfile.\\\")\\n\\n self.config.check_files(check_zredfile=True, check_bkgfile=True, check_bkgfile_components=True, check_parfile=True, check_zlambdafile=True)\\n\\n # Compute the border size\\n\\n self.config.border = self.config.compute_border()\\n\\n self.config.d.hpix = [self.pixel]\\n self.config.d.nside = self.nside\\n self.config.d.outbase = '%s_%d_%05d' % (self.config.outbase, self.nside, self.pixel)\\n\\n # Do the run\\n self.config.start_file_logging()\\n self.config.logger.info(\\\"Running redMaPPer on pixel %d\\\" % (self.pixel))\\n\\n firstpass = RunFirstPass(self.config)\\n\\n if not os.path.isfile(firstpass.filename):\\n firstpass.run()\\n firstpass.output(savemembers=False, withversion=False)\\n else:\\n self.config.logger.info(\\\"Firstpass file %s already present. Skipping...\\\" % (firstpass.filename))\\n\\n self.config.catfile = firstpass.filename\\n\\n # Clear out the firstpass memory\\n del firstpass\\n\\n like = RunLikelihoods(self.config)\\n\\n if not os.path.isfile(like.filename):\\n like.run()\\n like.output(savemembers=False, withversion=False)\\n else:\\n self.config.logger.info(\\\"Likelihood file %s already present. Skipping...\\\" % (like.filename))\\n\\n self.config.catfile = like.filename\\n\\n # Clear out the likelihood memory\\n del like\\n\\n perc = RunPercolation(self.config)\\n\\n if not os.path.isfile(perc.filename):\\n perc.run()\\n perc.output(savemembers=True, withversion=False)\\n else:\\n self.config.logger.info(\\\"Percolation file %s already present. Skipping...\\\" % (perc.filename))\\n\\n self.config.stop_file_logging()\",\n \"def use_effect(self):\\n if self.preview_name in FILTERS:\\n photo = Image.open(self.path.url[1:])\\n preview = photo.filter(FILTERS.get(self.preview_name))\\n preview.save(self.path.url[1:])\",\n \"def update(self):\\r\\n\\r\\n # Update the vision frames in the system\\r\\n self._system.update()\\r\\n\\r\\n # Create blank PIL images to hold the video streams\\r\\n layered = PIL.Image.new('RGBA', (400, 400))\\r\\n stacked = PIL.Image.new('RGBA', (200, 800))\\r\\n control = PIL.Image.new('RGBA', (600, 800))\\r\\n\\r\\n focalpoint = self._system[self._appString[\\\"device\\\"].get()].focalpoint()\\r\\n # print(focalpoint)\\r\\n\\r\\n # Get each vision key and vision for the selected device\\r\\n visionList = [(visionKey, vision) for visionKey, vision in self._system[self._appString[\\\"device\\\"].get()]]\\r\\n\\r\\n # Loop through each vision in the vision list\\r\\n for i, (visionKey, vision) in enumerate(visionList):\\r\\n\\r\\n # Grab the frames from the vision when it is \\\"curr\\\"\\r\\n frameList = [frame for frameKey, frame in vision if frameKey==self._appString[\\\"frame\\\"].get()]\\r\\n\\r\\n # Loop through each frame in the frame list\\r\\n for frame in frameList:\\r\\n\\r\\n # Get the properties and turn the image into RGBA\\r\\n ratio, size = vision.properties()\\r\\n rgbFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA)\\r\\n\\r\\n # print(rgbFrame.shape)\\r\\n width, height, channels = rgbFrame.shape\\r\\n\\r\\n # Paste the images together in layered\\r\\n\\r\\n imgFrame = PIL.Image.fromarray(cv2.resize(rgbFrame, (int(400 * ratio), int(400 * ratio))))\\r\\n layered.paste(imgFrame, (int(200 * (1 - ratio)), int(200 * (1 - ratio))))\\r\\n\\r\\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200 / width)), int(200 * (1 - ratio) - focalpoint[1] * (200 / height))))\\r\\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200 // width)), int(200 * (1 - ratio) - focalpoint[1] * (200 // height))))\\r\\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (ratio ** -1)), int(200 * (1 - ratio) - focalpoint[1] * (ratio ** -1))))\\r\\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200/width) / ratio), int(200 * (1 - ratio) - focalpoint[1] * (200/height) / ratio)))\\r\\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200 / width)), int(200 * (1 - ratio) - focalpoint[1] * (200 / height))))\\r\\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (ratio ** -1) / 200), int(200 * (1 - ratio) - focalpoint[1] * (ratio ** -1) / 200)))\\r\\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (400//width * (1- ratio))), int(200 * (1 - ratio) - focalpoint[1] * (400//height * (1 - ratio)))))\\r\\n\\r\\n # Paste the images together in stacked\\r\\n imgFrame = PIL.Image.fromarray(cv2.resize(rgbFrame, (200, 200)))\\r\\n stacked.paste(imgFrame, (0, 200 * i))\\r\\n\\r\\n # Add the stacked image to the canvas\\r\\n self._pilFrames[\\\"stacked\\\"] = PIL.ImageTk.PhotoImage(image=stacked)\\r\\n self._appCanvas[\\\"stacked\\\"].create_image(100, 0, image=self._pilFrames[\\\"stacked\\\"], anchor=tkinter.NW)\\r\\n\\r\\n # Add the layered image to the canvas\\r\\n self._pilFrames[\\\"layered\\\"] = PIL.ImageTk.PhotoImage(image=layered)\\r\\n self._appCanvas[\\\"layered\\\"].create_image(0, 0, image=self._pilFrames[\\\"layered\\\"], anchor=tkinter.NW)\\r\\n\\r\\n # Add the control image to the canvas\\r\\n imgFrame = cv2.cvtColor(self._system[self._appString[\\\"device\\\"].get()][self._appString[\\\"vision\\\"].get()][self._appString[\\\"frame\\\"].get()], cv2.COLOR_BGR2RGBA)\\r\\n control = PIL.Image.fromarray(cv2.resize(imgFrame, (600, 600)))\\r\\n self._pilFrames[\\\"control\\\"] = PIL.ImageTk.PhotoImage(image=control)\\r\\n self._appCanvas[\\\"control\\\"].create_image(100, 90, image=self._pilFrames[\\\"control\\\"], anchor=tkinter.NW)\\r\\n\\r\\n # Continue to update with a delay of 15\\r\\n self.after(15, self.update)\",\n \"def update(self):\\n if (self.j + self.step >= self.image.shape[0]) and (self.i + self.step >= self.image.shape[1]):\\n self.no_more_crops = True\\n elif self.i + self.step >= self.image.shape[1]:\\n self.i = 0\\n self.j += self.step\\n else:\\n self.i += self.step\",\n \"def transform(self, previousimage):\",\n \"def step(self, amt=1):\\n \\n # For checking if all the animations have their framse looked at\\n #activewormind = [i for i, x in enumerate(self._idlelist) if x == False]\\n #print \\\"Worm {} at {:5g}\\\".format(activewormind, 1000*(time.time() - starttime))\\n # save times activated for each worm \\n [self.timedata[i].append(1000*(time.time() - starttime)) for i, x in enumerate(self._idlelist) if x == False]\\n \\n #self._led.buffer = [0] * 480\\n self._led.pixheights = [-100] * self._led.numLEDs\\n #print type(self._led.buffer)\\n for ledcopy in self._ledcopies:\\n # self._led.buffer = map(ixor, self._led.buffer, ledcopy.buffer)\\n # use pixheights but assume all buffers same size\\n # print ledcopy.driver[0].pixheights\\n for pix in range(self._led.numLEDs):\\n #for ledcopy in self._ledcopies:\\n if self._led.pixheights[pix] == ledcopy.driver[0].pixheights[pix]:\\n for i in range(3):\\n self._led.buffer[3*pix + i] ^= ledcopy.buffer[3*pix + i]\\n elif self._led.pixheights[pix] < ledcopy.driver[0].pixheights[pix]:\\n for i in range(3):\\n self._led.buffer[3*pix + i] = ledcopy.buffer[3*pix + i]\\n self._led.pixheights[pix] = ledcopy.driver[0].pixheights[pix] \\n self._step += 1\",\n \"def process(image):\\n pass\",\n \"def cleanup(self):\\n self.subpixel, self.pixel = self.stepup(self.subpixel, self.pixel, AxisDistance.pixelsize)\\n self.pixel, self.tile = self.stepup(self.pixel, self.tile, AxisDistance.tilesize)\",\n \"def process_died_event(self, event):\\n old_point = self.sprites[event.id][0]\\n self.img[old_point.y, old_point.x] = self.sprite_colors[\\\"Background\\\"]\\n del self.sprites[event.id]\",\n \"def aperphot(fn, timekey=None, pos=[0,0], dap=[2,4,6], mask=None, verbose=False, nanval=999, resamp=None, retfull=False):\\n # 2009-09-14 10:49 IJC: Created\\n # 2010-01-15 14:20 IJC: Added numpy \\\"_string\\\" check\\n # 2011-12-29 12:01 IJMC: Added peak pixel values to photometry report.\\n # 2012-01-25 11:26 IJMC: Adding \\\"resamp\\\" option -- thanks to\\n # K. Stevenson and J. Harrington of UCF for\\n # the suggestion.\\n # 2012-02-26 11:53 IJMC: Now return 'ntarg' and 'nsky' -- number of pixels used.\\n # 2012-06-07 08:27 IJMC: 'peak' values are now corrected for the\\n # resampling factor.\\n # 2012-07-03 10:35 IJMC: Fixed a key bug: frames were not\\n # correctly background-subtracted when\\n # applying partial-pixel resampling.\\n # 2012-10-19 13:41 IJMC: Documented 'retfull' option; changed default.\\n # 2013-03-20 09:21 IJMC: More error-checking for saving header\\n # keywords. Thanks to A. Weigel @\\n # ETH-Zurich for catching this!\\n\\n from numpy import meshgrid, median,isfinite,sort,ndarray,string_\\n import numpy as np\\n import pyfits\\n #from analysis import fixval\\n from os import path\\n from scipy import interpolate\\n\\n thisobs = phot()\\n x0, y0 = pos\\n dap_targ, dap_skyinner, dap_skyouter = dap\\n if resamp is None or resamp<1:\\n resamp = 1\\n else:\\n resamp = float(resamp)\\n \\n # Determine size:\\n if isinstance(fn,str):\\n nx = pyfits.getval(fn, 'NAXIS1')\\n ny = pyfits.getval(fn, 'NAXIS2')\\n elif isinstance(fn,ndarray):\\n nx,ny = fn.shape\\n\\n nx0, ny0 = nx, ny\\n nx = ((nx - 1)*resamp + 1.) # Avoid resampling at pixel locations\\n ny = ((ny - 1)*resamp + 1.) # outside the original boundaries.\\n\\n # Generate or load masks:\\n if mask==None:\\n xx,yy = meshgrid(np.arange(ny)/resamp, np.arange(nx)/resamp)\\n mask_targ = makemask(xx, yy, (x0, y0, dap_targ))\\n mask_s1 = makemask(xx, yy, (x0,y0, dap_skyinner))\\n mask_s2 = makemask(xx, yy, (x0,y0, dap_skyouter))\\n mask_sky = mask_s2 - mask_s1\\n else:\\n mask_targ = mask==1\\n mask_sky = mask==2\\n if resamp>1:\\n print \\\"In aperphot, resamp>1 and user-specified mask passed in... beware!\\\"\\n\\n # Load data frame:\\n thisobs = phot()\\n if isinstance(fn,ndarray):\\n frame = fn\\n elif isinstance(fn, str) or isinstance(fn,string_):\\n if not path.isfile(fn):\\n print \\\"file %s not found! exiting...\\\" % fn\\n return thisobs\\n frame = pyfits.getdata(fn)\\n fixval(frame, nanval)\\n\\n # Resample data frame\\n if resamp>1:\\n frame0 = frame.copy()\\n xx0 = range(nx0)\\n yy0 = range(ny0)\\n x1,y1 = np.arange(nx)/resamp, np.arange(ny)/resamp\\n rectspline = interpolate.fitpack2.RectBivariateSpline(xx0, yy0, frame0, kx=1, ky=1, s=0)\\n frame = rectspline(x1, y1)\\n\\n #from pylab import *\\n #pdb.set_trace()\\n # Measure background and aperture photometry\\n thisbg, thisebg = estbg(frame, mask=mask_sky, plotalot=verbose, rout=[3,99])\\n thisphot = (mask_targ*(frame - thisbg)).sum() /resamp/resamp\\n peak = frame.max()\\n peak_targ = (mask_targ * frame).max()\\n peak_annulus = (mask_sky * frame).max()\\n\\n thisobs.bg=thisbg\\n thisobs.ebg=thisebg\\n thisobs.bgstr='phot.estbg: SDOM on bg histogram mean & dispersion after outlier rejection'\\n thisobs.phot=thisphot\\n thisobs.photstr='by-hand background-subtracted aperture photometry'\\n thisobs.ntarg = mask_targ.sum()/resamp/resamp\\n thisobs.nsky = mask_sky.sum()/resamp/resamp\\n\\n thisobs.peak = peak\\n thisobs.peak_targ = peak_targ\\n thisobs.peak_annulus = peak_annulus\\n thisobs.peakstr = 'peak pixel value in frame'\\n thisobs.peak_targstr = 'peak pixel value in target aperture'\\n thisobs.peak_annulusstr = 'peak pixel value in sky annulus'\\n thisobs.position = pos\\n thisobs.positionstr = 'user-specified, zero-indexed pixel coordinates.'\\n if isinstance(fn, str):\\n header = pyfits.getheader(fn)\\n if not timekey==None:\\n if timekey in header: \\n thisobs.time=header['timekey']\\n thisobs.timestr='heliocentric modified julian date'\\n if 'object' in header: thisobs.object = header['object']\\n if 'exptime' in header: thisobs.exptime = header['exptime']\\n thisobs.aper = dap\\n thisobs.aperstr = 'target, inner, outer aperture diameters, in pixels.'\\n thisobs.filename=fn\\n thisobs.resamp = resamp\\n if retfull:\\n thisobs.mask_targ = mask_targ\\n thisobs.mask_sky = mask_sky\\n thisobs.frame = frame\\n\\n if verbose:\\n from pylab import figure, colorbar\\n from nsdata import imshow\\n figure(); imshow(frame*mask_targ); colorbar()\\n figure(); imshow(frame*mask_sky); colorbar()\\n\\n return thisobs\",\n \"def start(self):\\n self.frame = 0\\n self._init_level(1)\\n self.reward = 0\\n self.pcontinue = 1\\n self.ghost_speed = self.ghost_speed_init\\n return self._make_image(), self.reward, self.pcontinue\",\n \"def hook_func(module, input, output):\\n image_name = get_image_name_for_hook(module)\\n data = output.clone().detach()\\n data = data.permute(1, 0, 2, 3)\\n vutil.save_image(data, image_name, pad_value=0.5)\",\n \"def augment(self, image):\\n pass\",\n \"def post_process(self):\\n\\t\\ti_s = 0\\n\\t\\ti_e = 0\\n\\t\\tif self.trans_t_dict[0][1] == 0:\\n\\t\\t\\tif len(self.noise_itv) == 0:\\n\\t\\t\\t\\tself.trans_t_dict[0][1] = self.fake_start_offset\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.trans_t_dict[0][1] = self.noise_itv[0][1] # start_offset\\n\\t\\t\\tself.trans_t_dict[0][2] = 0.1\\n\\t\\tif self.trans_t_dict[len(self.trans_t_dict)-1][1] == 0:\\n\\t\\t\\tif len(self.noise_itv) == 0:\\n\\t\\t\\t\\tself.trans_t_dict[len(self.trans_t_dict)-1][1] = self.fake_end_offset\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.trans_t_dict[len(self.trans_t_dict)-1][1] = self.noise_itv[-1][0] # end_offset\\n\\t\\t\\tself.trans_t_dict[len(self.trans_t_dict)-1][2] = 0.1\\n\\n\\t\\twhile i_s < len(self.trans_t_dict):\\n\\t\\t\\twhile i_s < len(self.trans_t_dict) and self.trans_t_dict[i_s][1] != 0:\\n\\t\\t\\t\\ti_s += 1\\n\\t\\t\\tif i_s == len(self.trans_t_dict):\\n\\t\\t\\t\\ti_e = len(self.trans_t_dict)\\n\\t\\t\\tif i_s < len(self.trans_t_dict):\\n\\t\\t\\t\\ti_s -= 1\\n\\t\\t\\t\\ti_e = i_s + 1\\n\\t\\t\\t\\twhile i_e < len(self.trans_t_dict) and self.trans_t_dict[i_e][1] == 0:\\n\\t\\t\\t\\t\\ti_e += 1\\n\\t\\t\\t\\tif i_e == len(self.trans_t_dict):\\n\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t# incorperate the noise inverval\\n\\t\\t\\t\\ts_time = self.trans_t_dict[i_s][1]\\n\\t\\t\\t\\te_time = self.trans_t_dict[i_e][1]\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tfor ts in self.noise_itv:\\n\\t\\t\\t\\t\\tif len(ts) == 2:\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\ttime1 = ts[0]\\n\\t\\t\\t\\t\\t\\ttime2 = ts[1]\\n\\t\\t\\t\\t\\t\\tif s_time < time1 and time2 < e_time:\\n\\t\\t\\t\\t\\t\\t\\te_time = min(e_time, time1)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\ttime0 = ts[0]\\n\\t\\t\\t\\t\\t\\tif s_time < time0 and time0 < e_time:\\n\\t\\t\\t\\t\\t\\t\\te_time = min(e_time, time0)\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tchar_len = 0\\n\\t\\t\\t\\tfor i in range(i_s, i_e):\\n\\t\\t\\t\\t\\tchar_len += len(self.trans_t_dict[i][0])\\n\\t\\t\\t\\t# ratio = float(self.trans_t_dict[i_e][1]-self.trans_t_dict[i_s][1]) / float(char_len)\\n\\t\\t\\t\\tratio = float(e_time - s_time) / float(char_len)\\n\\t\\t\\t\\tchar_len = 0\\n\\t\\t\\t\\t# s_time = self.trans_t_dict[i_s][1]\\n\\t\\t\\t\\tfor i in range(i_s+1, i_e):\\n\\t\\t\\t\\t\\tchar_len += len(self.trans_t_dict[i-1][0])\\n\\t\\t\\t\\t\\tself.trans_t_dict[i][1] = s_time + char_len * ratio\\n\\t\\t\\t\\t\\tself.trans_t_dict[i][2] = len(self.trans_t_dict[i][0]) * ratio\\n\\t\\t\\ti_s = i_e\",\n \"def apply_filter(self, image):\\n pass\",\n \"def preprocess(args):\\n \\n # Set up options\\n src = args.src\\n dest = args.dest\\n collect_path = args.collect_path\\n formats = args.formats\\n ref_img_path = args.ref_img_path\\n width = args.width\\n debug = args.debug\\n if debug:\\n print args.__dict__\\n # Make necessary directories if there is not.\\n if not os.path.exists(dest):\\n os.mkdir(dest)\\n if not os.path.exists(collect_path):\\n os.mkdir(collect_path)\\n\\n # Open referce image and trying to find the face in it.\\n try:\\n ref_img_origin = Image.open(os.path.abspath(ref_img_path))\\n except IOError as e:\\n print \\\"[IOError] Can't open the reference imgae: {}\\\".format(ref_img_path)\\n print \\\"[Info] Terminating....\\\"\\n return 1\\n\\n face_ref_coor, degree_ref = segment_tools.faces_positions(ref_img_origin)\\n \\n # Only one face is allowed in referece image. Raise error if it isn't.\\n # Crop the origin image to get the face image.\\n if face_ref_coor.shape[0] > 1:\\n raise MultiFaceError(\\\"Detect multiple faces in reference image. There should be only one face.\\\")\\n face_ref = segment_tools.crop_img(ref_img_origin, face_ref_coor[0], offset = True)\\n\\n # Adjust that image to make eyes lie on horizontal line.\\n try:\\n eye_angle = face_align_tools.eyes_horizon_angle(face_ref)\\n except segment_tools.NotDetectedError:\\n print \\\"[NotDetectedError] This reference image is not good enough. The program can't make the eyes horizontal.\\\"\\n print \\\"[NotDetectedError] Pleas use another reference image.\\\"\\n print \\\"Terminating....\\\"\\n return 1\\n\\n total_degree = eye_angle + degree_ref\\n img_ref_rotated = ref_img_origin.rotate(total_degree, resample = Image.CUBIC)\\n face_ref_coor, _ = segment_tools.faces_positions(img_ref_rotated)\\n face_ref = segment_tools.crop_img(img_ref_rotated, face_ref_coor[0], offset = True)\\n \\n # Resize the reference face to desired witdh (but preserve the width/heigh ratio.)\\n ref_width, ref_heigh = face_ref.size\\n face_ref = face_ref.resize((width, ref_heigh*width/ref_width))\\n if debug:\\n face_ref.show()\\n \\n ref_file_name = os.path.basename(ref_img_path)\\n face_ref.save(os.path.join(os.path.abspath(dest), \\\"ref_\\\" + ref_file_name))\\n print \\\"[Info] Complete preprocess of reference image.\\\"\\n\\n # Walk through the source directory.\\n print \\\"[Info] Start processing files in {src}.\\\".format(src = os.path.abspath(src))\\n for rel_path, dir_names, file_names in os.walk(os.path.abspath(src)):\\n for filename in file_names:\\n if np.any(map(filename.endswith, formats)):\\n file_path = os.path.join(os.path.abspath(rel_path), filename)\\n print \\\"[Info] Start processing {file_path}.\\\".format(file_path = file_path)\\n try:\\n target_img_origin = Image.open(file_path)\\n except IOError as e:\\n print \\\"[IOError] Can not open {}\\\".format(file_path)\\n print \\\"[Info] Passing this image.\\\"\\n continue\\n \\n # Try to find faces in target image. If don't, copy it to collection directory.\\n try:\\n faces_target_coors, degree_target = segment_tools.faces_positions(target_img_origin)\\n except segment_tools.NotDetectedError as e:\\n print \\\"[NotDetectedError] Does not find any face in {filename}. Collect it into {collect_path}\\\".format(filename = filename, collect_path = collect_path)\\n target_img_origin.save(os.path.join(os.path.abspath(collect_path), filename))\\n continue # Brake loop for not finding any face in the picture.\\n\\n # Adjust all found faces to make them just.\\n target_img_rotated = target_img_origin.rotate(degree_target, resample = Image.CUBIC)\\n for face_coor in faces_target_coors:\\n temp_img = segment_tools.crop_img(target_img_rotated, face_coor, offset=True)\\n try:\\n eyes_degree = face_align_tools.eyes_horizon_angle(temp_img)\\n except segment_tools.NotDetectedError:\\n eyes_degree = 0\\n face_target = temp_img.rotate(eyes_degree)\\n temp_file_name = random_prefix() + filename\\n if debug:\\n face_target.show()\\n face_target.save(os.path.join(os.path.abspath(dest), temp_file_name))\\n temp_aligned_file_name = \\\"aligned_\\\" + temp_file_name\\n try:\\n face_target_aligned = face_align_tools.face_align(face_ref, face_target)\\n face_target_aligned.save(os.path.join(os.path.abspath(dest), temp_aligned_file_name))\\n except segment_tools.NotDetectedError:\\n print \\\"[AlignError] Can't align face. Moving to {collection}.\\\".format(collection = collect_path)\\n face_target.save(os.path.join(os.path.abspath(collect_path), \\\"not_aligned_\\\" + temp_file_name))\\n print \\\"[Info] Saving {}\\\".format(os.path.join(os.path.abspath(collect_path), \\\"not_aligned_\\\" + temp_file_name))\\n continue\\n masked_target_img = segment_tools.mask_img(target_img_rotated, faces_target_coors)\\n\\n if debug:\\n masked_target_img.show()\\n masked_target_img.save(\\\"masked.jpg\\\")\\n \\n try:\\n while True:\\n temp_face_coors, temp_degree = segment_tools.faces_positions(masked_target_img)\\n temp_img = masked_target_img.rotate(temp_degree, resample = Image.CUBIC)\\n if debug:\\n print \\\"temp_face_coors\\\", temp_face_coors\\n print \\\"[Info] Multiple faces are found in {file_path}\\\".format(file_path = file_path)\\n for face_coor in temp_face_coors:\\n temp_face = segment_tools.crop_img(temp_img, face_coor, offset = True)\\n eye_angle = face_align_tools.eyes_horizon_angle(temp_face)\\n face_target = temp_face.rotate(eye_angle, resample = Image.CUBIC)\\n if debug:\\n face_target.show()\\n face_target_aligned = face_align_tools.face_align(face_ref, face_target)\\n temp_file_name = random_prefix() + filename\\n temp_aligned_file_name = \\\"aligned_\\\" + temp_file_name\\n print \\\"[Info] Sucessful aligned {}\\\".format(temp_file_name)\\n if debug:\\n masked_target_img.show()\\n except segment_tools.NotDetectedError:\\n file_path = os.path.join(os.path.abspath(rel_path), filename)\\n print \\\"[Info] Complete searching faces in {file_path}\\\".format(file_path = file_path)\",\n \"def test_rolling_before_analysis(self):\\n cheese = TomoCheese.from_demo_images()\\n cheese.analyze()\\n original_roi_1 = copy.copy(cheese.module.rois[\\\"1\\\"].pixel_value)\\n for img in cheese.dicom_stack:\\n img.roll(direction=\\\"x\\\", amount=20)\\n cheese.analyze()\\n new_roi_1 = cheese.module.rois[\\\"1\\\"].pixel_value\\n assert math.isclose(original_roi_1, new_roi_1, abs_tol=3)\",\n \"def test_do_manga_dither_after_sequence(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['boss_science'])\\n dither = 'N'\\n cmdState = self.actorState.doMangaSequence\\n cmdState.reinitialize(self.cmd)\\n cmdState.count = 1\\n cmdState.dithers = 'NSE'\\n cmdState.reset_ditherSeq()\\n self.cmd.verbose = False\\n masterThread.do_apogeemanga_sequence(self.cmd, cmdState, myGlobals.actorState)\\n self.cmd.reset()\\n self.cmd.verbose = self.verbose\\n self._do_manga_dither(4, 28, 0, 0, dither=dither)\",\n \"def augmenter(x, y):\\n # Note that we only use fliprots along axis=(1,2), i.e. the yx axis\\n # as 3D microscopy acquisitions are usually not axially symmetric\\n x, y = random_fliprot(x, y, axis=(1, 2))\\n x = random_intensity_change(x)\\n return x, y\",\n \"def go():\\n ##########\\n #\\n # MB19284\\n #\\n ##########\\n\\n ##########\\n # Kp-band reduction\\n ##########\\n\\n target = 'mb19284'\\n sci_files = ['i200822_a011{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\\n sci_files += ['i200822_a012{0:03d}_flip'.format(ii) for ii in range(2, 25+1)]\\n sky_files = ['i200822_a018{0:03d}_flip'.format(ii) for ii in range(2, 6+1)]\\n refSrc = [917.75, 1033.5] # This is the target\\n # Alternative star to try (bright star to bottom of target): [1015, 581.9]\\n \\n sky.makesky(sky_files, target, 'kp_tdOpen', instrument=osiris)\\n data.clean(sci_files, target, 'kp_tdOpen', refSrc, refSrc, field=target, instrument=osiris)\\n data.calcStrehl(sci_files, 'kp_tdOpen', field=target, instrument=osiris)\\n data.combine(sci_files, 'kp_tdOpen', epoch, field=target,\\n trim=0, weight='strehl', submaps=3, instrument=osiris)\\n\\n ##########\\n #\\n # KB200101\\n #\\n ##########\\n\\n ##########\\n # Kp-band reduction\\n ##########\\n\\n # -- If you have more than one position angle, make sure to\\n # clean them seperatly.\\n # -- Strehl and Ref src should be the pixel coordinates of a bright\\n # (but non saturated) source in the first exposure of sci_files.\\n # -- If you use the OSIRIS image, you must include the full filename in the list. \\n target = 'kb200101'\\n sci_files = ['i200822_a014{0:03d}_flip'.format(ii) for ii in range(2, 28+1)]\\n sci_files += ['i200822_a015{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\\n sci_files += ['i200822_a016{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\\n sky_files = ['i200822_a017{0:03d}_flip'.format(ii) for ii in range(2, 6+1)]\\n refSrc = [975, 1006] # This is the target\\n # Alternative star to try (bright star to right of target): [1158, 994]\\n \\n sky.makesky(sky_files, target, 'kp_tdOpen', instrument=osiris)\\n data.clean(sci_files, target, 'kp_tdOpen', refSrc, refSrc, field=target, instrument=osiris)\\n data.calcStrehl(sci_files, 'kp_tdOpen', field=target, instrument=osiris)\\n data.combine(sci_files, 'kp_tdOpen', epoch, field=target,\\n trim=1, weight='strehl', submaps=3, instrument=osiris)\",\n \"def main():\\n NAME = os.path.basename(__file__).split(\\\".\\\")[0]\\n\\n with its.device.ItsSession() as cam:\\n\\n props = cam.get_camera_properties()\\n\\n white_level = float(props['android.sensor.info.whiteLevel'])\\n black_levels = props['android.sensor.blackLevelPattern']\\n idxs = its.image.get_canonical_cfa_order(props)\\n black_levels = [black_levels[i] for i in idxs]\\n\\n # Expose for the scene with min sensitivity\\n sens_min, sens_max = props['android.sensor.info.sensitivityRange']\\n s_ae,e_ae,awb_gains,awb_ccm,_ = cam.do_3a(get_results=True)\\n s_e_prod = s_ae * e_ae\\n\\n # Make the image brighter since the script looks at linear Bayer\\n # raw patches rather than gamma-encoded YUV patches (and the AE\\n # probably under-exposes a little for this use-case).\\n s_e_prod *= 2\\n\\n # Capture raw frames across the full sensitivity range.\\n NUM_SENS_STEPS = 15\\n sens_step = int((sens_max - sens_min - 1) / float(NUM_SENS_STEPS))\\n reqs = []\\n sens = []\\n for s in range(sens_min, sens_max, sens_step):\\n e = int(s_e_prod / float(s))\\n req = its.objects.manual_capture_request(s, e)\\n req[\\\"android.colorCorrection.transform\\\"] = \\\\\\n its.objects.float_to_rational(awb_ccm)\\n req[\\\"android.colorCorrection.gains\\\"] = awb_gains\\n reqs.append(req)\\n sens.append(s)\\n\\n caps = cam.do_capture(reqs, cam.CAP_RAW)\\n\\n # A list of the (x,y) coords of the center pixel of a collection of\\n # patches of a color checker chart. Each patch should be uniform,\\n # however the actual color doesn't matter. Note that the coords are\\n # relative to the *converted* RGB image, which is 1/2 x 1/2 of the\\n # full size; convert back to full.\\n img = its.image.convert_capture_to_rgb_image(caps[0], props=props)\\n patches = its.image.get_color_checker_chart_patches(img, NAME+\\\"_debug\\\")\\n patches = [(2*x,2*y) for (x,y) in sum(patches,[])]\\n\\n lines = []\\n for (s,cap) in zip(sens,caps):\\n # For each capture, compute the mean value in each patch, for each\\n # Bayer plane; discard patches where pixels are close to clamped.\\n # Also compute the variance.\\n CLAMP_THRESH = 0.2\\n planes = its.image.convert_capture_to_planes(cap, props)\\n points = []\\n for i,plane in enumerate(planes):\\n plane = (plane * white_level - black_levels[i]) / (\\n white_level - black_levels[i])\\n for j,(x,y) in enumerate(patches):\\n tile = plane[y/2-16:y/2+16:,x/2-16:x/2+16:,::]\\n mean = its.image.compute_image_means(tile)[0]\\n var = its.image.compute_image_variances(tile)[0]\\n if (mean > CLAMP_THRESH and mean < 1.0-CLAMP_THRESH):\\n # Each point is a (mean,variance) tuple for a patch;\\n # for a given ISO, there should be a linear\\n # relationship between these values.\\n points.append((mean,var))\\n\\n # Fit a line to the points, with a line equation: y = mx + b.\\n # This line is the relationship between mean and variance (i.e.)\\n # between signal level and noise, for this particular sensor.\\n # In the DNG noise model, the gradient (m) is \\\"S\\\", and the offset\\n # (b) is \\\"O\\\".\\n points.sort()\\n xs = [x for (x,y) in points]\\n ys = [y for (x,y) in points]\\n m,b = numpy.polyfit(xs, ys, 1)\\n lines.append((s,m,b))\\n print s, \\\"->\\\", m, b\\n\\n # TODO: Clean up these checks (which currently fail in some cases).\\n # Some sanity checks:\\n # * Noise levels should increase with brightness.\\n # * Extrapolating to a black image, the noise should be positive.\\n # Basically, the \\\"b\\\" value should correspnd to the read noise,\\n # which is the noise level if the sensor was operating in zero\\n # light.\\n #assert(m > 0)\\n #assert(b >= 0)\\n\\n # Draw a plot.\\n pylab.plot(xs, ys, 'r')\\n pylab.plot([0,xs[-1]],[b,m*xs[-1]+b],'b')\\n matplotlib.pyplot.savefig(\\\"%s_plot_mean_vs_variance.png\\\" % (NAME))\\n\\n # Now fit a line across the (m,b) line parameters for each sensitivity.\\n # The gradient (m) params are fit to the \\\"S\\\" line, and the offset (b)\\n # params are fit to the \\\"O\\\" line, both as a function of sensitivity.\\n gains = [d[0] for d in lines]\\n Ss = [d[1] for d in lines]\\n Os = [d[2] for d in lines]\\n mS,bS = numpy.polyfit(gains, Ss, 1)\\n mO,bO = numpy.polyfit(gains, Os, 1)\\n\\n # Plot curve \\\"O\\\" as 10x, so it fits in the same scale as curve \\\"S\\\".\\n pylab.plot(gains, [10*o for o in Os], 'r')\\n pylab.plot([gains[0],gains[-1]],\\n [10*mO*gains[0]+10*bO, 10*mO*gains[-1]+10*bO], 'b')\\n pylab.plot(gains, Ss, 'r')\\n pylab.plot([gains[0],gains[-1]], [mS*gains[0]+bS, mS*gains[-1]+bS], 'b')\\n matplotlib.pyplot.savefig(\\\"%s_plot_S_O.png\\\" % (NAME))\\n\\n print \\\"\\\"\\\"\\n /* Generated test code to dump a table of data for external validation\\n * of the noise model parameters.\\n */\\n #include <stdio.h>\\n #include <assert.h>\\n double compute_noise_model_entry_S(int sens);\\n double compute_noise_model_entry_O(int sens);\\n int main(void) {\\n int sens;\\n for (sens = %d; sens <= %d; sens += 100) {\\n double o = compute_noise_model_entry_O(sens);\\n double s = compute_noise_model_entry_S(sens);\\n printf(\\\"%%d,%%lf,%%lf\\\\\\\\n\\\", sens, o, s);\\n }\\n return 0;\\n }\\n\\n /* Generated functions to map a given sensitivity to the O and S noise\\n * model parameters in the DNG noise model.\\n */\\n double compute_noise_model_entry_S(int sens) {\\n double s = %e * sens + %e;\\n return s < 0.0 ? 0.0 : s;\\n }\\n double compute_noise_model_entry_O(int sens) {\\n double o = %e * sens + %e;\\n return o < 0.0 ? 0.0 : o;\\n }\\n \\\"\\\"\\\"%(sens_min,sens_max,mS,bS,mO,bO)\",\n \"def prepro(I):\\n# I = env.reset() # Use this to verify, whats happening\\n# plt.imshow(I)\\n I = I[35:195] # crop and keep only the play area\\n I = I[::2,::2,0] # downsample by factor of 2, take every second row and column, and take only \\\"R\\\" component out of RGB image\\n I[I == 144] = 0 # erase background (background type 1)\\n I[I == 109] = 0 # erase background (background type 2)\\n I[I != 0] = 1 # everything else (but paddles, ball) just set to 1\\n return I.astype(np.float).ravel() # convert to 1D array and return\",\n \"def forward(self, x): \\n pal1_sources = list()\\n pal2_sources = list()\\n loc_pal1 = list()\\n conf_pal1 = list()\\n loc_pal2 = list()\\n conf_pal2 = list()\\n\\n # apply vgg up to conv3_3 relu\\n for k in range(16):\\n x = self.vgg[k](x)\\n\\n of1 = x\\n s = self.L2Normof1(of1)\\n pal1_sources.append(s)\\n \\n # apply vgg up to conv4_3 relu\\n for k in range(16, 23):\\n x = self.vgg[k](x)\\n\\n of2 = x\\n s = self.L2Normof2(of2)\\n pal1_sources.append(s)\\n\\n # apply vgg up to conv5_3 relu\\n for k in range(23, 30):\\n x = self.vgg[k](x)\\n of3 = x\\n s = self.L2Normof3(of3)\\n pal1_sources.append(s)\\n\\n # apply vgg up to fc7\\n for k in range(30, len(self.vgg)):\\n x = self.vgg[k](x)\\n of4 = x\\n pal1_sources.append(of4)\\n \\n # apply extra layers and cache source layer outputs\\n for k in range(2):\\n x = F.relu(self.extras[k](x), inplace=True)\\n of5 = x\\n pal1_sources.append(of5)\\n for k in range(2, 4):\\n x = F.relu(self.extras[k](x), inplace=True)\\n of6 = x\\n pal1_sources.append(of6)\\n\\n ## fpn module\\n \\\"\\\"\\\"\\n lfpn6 = self.fpn_topdown6(of6)\\n lfpn5 = self._upsample_product(self.fpn_topdown5(of6), self.fpn_latlayer5(of5))\\n lfpn4 = self._upsample_product(self.fpn_topdown4(of5), self.fpn_latlayer4(of4))\\n lfpn3 = self._upsample_product(self.fpn_topdown3(of4), self.fpn_latlayer3(of3))\\n lfpn2 = self._upsample_product(self.fpn_topdown2(of3), self.fpn_latlayer2(of2))\\n lfpn1 = self._upsample_product(self.fpn_topdown1(of2), self.fpn_latlayer1(of1))\\n\\n\\n ef1 = self.fpn_fem3_3(lfpn1)\\n ef1 = self.L2Normef1(ef1)\\n ef2 = self.fpn_fem4_3(lfpn2)\\n ef2 = self.L2Normef2(ef2)\\n ef3 = self.fpn_fem5_3(lfpn3)\\n ef3 = self.L2Normef3(ef3)\\n\\n ef4 = self.fpn_fem7(lfpn4)\\n ef5 = self.fpn_fem6_2(lfpn5)\\n ef6 = self.fpn_fem7_2(lfpn6)\\n \\\"\\\"\\\"\\n\\n conv7 = F.relu(self.fpn_topdown[0](of6), inplace=True)\\n x = F.relu(self.fpn_topdown[1](conv7), inplace=True)\\n conv6 = F.relu(self._upsample_product(x, self.fpn_latlayer[0](of5)), inplace=True)\\n\\n x = F.relu(self.fpn_topdown[2](conv6), inplace=True)\\n convfc7_2 = F.relu(self._upsample_product(x, self.fpn_latlayer[1](of4)), inplace=True)\\n\\n x = F.relu(self.fpn_topdown[3](convfc7_2), inplace=True)\\n conv5 = F.relu(self._upsample_product(x, self.fpn_latlayer[2](of3)), inplace=True)\\n\\n x = F.relu(self.fpn_topdown[4](conv5), inplace=True)\\n conv4 = F.relu(self._upsample_product(x, self.fpn_latlayer[3](of2)), inplace=True)\\n\\n x = F.relu(self.fpn_topdown[5](conv4), inplace=True)\\n conv3 = F.relu(self._upsample_product(x, self.fpn_latlayer[4](of1)), inplace=True)\\n\\n ef1 = self.fpn_fem[0](conv3)\\n ef1 = self.L2Normef1(ef1)\\n ef2 = self.fpn_fem[1](conv4)\\n ef2 = self.L2Normef2(ef2)\\n ef3 = self.fpn_fem[2](conv5)\\n ef3 = self.L2Normef3(ef3)\\n ef4 = self.fpn_fem[3](convfc7_2)\\n ef5 = self.fpn_fem[4](conv6)\\n ef6 = self.fpn_fem[5](conv7)\\n\\n pal2_sources = (ef1, ef2, ef3, ef4, ef5, ef6)\\n\\n ## first shot \\n for (x, l, c) in zip(pal1_sources, self.loc_pal1, self.conf_pal1):\\n loc_pal1.append(l(x).permute(0, 2, 3, 1).contiguous())\\n conf_pal1.append(c(x).permute(0, 2, 3, 1).contiguous())\\n \\n ## second shot\\n for (x, l, c) in zip(pal2_sources, self.loc_pal2, self.conf_pal2):\\n loc_pal2.append(l(x).permute(0, 2, 3, 1).contiguous())\\n conf_pal2.append(c(x).permute(0, 2, 3, 1).contiguous())\\n\\n # first shot\\n loc_pal1 = torch.cat([o.view(o.size(0), -1) for o in loc_pal1], 1)\\n conf_pal1 = torch.cat([o.view(o.size(0), -1) for o in conf_pal1], 1)\\n \\n # second shot\\n loc_pal2 = torch.cat([o.view(o.size(0), -1) for o in loc_pal2], 1)\\n conf_pal2 = torch.cat([o.view(o.size(0), -1) for o in conf_pal2], 1)\\n\\n if self.phase == 'test':\\n # 测试时， 仅使用shot2 的输出\\n output = self.detect(\\n loc_pal2.view(loc_pal2.size(0), -1, 4),\\n self.softmax(conf_pal2.view(conf_pal2.size(0), -1,\\n self.num_classes)), # conf preds\\n )\\n else:\\n ## 训练时，使用shot1 和 shot2 的输出\\n output = (\\n loc_pal1.view(loc_pal1.size(0), -1, 4),\\n conf_pal1.view(conf_pal1.size(0), -1, self.num_classes),\\n loc_pal2.view(loc_pal2.size(0), -1, 4),\\n conf_pal2.view(conf_pal2.size(0), -1, self.num_classes))\\n return output\",\n \"def forward_dummy(self, img):\\n output = self.generator(img)\\n return output\",\n \"def noiseReduction(self):\\n pass\",\n \"def __getitem__(self, index):\\n A_path = self.A_paths[index % self.A_size] # make sure index is within then range\\n #if self.opt.serial_batches: # make sure index is within then range\\n \\n\\n A_img = Image.open(A_path).convert('L')\\n \\n A = self.transform_A(A_img)\\n # B20 = self.transform_B(B20_img)\\n #B2 = self.transform_B(B2_img)\\n\\n\\n index_B50 = index % self.B50_size\\n B50_path = self.B50_paths[index_B50]\\n B50_img = Image.open(B50_path).convert('L')\\n B50 = self.transform_B(B50_img)\\n\\n\\n\\n index_B100 = index % self.B100_size\\n B100_path = self.B100_paths[index_B100]\\n B100_img = Image.open(B100_path).convert('L')\\n B100 = self.transform_B(B100_img)\\n\\n index_B150 = index % self.B150_size\\n B150_path = self.B150_paths[index_B150]\\n B150_img = Image.open(B150_path).convert('L')\\n B150 = self.transform_B(B150_img)\\n\\n\\n \\n\\n index_m0 = 0\\n m0_path = self.m0_paths[index_m0]\\n m0_img = Image.open(m0_path).convert('L')\\n m0 = self.transform_B(m0_img)\\n \\n index_m50 = 0\\n m50_path = self.m50_paths[index_m50]\\n m50_img = Image.open(m50_path).convert('L')\\n m50 = self.transform_B(m50_img)\\n\\n index_m100 = 0\\n m100_path = self.m100_paths[index_m100]\\n m100_img = Image.open(m100_path).convert('L')\\n m100 = self.transform_B(m100_img)\\n\\n index_m150 = 0\\n m150_path = self.m150_paths[index_m150]\\n m150_img = Image.open(m150_path).convert('L')\\n m150 = self.transform_B(m150_img)\\n\\n\\n\\n return {'A': A, 'B50': B50,'B100': B100, 'B150': B150, 'A_paths': A_path, 'B50_paths': B50_path,'B100_paths': B100_path, 'B150_paths': B150_path, 'm0':m0, 'm50':m50,'m100':m100, 'm150':m150}\",\n \"def Resampler(name):\\n\\n def resample_average(path, dsquery, dstile, image_format):\\n for i in range(1, dstile.RasterCount+1):\\n res = gdal.RegenerateOverview(dsquery.GetRasterBand(i), dstile.GetRasterBand(i), \\\"average\\\")\\n if res != 0:\\n raise ImageOutputException(\\\"RegenerateOverview() failed with error %d\\\" % res)\\n\\n gdal_write(path, dstile, image_format)\\n\\n def resample_antialias(path, dsquery, dstile, image_format):\\n querysize = dsquery.RasterXSize\\n tilesize = dstile.RasterXSize\\n\\n array = numpy.zeros((querysize, querysize, 4), numpy.uint8)\\n for i in range(dstile.RasterCount):\\n array[:,:,i] = gdalarray.BandReadAsArray(dsquery.GetRasterBand(i+1), 0, 0, querysize, querysize)\\n im = Image.fromarray(array, 'RGBA') # Always four bands\\n im1 = im.resize((tilesize,tilesize), Image.ANTIALIAS)\\n\\n if os.path.exists(path):\\n im0 = Image.open(path)\\n im1 = Image.composite(im1, im0, im1)\\n\\n ensure_dir_exists(path)\\n\\n if image_format == \\\"JPEG\\\":\\n im1.save(path, image_format, quality=jpeg_quality)\\n else:\\n im1.save(path, image_format)\\n\\n\\n if name == \\\"average\\\":\\n return resample_average\\n elif name == \\\"antialias\\\":\\n return resample_antialias\\n\\n resampling_methods = {\\n \\\"near\\\" : gdal.GRA_NearestNeighbour,\\n \\\"bilinear\\\" : gdal.GRA_Bilinear,\\n \\\"cubic\\\" : gdal.GRA_Cubic,\\n \\\"cubicspline\\\" : gdal.GRA_CubicSpline,\\n \\\"lanczos\\\" : gdal.GRA_Lanczos\\n }\\n\\n resampling_method = resampling_methods[name]\\n\\n def resample_gdal(path, dsquery, dstile, image_format):\\n querysize = dsquery.RasterXSize\\n tilesize = dstile.RasterXSize\\n\\n dsquery.SetGeoTransform( (0.0, tilesize / float(querysize), 0.0, 0.0, 0.0, tilesize / float(querysize)) )\\n dstile.SetGeoTransform( (0.0, 1.0, 0.0, 0.0, 0.0, 1.0) )\\n\\n res = gdal.ReprojectImage(dsquery, dstile, None, None, resampling_method)\\n if res != 0:\\n raise ImageOutputException(\\\"ReprojectImage() failed with error %d\\\" % res)\\n\\n gdal_write(path, dstile, image_format)\\n\\n return resample_gdal\",\n \"def exposure():\\n def r(x):\\n return x/6e4\\n\\n def w(x):\\n return int(x*6e4)\\n return r, w\",\n \"def process_frame(self, downsize):\\n # if (not hasattr(downsize,'shape')) and (not hasattr(downsize,'len')):\\n # downsize = np.array(downsize)\\n\\n if type(downsize) != np.ndarray:\\n raise TypeError\\n\\n if not downsize.any():\\n raise ValueError\\n\\n if self.pre_resize:\\n downsize = cv2.resize(downsize, (0, 0), fx=self.resize_factor, fy=self.resize_factor)\\n\\n self.frame_history.append(downsize)\\n\\n # Remove no longer needed frames from memory\\n self.frame_history = self.frame_history[-(self.LMC_rec_depth):]\\n downsize = signal.lfilter(self.b, self.a, self.frame_history, axis=0)[-1]\\n\\n # Center surround antagonism kernel applied.\\n\\n downsize = cv2.filter2D(downsize, -1, self.CSKernel)\\n\\n # RTC filter.\\n u_pos = deepcopy(downsize)\\n u_neg = deepcopy(downsize)\\n u_pos[u_pos < 0] = 0\\n u_neg[u_neg > 0] = 0\\n u_neg = -u_neg\\n\\n # On first step, instead of computing just save the images.\\n if self.t == self.T0:\\n self.v_pos_prev = deepcopy(u_pos)\\n self.v_neg_prev = deepcopy(u_neg)\\n self.u_pos_prev = deepcopy(u_pos)\\n self.u_neg_prev = deepcopy(u_neg)\\n\\n # Do everything for pos == ON.\\n tau_pos = u_pos - self.u_pos_prev\\n tau_pos[tau_pos >= 0] = 0.001\\n tau_pos[tau_pos < 0] = 0.1\\n mult_pos = self.rtc_exp(self.dt, tau_pos)\\n v_pos = -(mult_pos - 1) * u_pos + mult_pos * self.v_pos_prev\\n self.v_pos_prev = deepcopy(v_pos)\\n\\n # Do everything for neg == OFF.\\n tau_neg = u_neg - self.u_neg_prev\\n tau_neg[tau_neg >= 0] = 0.001\\n tau_neg[tau_neg < 0] = 0.1\\n mult_neg = self.rtc_exp(self.dt, tau_neg)\\n v_neg = -(mult_neg - 1) * u_neg + mult_neg * self.v_neg_prev\\n self.v_neg_prev = deepcopy(v_neg)\\n\\n # keep track of previous u.\\n self.u_pos_prev = deepcopy(u_pos)\\n self.u_neg_prev = deepcopy(u_neg)\\n\\n # Subtract v from u to give the output of each channel.\\n out_pos = u_pos - v_pos\\n out_neg = u_neg - v_neg\\n\\n # Now apply yet another filter to both parts.\\n out_pos = cv2.filter2D(out_pos, -1, self.H_filter)\\n out_neg = cv2.filter2D(out_neg, -1, self.H_filter)\\n out_pos[out_pos < 0] = 0\\n out_neg[out_neg < 0] = 0\\n\\n if self.t == self.T0:\\n self.out_neg_prev = deepcopy(out_neg)\\n\\n # Delay off channel.\\n out_neg = signal.lfilter(self.b1, self.a1, [self.out_neg_prev, out_neg], axis=0)[-1]\\n self.out_neg_prev = out_neg\\n downsize = out_neg * out_pos\\n\\n # Show image.\\n downsize *= self.gain\\n downsize = np.tanh(downsize)\\n\\n # Threshold.\\n downsize[downsize < self.threshold] = 0\\n\\n if not self.pre_resize:\\n downsize = cv2.resize(downsize, (0, 0), fx=self.resize_factor, fy=self.resize_factor)\\n\\n self.t += self.dt\\n\\n return downsize\",\n \"def manipulations(path):\\r\\n\\r\\n print (\\\"\\\\n Working on %s\\\\n\\\" %(path))\\r\\n\\r\\n # Creates a folder with the results for the current image\\r\\n if not os.path.exists(\\\"Results\\\\\\\\%s\\\" %(path)):\\r\\n os.makedirs(\\\"Results\\\\\\\\%s\\\" %(path))\\r\\n\\r\\n # The variations made of the image\\r\\n func.pixelImage(path, 10, 10)\\r\\n func.animate(path)\\r\\n func.colorScale(path, 0)\\r\\n func.colorScale(path, 1)\\r\\n func.colorScale(path, 2)\\r\\n func.scan(path, 280)\\r\\n func.greyImage(path)\\r\\n func.colorSteps(path, 1)\\r\\n func.inverted(path)\",\n \"def generate_images_pred(self, inputs, outputs):\\n for scale in self.scales:\\n disp = outputs[(\\\"disp\\\", scale)]\\n disp = F.interpolate(\\n disp, [self.height, self.width], mode=\\\"bilinear\\\", align_corners=False)\\n source_scale = 0\\n\\n _, depth = disp_to_depth(disp, self.min_depth, self.max_depth)\\n\\n outputs[(\\\"depth\\\", 0, scale)] = depth\\n\\n for i, frame_id in enumerate(self.frame_ids[1:]):\\n\\n T = outputs[(\\\"cam_T_cam\\\", 0, frame_id)]\\n\\n # from the authors of https://arxiv.org/abs/1712.00175\\n # mean-normalized inverse depth from [62] to discourage shrinking of the estimated depth\\n\\n axisangle = outputs[(\\\"axisangle\\\", 0, frame_id)]\\n translation = outputs[(\\\"translation\\\", 0, frame_id)]\\n\\n inv_depth = 1 / depth\\n mean_inv_depth = inv_depth.mean(3, True).mean(2, True)\\n\\n T = transformation_from_parameters(\\n axisangle[:, 0], translation[:, 0] * mean_inv_depth[:, 0], frame_id < 0)\\n\\n cam_points = self.backproject_depth[source_scale](\\n depth, inputs[(\\\"inv_K\\\", source_scale)])\\n pix_coords = self.project_3d[source_scale](\\n cam_points, inputs[(\\\"K\\\", source_scale)], T)\\n\\n outputs[(\\\"sample\\\", frame_id, scale)] = pix_coords\\n\\n outputs[(\\\"color\\\", frame_id, scale)] = F.grid_sample(\\n inputs[(\\\"color\\\", frame_id, source_scale)],\\n outputs[(\\\"sample\\\", frame_id, scale)],\\n padding_mode=\\\"border\\\")\\n\\n outputs[(\\\"color_identity\\\", frame_id, scale)] = \\\\\\n inputs[(\\\"color\\\", frame_id, source_scale)]\",\n \"def des_image(exptime=100,mag=None, Nstar=1,ccd=None,seeing=[0.9,0.,0.],npix=npix,zenith=0,filter='r', theta=0., phi=0,corrector='corrector',x=None,y=None,z=None,suband=None,regular=False,setbkg=True):\\n gain = 0.21 # convert electrons to ADU\\n zeropoint = 26.794176 # r band, from Nikolay\\n \\n if setbkg == False:\\n skyphoton = 0.\\n else:\\n skyphoton = 8.460140*exptime\\n bkg = skyphoton*gain\\n res = genImgV(filename=None,Nstar=Nstar,ccd=ccd,seeing=seeing,npix=npix,zenith=zenith,filter=filter, theta=theta, phi=phi,corrector=corrector,x=x,y=y,z=z,suband=suband,regular=regular)\\n if Nstar == 1:\\n objectphoton = exptime*10**(0.4*(zeropoint - mag))\\n psf = res[0][0][4:].reshape(npix,npix)\\n img = (psf * objectphoton + skyphoton)*gain\\n img = rebin(img,(40,40))\\n psf = rebin(psf,(40,40))\\n img = img + add_imageNoise(img)\\n if Nstar > 1:\\n img = []\\n psf = []\\n magg = []\\n for i in range(Nstar):\\n if type(mag) == list:\\n rng = abs(mag[1] - mag[0])\\n magi = min(mag)+np.random.rand()*rng\\n objectphoton = exptime*10**(0.4*(zeropoint - magi))\\n psfi = res[0][i][4:].reshape(npix,npix)\\n imgi = (psfi * objectphoton + skyphoton)*gain\\n imgi = imgi+np.sqrt(imgi)\\n imgi = rebin(imgi,(40,40))\\n psfi = rebin(psfi,(40,40))\\n imgi = imgi + add_imageNoise(imgi)\\n img.append(imgi)\\n psf.append(psfi)\\n magg.append(magi)\\n return img,bkg,psf,magg\",\n \"def main():\\n logging.basicConfig() # create a baseconfiguration s.t. we cann now log \\n cycle = 0\\n while True:\\n\\n logging.info(f\\\"{time.now()} - Start cycle {cycle}\\\") # changed from print to info \\n do_unstable_magick(cycle)\\n logging.info(f\\\"{time.nos()} - Finished cycle {cycle}\\\")\",\n \"def _aperture_to_photopoint_(self, *args, **kwargs):\\n\\n if not self.has_sky():\\n return super(GALEX,self)._aperture_to_photopoint_( *args, **kwargs )\\n\\n datacps, bkgdcps = args\\n datacounts = datacps[0]*self.exposuretime\\n bkgdcounts = bkgdcps[0]*self.exposuretime\\n \\n # ------------------\\n # - One Photopoint\\n if len(np.atleast_1d(datacounts))==1:\\n return get_photopoint(lbda=self.lbda,\\n datacounts=np.atleast_1d(datacounts)[0],\\n bkgdcounts=np.atleast_1d(bkgdcounts)[0],\\n exptime=self.exposuretime,\\n source=\\\"image\\\",mjd=self.mjd,\\n zp=self.mab0,\\n bandname=self.bandname,\\n instrument_name=self.instrument_name)\\n # -----------------------\\n # - Several Photopoints\\n return [get_photopoint(lbda=self.lbda,\\n datacounts=datacounts_,\\n bkgdcounts=bkgdcounts_,\\n exptime=self.exposuretime,\\n source=\\\"image\\\",mjd=self.mjd,\\n zp=self.mab0,bandname=self.bandname,\\n instrument_name=self.instrument_name)\\n for datacounts_,bkgdcounts_ in zip(datacounts,bkgdcounts)]\",\n \"def features_combine():\\n\\n\\n\\t# PROCESSING AUDIO\",\n \"def process_image(image):\\r\\n image = random_brightness(image)\\r\\n image = crop_image(image)\\r\\n image = resize(image)\\r\\n return image\",\n \"def process_sound_map():\\n pass\",\n \"def update_channels(imgs, msks, **settings):\\n\\n\\tshp = imgs.shape\\n\\tnew_imgs = np.zeros((shp[0],shp[1],shp[2], settings['IN_CHANNEL_NO']))\\n\\tnew_msks = np.zeros((shp[0],shp[1],shp[2], settings['OUT_CHANNEL_NO']))\\n\\n\\tif settings['MODE']==1:\\n\\t\\tnew_imgs[:,:,:,0] = imgs[:,:,:,2] # flair\\n\\t\\tnew_msks[:,:,:,0] = msks[:,:,:,0]+msks[:,:,:,1]+msks[:,:,:,2]+msks[:,:,:,3]\\n\\t\\tprint('-'*10,' Whole tumor', '-'*10)\\n\\n\\telif settings['MODE'] == 2:\\n\\t\\t#core (non enhancing)\\n\\t\\tnew_imgs[:,:,:,0] = imgs[:,:,:,0] # t1 post\\n\\t\\tnew_msks[:,:,:,0] = msks[:,:,:,3]\\n\\t\\tprint('-'*10,' Predicing enhancing tumor', '-'*10)\\n\\n\\telif settings['MODE'] == 3:\\n\\t\\t#core (non enhancing)\\n\\t\\tnew_imgs[:,:,:,0] = imgs[:,:,:,1]# t2 post\\n\\t\\tnew_msks[:,:,:,0] = msks[:,:,:,0]+msks[:,:,:,2]+msks[:,:,:,3] # active core\\n\\t\\tprint('-'*10,' Predicing active Core', '-'*10)\\n\\n\\telse:\\n\\t\\tnew_msks[:,:,:,0] = msks[:,:,:,0]+msks[:,:,:,1]+msks[:,:,:,2]+msks[:,:,:,3]\\n\\n\\treturn new_imgs.astype(np.float32), new_msks.astype(np.float32)\",\n \"def preprocess_images():\\n \\n # Set up the lists to collect the images and measurements\\n images = []\\n measurements = []\\n \\n # Set up the path to the data files \\n data_sets_path = 'data'\\n data_sets = [os.path.join(data_sets_path, i) for i\\n in os.listdir(data_sets_path)]\\n \\n # Step through the data folders and collect the images\\n # and the steering angles\\n for data_set in data_sets:\\n lines = []\\n \\n # Open up the csv file of image paths and steering angles\\n with open(os.path.join(data_set,\\n 'driving_log.csv')) as csvfile:\\n reader = csv.reader(csvfile)\\n for line in reader:\\n lines.append(line)\\n for line in lines:\\n source_path = line[0]\\n filename = source_path.split('\\\\\\\\')[-1]\\n current_path = os.path.join(data_set, 'IMG',\\n filename)\\n \\n # Import each image and change it to RGB\\n BGR_image = cv2.imread(current_path)\\n image = cv2.cvtColor(BGR_image, cv2.COLOR_BGR2RGB)\\n rows, cols, depth = image.shape\\n flipped_image = cv2.flip(image, 1)\\n \\n # Create a scaled version of the image\\n scale = [0.9, 1.1]\\n zoomfactor = random.choice(scale)\\n scale_matrix = cv2.getRotationMatrix2D((cols/2, rows/2),\\n 0, zoomfactor)\\n scaled_image = cv2.warpAffine(image, scale_matrix,\\n (cols, rows))\\n\\n # Append the images to the image list\\n images.append(image)\\n images.append(scaled_image)\\n images.append(flipped_image)\\n \\n # Append the steering angle to the measurements list\\n measurement = float(line[3])\\n measurements.append(measurement)\\n measurements.append(measurement)\\n measurements.append(-1*measurement)\\n \\n return images, measurements\",\n \"def measure(self, imgage, previous=None):\",\n \"def run():\\n scene = lm.scene_object()\\n copy_latest_low()\\n copy_latest_high()\",\n \"def main():\\n cam = Realsense()\\n # cam.access_intr_and_extr()\\n profile = cam.pipeline.start(cam.config)\\n depth_sensor = profile.get_device().first_depth_sensor()\\n depth_scale = depth_sensor.get_depth_scale()\\n align_to = rs.stream.color\\n align = rs.align(align_to)\\n\\n objp = np.zeros((3*4,3), np.float32)\\n objp[:,:2] = np.mgrid[0:4,0:3].T.reshape(-1,2)\\n axis = np.float32([[1,0,0], [0,1,0], [0,0,-1]]).reshape(-1,3)\\n # print(objp)\\n\\n try:\\n while (True):\\n # detect ArUco markers in RGB images\\n frames = cam.pipeline.wait_for_frames()\\n aligned_frames = align.process(frames)\\n color_frame = aligned_frames.get_color_frame()\\n color_image = np.asanyarray(color_frame.get_data()) \\n frame = color_image\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n corners, ids, rvecs, tvecs = cam.detect_markers_realsense(frame)\\n \\n if np.all(ids != None): # if markers are detected\\n for i in range(0, ids.size):\\n aruco.drawAxis(frame, cam.newcameramtx, cam.dist, rvecs[i],\\n tvecs[i], 0.1) # Draw axis\\n aruco.drawDetectedMarkers(frame, corners) # draw square around markers\\n\\n ###### DRAW ID #####\\n strg = ''\\n for i in range(0, ids.size):\\n strg += str(ids[i][0])+', '\\n\\n cv2.putText(frame, \\\"Id: \\\" + strg, (0,25), font, 1, (0,255,0), 2,\\n cv2.LINE_AA)\\n\\n\\t ###### Output marker positions in camera frame ######\\n \\t # output tvec\\n y0 = 60\\n dy = 40\\n for i in range(0, ids.size):\\n y = y0 + i*dy\\n cv2.putText(frame, str(tvecs[i][0]), (0, y), font, 1, (0,255,0),\\n 2, cv2.LINE_AA)\\n\\n else:\\n ##### DRAW \\\"NO IDS\\\" #####\\n cv2.putText(frame, \\\"No Ids\\\", (0,64), font, 1, (0,255,0), 2,\\n cv2.LINE_AA)\\n\\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n ret, corners = cv2.findChessboardCorners(gray, (4,3), None)\\n if ret == True:\\n corners2 = cv2.cornerSubPix(gray, corners,(11,11), (-1,-1),\\n cam.criteria)\\n corners2 = corners2[::-1]\\n # print(corners2)\\n # print(objp)\\n frame = cv2.drawChessboardCorners(frame, (4,3), corners2, ret)\\n # Find the rotation and translation vectors.\\n _, rvecs, tvecs = cv2.solvePnP(objp, corners2, cam.newcameramtx,\\n cam.dist)\\n rot, _ = cv2.Rodrigues(rvecs)\\n # print(rot)\\n # project 3D points to image plane\\n imgpts, jac = cv2.projectPoints(axis, rvecs, tvecs,\\n cam.newcameramtx, cam.dist)\\n frame = draw(frame, corners2, imgpts)\\n\\n # Display the resulting frame\\n cv2.imshow('frame',frame)\\n cv2.waitKey(5)\\n\\n # When everything done, release the capture\\n cv2.destroyAllWindows()\\n\\n finally:\\n cam.pipeline.stop()\",\n \"def update_anim(frame, self):\\n self.step()\\n self.im.set_data(self.array)\\n self.im2.set_data(self.array2)\",\n \"def augment():\\n print(\\\"augmenting......\\\")\\n path1 = '../trainp1/'\\n path2 = '../trainp2/'\\n # path of pair1 and pair2 similar to img & mask task for segmentation\\n p = Augmentor.Pipeline(path1) # pair1\\n p.ground_truth(path2) # pair2\\n p.rotate(probability=0.3, max_left_rotation=3, max_right_rotation=3) \\n p.flip_left_right(probability=0.2) \\n p.random_distortion(0.5, 2, 2, 2)\\n p.zoom(probability=0.5, min_factor=0.95, max_factor=1.05)\\n p.process()\",\n \"def main():\\n NAME = os.path.basename(__file__).split(\\\".\\\")[0]\\n\\n # Pass/fail thresholds\\n MIN_AVG_FRAME_DELTA = 30 # at least 30ms delta between frames\\n MAX_VAR_FRAME_DELTA = 0.01 # variance of frame deltas\\n MAX_FRAME_DELTA_JITTER = 0.3 # max ms gap from the average frame delta\\n\\n with its.device.ItsSession() as cam:\\n props = cam.get_camera_properties()\\n if not its.caps.manual_sensor(props):\\n print \\\"Test skipped\\\"\\n return\\n\\n req, fmt = its.objects.get_fastest_manual_capture_settings(props)\\n caps = cam.do_capture([req]*50, [fmt])\\n\\n # Print out the millisecond delta between the start of each exposure\\n tstamps = [c['metadata']['android.sensor.timestamp'] for c in caps]\\n deltas = [tstamps[i]-tstamps[i-1] for i in range(1,len(tstamps))]\\n deltas_ms = [d/1000000.0 for d in deltas]\\n avg = sum(deltas_ms) / len(deltas_ms)\\n var = sum([d*d for d in deltas_ms]) / len(deltas_ms) - avg * avg\\n range0 = min(deltas_ms) - avg\\n range1 = max(deltas_ms) - avg\\n print \\\"Average:\\\", avg\\n print \\\"Variance:\\\", var\\n print \\\"Jitter range:\\\", range0, \\\"to\\\", range1\\n\\n # Draw a plot.\\n pylab.plot(range(len(deltas_ms)), deltas_ms)\\n matplotlib.pyplot.savefig(\\\"%s_deltas.png\\\" % (NAME))\\n\\n # Test for pass/fail.\\n assert(avg > MIN_AVG_FRAME_DELTA)\\n assert(var < MAX_VAR_FRAME_DELTA)\\n assert(abs(range0) < MAX_FRAME_DELTA_JITTER)\\n assert(abs(range1) < MAX_FRAME_DELTA_JITTER)\",\n \"def expose(self):\\n\\n ## Determine type of exposure (exp, series, stack)\\n exptype = str(self.exptypeComboBox.currentText())\\n mode = self.modedict[exptype]\\n\\n ## Get exposure parameters\\n if mode == \\\"bias\\\":\\n exptime = 0.0\\n else:\\n exptime = self.exptimeSpinBox.value()\\n imcount = self.imstackSpinBox.value()\\n seqnum = self.imnumSpinBox.value()\\n mintime = self.minexpSpinBox.value()\\n maxtime = self.maxexpSpinBox.value()\\n step = self.tstepSpinBox.value()\\n\\n ## Determine filter kwargs\\n if self.filterToggleButton.isChecked():\\n kwargs = {'filter_name' : str(self.filterComboBox.currentText())}\\n else:\\n kwargs = {'monowl' : self.monoSpinBox.value()}\\n\\n if self.testimCheckBox.isChecked():\\n title = 'test'\\n else:\\n title = str(self.imtitleLineEdit.text())\\n\\n ## Build filepath\\n filepath = os.path.join(str(self.imfilenameLineEdit.text()),title)\\n \\n ## Check if single exposure\\n if exptype in [\\\"Exposure\\\", \\\"Dark\\\", \\\"Bias\\\"]:\\n\\n ## Perform exposure\\n self.logger.info(\\\"Starting {0}s {1} image.\\\".format(exptime, exptype))\\n self.image_start.emit(1)\\n\\n try:\\n filename = exposure.im_acq(mode, filepath, exptime, seqnum, **kwargs)\\n self.image_taken.emit(1)\\n except subprocess.CalledProcessError:\\n self.logger.exception(\\\"Error in executable {0}_acq. Image not taken.\\\".format(mode))\\n except OSError:\\n self.logger.exception(\\\"Executable {0}_acq not found. Image not taken\\\".format(mode))\\n except IOError:\\n self.logger.exception(\\\"File already exits. Image not taken.\\\")\\n else:\\n self.logger.info(\\\"Exposure {0} finished successfully.\\\".format(filename))\\n self.seqnum_inc.emit(seqnum)\\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename,\\n '-zoom', 'to', 'fit', '-cmap', 'b'])\\n\\n ## Check if a stack of exposures of same type\\n elif exptype in [\\\"Exposure Stack\\\", \\\"Dark Stack\\\", \\\"Bias Stack\\\"]:\\n\\n total = seqnum + imcount\\n self.logger.info(\\\"Starting {0}s {1} stack.\\\".format(exptime, exptype))\\n self.image_start.emit(imcount)\\n\\n try:\\n for i in range(seqnum, total):\\n self.logger.info(\\\"Starting image {0} of {1}.\\\".format(i+1-seqnum, imcount))\\n filename = exposure.im_acq(mode, filepath, exptime, i, **kwargs)\\n self.logger.info(\\\"Exposure {0} finished successfully.\\\".format(filename))\\n self.image_taken.emit(i+1-seqnum)\\n self.seqnum_inc.emit(i)\\n except subprocess.CalledProcessError:\\n self.logger.exception(\\\"Error in executable {0}_acq. Image not taken.\\\".format(mode))\\n except OSError:\\n self.logger.exception(\\\"Executable {0}_acq not found. Image not taken.\\\".format(mode))\\n except IOError:\\n self.logger.exception(\\\"File already exists. Image not taken.\\\")\\n else:\\n self.logger.info(\\\"Exposure stack finished successfully.\\\")\\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename, '-zoom', 'to', 'fit', '-cmap', 'b'])\\n \\n ## Check if a series of exposures of increase exposure time\\n elif exptype in [\\\"Exposure Series\\\", \\\"Dark Series\\\"]:\\n\\n ## Parameter checks\\n if mintime > maxtime:\\n self.logger.warning(\\\"Minimum time must be less than Maximum time. Series not started.\\\")\\n return\\n elif step <= 0:\\n self.logger.warning(\\\"Time step must be greater than 0. Series not started.\\\")\\n return\\n\\n ## Construct array of exposure times\\n t = mintime\\n time_array = []\\n while t <= maxtime:\\n time_array.append(t)\\n t += step\\n \\n ## Perform series\\n self.logger.info(\\\"Starting {0} series with mintime {1}, maxtime {2}, and step {3}.\\\".format(exptype, mintime, maxtime, step))\\n self.image_start.emit(len(time_array))\\n \\n try:\\n for i, time in enumerate(time_array):\\n self.logger.info(\\\"Starting {0}s {1} image.\\\".format(time, mode))\\n filename = exposure.im_acq(mode, filepath, time, seqnum, **kwargs)\\n self.logger.info(\\\"Exposure {0} finished successfully.\\\".format(filename))\\n self.image_taken.emit(i+1)\\n except subprocess.CalledProcessError:\\n self.logger.exception(\\\"Error in executable {0}_acq. Image not taken.\\\".format(mode))\\n except OSError:\\n self.logger.exception(\\\"Executable {0}_acq not found. Image not taken.\\\".format(mode))\\n except IOError:\\n self.logger.exception(\\\"File already exists. Image not taken.\\\")\\n else:\\n self.logger.info(\\\"Exposure series finished successfully.\\\")\\n subprocess.Popen(['ds9', '-mosaicimage', 'iraf', filename, '-zoom', 'to', 'fit', '-cmap', 'b'])\\n self.seqnum_inc.emit(seqnum)\",\n \"def problem2():\\n\\n data = loaddata(\\\"data/bayerdata.npy\\\")\\n r, g, b = separatechannels(data)\\n\\n img = assembleimage(r, g, b)\\n display_image(img)\\n\\n img_interpolated = interpolate(r, g, b)\\n display_image(img_interpolated)\",\n \"def upscale_main_side(output_img):\\n #Fixing pixel which y % 2 != 1\\n outputx, outputy = output_img.size\\n for oy in range(0, outputy-1, 2):\\n for ox in range(1, outputx, 2):\\n pixel1 = output_img.getpixel((ox-1, oy))\\n p1 = pixel1[0]\\n p2 = pixel1[1]\\n p3 = pixel1[2]\\n if ox == outputx-1 :\\n output_img.putpixel((ox, oy), (p1, p2, p3))\\n else:\\n pixel2 = output_img.getpixel((ox+1, oy))\\n P1 = pixel2[0]\\n P2 = pixel2[1]\\n P3 = pixel2[2]\\n output_img.putpixel((ox, oy), (int((p1+P1)/2), int((p2+P2)/2), int((p3+P3)/2)))\\n #print(f'pixel:{ox, oy} output:{output_img.getpixel((ox,oy))}')\\n #Fixing pixel which y % 2 == 1\\n for oy in range(1, outputy-1, 2):\\n for ox in range(0, outputx):\\n pixel1 = output_img.getpixel((ox, oy-1))\\n p1 = pixel1[0]\\n p2 = pixel1[1]\\n p3 = pixel1[2]\\n if oy == outputx:\\n output_img.putpixel((ox, oy), (p1, p2, p3))\\n break\\n else:\\n pixel2 = output_img.getpixel((ox, oy+1))\\n P1 = pixel2[0]\\n P2 = pixel2[1]\\n P3 = pixel2[2]\\n output_img.putpixel((ox, oy), (int((p1+P1)/2), int((p2+P2)/2), int((p3+P3)/2)))\\n #print(f'pixel:{ox, oy} output:{output_img.getpixel((ox,oy))}')\\n #Save image \\n result_img = output_path+'/output.'+working_img.format.lower()\\n output_img.save(result_img)\\n print('Upscale finished..!')\\n output_img.show()\",\n \"def run(self):\\n #calculate platescale of first input image\\n try:\\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.cd)\\n pscale = np.sqrt(np.abs(det))*3600.\\n except:\\n try:\\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.pc)\\n pscale = np.sqrt(np.abs(det))*3600.\\n except:\\n pscale = self.datain[0].header['PIXSCAL']\\n #filtering out images which are too far away from the others\\n #passing images added to a list of (image, WCS) tuples\\n '''\\n image_centers = []\\n for f in self.datain:\\n image_centers.append((f.header['CRVAL1'], f.header['CRVAL2']))\\n filtered_datain = []\\n dist_list = [[[0]*(len(image_centers)-1)]*len(image_centers)]\\n for i in range(len(image_centers)):\\n for j in range(len(image_centers)-1):\\n dist_list[i][j+1] = np.sqrt((image_)**2+()**2)\\n '''\\n #calculations necessary for updating wcs information\\n px = []\\n py = []\\n \\n #in order to avoid NaN interactions, creating weight map\\n weights=[]\\n for f in self.datain:\\n weights.append((np.where(np.isnan(f.image) == True, 0, 1)))\\n \\n for f in self.datain:\\n px.extend(wcs.WCS(f.header).calc_footprint()[:,0])\\n py.extend(wcs.WCS(f.header).calc_footprint()[:,1])\\n x0 = (max(px)+min(px))/2.\\n y0 = (max(py)+min(py))/2.\\n sx = (max(px)-min(px))*np.cos(y0/180*np.pi) # arcsec\\n sy = (max(py)-min(py)) # arcsec\\n size = (sx*3600+self.getarg('pad')*2, sy*3600+self.getarg('pad')*2)\\n xpix = size[0]//pscale\\n ypix = size[1]//pscale\\n cdelt = [pscale/3600.]*2\\n \\n #create self.dataout and give it a copy of an input's header\\n self.dataout = DataFits(config = self.config)\\n self.dataout.header = self.datain[0].header.copy()\\n \\n #update header wcs information\\n self.log.info('Creating new WCS header')\\n \\n self.dataout.header['CRPIX1'] = xpix/2\\n self.dataout.header['CRPIX2'] = ypix/2\\n self.dataout.header['CRVAL1'] = x0\\n self.dataout.header['CRVAL2'] = y0\\n self.dataout.header['CD1_1'] = -cdelt[0]\\n self.dataout.header['CD1_2'] = self.dataout.header['CD2_1'] = 0.\\n self.dataout.header['CD2_2'] = cdelt[1]\\n self.dataout.header['NAXIS1'] = int(xpix)\\n self.dataout.header['NAXIS2'] = int(ypix)\\n self.dataout.header['CTYPE1'] = 'RA---TAN-SIP'\\n self.dataout.header['CTYPE2'] = 'DEC--TAN-SIP'\\n self.dataout.header['RADESYS'] = 'ICRS'\\n self.dataout.header['EQUINOX'] = 2000\\n self.dataout.header['LATPOLE'] = self.datain[0].header['CRVAL2']\\n self.dataout.header['LONPOLE'] = 180\\n self.dataout.header['PIXASEC'] = pscale\\n \\n theta_rad = np.deg2rad(self.getarg('outangle'))\\n rot_matrix = np.array([[np.cos(theta_rad), -np.sin(theta_rad)], \\n [np.sin(theta_rad), np.cos(theta_rad)]])\\n rot_cd = np.dot(rot_matrix, np.array([[self.dataout.header['CD1_1'], 0.],[0., self.dataout.header['CD2_2']]]))\\n for i in [0,1]:\\n for j in [0,1]:\\n self.dataout.header['CD{0:d}_{1:d}'.format(i+1, j+1)] = rot_cd[i,j]\\n \\n #check drizzle arguments\\n if self.getarg('kernel') == 'smoothing':\\n kernel = 'lanczos3'\\n elif self.getarg('kernel') in ['square', 'point', 'gaussian', 'tophat']:\\n kernel = self.getarg('kernel')\\n else:\\n self.log.error('Kernel name not recognized, using default')\\n kernel = 'square'\\n if self.getarg('drizzleweights') == 'uniform':\\n driz_wt = ''\\n elif self.getarg('drizzleweights') in ['exptime', 'expsq']:\\n driz_wt = self.getarg('drizzleweights')\\n else:\\n self.log.error('Drizzle weighting not recognized, using default')\\n driz_wt = ''\\n \\n #create drizzle object and add input images\\n fullwcs = wcs.WCS(self.dataout.header)\\n self.log.info('Starting drizzle')\\n driz = drz.Drizzle(outwcs = fullwcs, pixfrac=self.getarg('pixfrac'), \\\\\\n kernel=kernel, fillval='10000', wt_scl=driz_wt)\\n for i,f in enumerate(self.datain):\\n self.log.info('Adding %s to drizzle stack' % f.filename)\\n driz.add_image(f.imgdata[0], wcs.WCS(f.header), inwht=weights[i])\\n \\n try:\\n fillval=float(self.getarg('fillval'))\\n except:\\n fillval=np.nan\\n self.log.error('Fillvalue not recognized or missing, using default')\\n \\n #creates output fits file from drizzle output\\n self.dataout.imageset(np.where(driz.outsci == 10000, fillval, driz.outsci))\\n self.dataout.imageset(driz.outwht,'OutWeight', self.dataout.header)\\n self.dataout.filename = self.datain[0].filename\\n\\n #add history\\n self.dataout.setheadval('HISTORY','Coadd: %d files combined with %s kernel, pixfrac %f at %f times resolution' \\\\\\n % (len(self.datain), kernel, self.getarg('pixfrac'), self.getarg('resolution')))\",\n \"def run(self, src, dest):\\n self.logger.debug('Start the blurring. src=\\\"%s\\\", dest=\\\"%s\\\"', src, dest)\\n create_frames(src, self.work['frames'])\\n data = self.analyze()\\n\\n for frame_no, frame in enumerate(self.work.files('frames')):\\n basename = os.path.basename(frame)\\n areas = []\\n for values in data:\\n for sector in values['sectors']:\\n if frame_no in range(sector[0]-self.offset, sector[1]+self.offset):\\n areas.append(values['area'])\\n break\\n if areas:\\n self.blur.blur_image(frame, areas, os.path.join(self.work['cleaned'], basename))\\n else:\\n copyfile(frame, os.path.join(self.work['cleaned'], basename))\\n save_frames(self.work['cleaned'], dest)\",\n \"def camera(self):\\n self.spectrum = self.spectrum\",\n \"def degrade_image(im, psf, downsample, shift_range):\\n\\n shift = np.random.randint(shift_range[0], shift_range[1], (1, 2))[0]\\n\\n # Add shift\\n im = fourier_shift(np.fft.fftn(im), shift)\\n im = np.fft.ifftn(im).real\\n\\n # Blur and downsample\\n im = convolve2d(im, psf)\\n im = downscale_local_mean(im, (downsample, downsample))\\n\\n return im\",\n \"def testSmallSrc(self):\\n fromWcs = afwGeom.makeSkyWcs(\\n crpix=lsst.geom.Point2D(0, 0),\\n crval=lsst.geom.SpherePoint(359, 0, lsst.geom.degrees),\\n cdMatrix=afwGeom.makeCdMatrix(scale=1.0e-8*lsst.geom.degrees),\\n )\\n fromExp = afwImage.ExposureF(afwImage.MaskedImageF(1, 1), fromWcs)\\n\\n toWcs = afwGeom.makeSkyWcs(\\n crpix=lsst.geom.Point2D(0, 0),\\n crval=lsst.geom.SpherePoint(358, 0, lsst.geom.degrees),\\n cdMatrix=afwGeom.makeCdMatrix(scale=1.1e-8*lsst.geom.degrees),\\n )\\n toExp = afwImage.ExposureF(afwImage.MaskedImageF(10, 10), toWcs)\\n\\n warpControl = afwMath.WarpingControl(\\\"lanczos3\\\")\\n # if a bug described in ticket #2441 is present, this will raise an\\n # exception:\\n numGoodPix = afwMath.warpExposure(toExp, fromExp, warpControl)\\n self.assertEqual(numGoodPix, 0)\\n self.assertTrue(np.all(np.isnan(toExp.image.array)))\\n self.assertTrue(np.all(np.isinf(toExp.variance.array)))\\n noDataBitMask = afwImage.Mask.getPlaneBitMask(\\\"NO_DATA\\\")\\n self.assertTrue(np.all(toExp.mask.array == noDataBitMask))\",\n \"def _image(self):\\n print(\\\"imaging\\\")\\n self.images.append(self.device_control.image())\\n yield\",\n \"def dither_img(img,num_pxl,bw_threshold=128):\\n\\n img_copy = np.copy(img)\\n img_copy[img_copy >= bw_threshold] = 255\\n img_copy[img_copy < bw_threshold] = 0\\n\\n h = img_copy.shape[0]\\n w = img_copy.shape[1]\\n\\n coordinates_0 = np.where(img_copy == 0)\\n coordinates_0 = tuple(zip(coordinates_0[0],coordinates_0[1]))\\n\\n coordinates_255 = np.where(img_copy == 255)\\n coordinates_255 = tuple(zip(coordinates_255[0],coordinates_255[1]))\\n\\n if num_pxl == 0:\\n return img_copy\\n\\n selected_coordinates_0 = random.sample(coordinates_0,min(num_pxl,min(len(coordinates_0),len(coordinates_255))))\\n selected_coordinates_255 = random.sample(coordinates_255,min(num_pxl,min(len(coordinates_0),len(coordinates_255))))\\n\\n selected_coordinates_0 = tuple(zip(*selected_coordinates_0))\\n selected_coordinates_255 = tuple(zip(*selected_coordinates_255))\\n\\n img_copy[selected_coordinates_0[0],selected_coordinates_0[1]] = 255\\n img_copy[selected_coordinates_255[0],selected_coordinates_255[1]] = 0\\n\\n return img_copy\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60497373","0.5954956","0.588953","0.58547735","0.5736053","0.5712237","0.56600004","0.5645142","0.56387717","0.5601205","0.56006426","0.5587478","0.5586383","0.5524406","0.55159074","0.5505001","0.5496937","0.5476632","0.54593825","0.5451838","0.54492474","0.5445616","0.5441269","0.54300416","0.5424851","0.54109013","0.5403154","0.5366931","0.53665185","0.53582674","0.5353076","0.5335535","0.53159547","0.53137016","0.5298819","0.52911645","0.5286996","0.52816683","0.5265932","0.52646303","0.524895","0.52478915","0.5239897","0.5229337","0.52285933","0.5226021","0.5219829","0.52040786","0.52027154","0.5186683","0.5183898","0.51808286","0.51775485","0.51773673","0.51721567","0.5171474","0.5170893","0.5163017","0.51604587","0.5159254","0.51551074","0.51451784","0.5144641","0.5138974","0.5132032","0.51265526","0.5120042","0.51152587","0.5106123","0.5103409","0.5101557","0.5097954","0.50907975","0.50907815","0.50862676","0.50842017","0.50824827","0.50785106","0.507828","0.5078229","0.5068843","0.5066857","0.5063911","0.5063681","0.50634927","0.5062824","0.5062676","0.5062385","0.5060525","0.5053911","0.50452757","0.50397307","0.50318706","0.5025127","0.502506","0.5024688","0.50231785","0.50212985","0.5015748","0.50137407","0.5010108"],"string":"[\n \"0.60497373\",\n \"0.5954956\",\n \"0.588953\",\n \"0.58547735\",\n \"0.5736053\",\n \"0.5712237\",\n \"0.56600004\",\n \"0.5645142\",\n \"0.56387717\",\n \"0.5601205\",\n \"0.56006426\",\n \"0.5587478\",\n \"0.5586383\",\n \"0.5524406\",\n \"0.55159074\",\n \"0.5505001\",\n \"0.5496937\",\n \"0.5476632\",\n \"0.54593825\",\n \"0.5451838\",\n \"0.54492474\",\n \"0.5445616\",\n \"0.5441269\",\n \"0.54300416\",\n \"0.5424851\",\n \"0.54109013\",\n \"0.5403154\",\n \"0.5366931\",\n \"0.53665185\",\n \"0.53582674\",\n \"0.5353076\",\n \"0.5335535\",\n \"0.53159547\",\n \"0.53137016\",\n \"0.5298819\",\n \"0.52911645\",\n \"0.5286996\",\n \"0.52816683\",\n \"0.5265932\",\n \"0.52646303\",\n \"0.524895\",\n \"0.52478915\",\n \"0.5239897\",\n \"0.5229337\",\n \"0.52285933\",\n \"0.5226021\",\n \"0.5219829\",\n \"0.52040786\",\n \"0.52027154\",\n \"0.5186683\",\n \"0.5183898\",\n \"0.51808286\",\n \"0.51775485\",\n \"0.51773673\",\n \"0.51721567\",\n \"0.5171474\",\n \"0.5170893\",\n \"0.5163017\",\n \"0.51604587\",\n \"0.5159254\",\n \"0.51551074\",\n \"0.51451784\",\n \"0.5144641\",\n \"0.5138974\",\n \"0.5132032\",\n \"0.51265526\",\n \"0.5120042\",\n \"0.51152587\",\n \"0.5106123\",\n \"0.5103409\",\n \"0.5101557\",\n \"0.5097954\",\n \"0.50907975\",\n \"0.50907815\",\n \"0.50862676\",\n \"0.50842017\",\n \"0.50824827\",\n \"0.50785106\",\n \"0.507828\",\n \"0.5078229\",\n \"0.5068843\",\n \"0.5066857\",\n \"0.5063911\",\n \"0.5063681\",\n \"0.50634927\",\n \"0.5062824\",\n \"0.5062676\",\n \"0.5062385\",\n \"0.5060525\",\n \"0.5053911\",\n \"0.50452757\",\n \"0.50397307\",\n \"0.50318706\",\n \"0.5025127\",\n \"0.502506\",\n \"0.5024688\",\n \"0.50231785\",\n \"0.50212985\",\n \"0.5015748\",\n \"0.50137407\",\n \"0.5010108\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":498,"cells":{"query":{"kind":"string","value":"Tests if expTime is set to 500s after a double length exposure."},"document":{"kind":"string","value":"def test_do_apogee_science_500s_after_1000s_cart7(self):\n\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLead1000sCart7'])\n self._update_cart(7, 'APOGEE')\n cmdState = self.actorState.doApogeeScience\n cmdState.reinitialize(self.cmd)\n self.assertEqual(cmdState.expTime, 1000)\n self.assertEqual(cmdState.keywords['expTime'], 1000)\n\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLeadCart7'])\n self._update_cart(7, 'APOGEE')\n cmdState = self.actorState.doApogeeScience\n cmdState.reinitialize(self.cmd)\n self.assertEqual(cmdState.expTime, 500)\n self.assertEqual(cmdState.keywords['expTime'], 500)"},"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 exp(self, exposure_time):\n print(f\"exp: {exposure_time}\")\n self.device_control.exposure = exposure_time\n yield","def exposuretime(self) -> ErrorValue:\n return ErrorValue(self._data['ExpTime'], self._data.setdefault('ExpTimeError',0.0))","def exptime(et=0.02):\n if et < 0.02:\n et = 0.02\n logger.error('Exposure time less than 0.02 seconds specified, using 0.02.')\n print camera.exptime(et)\n camera.status.update()","def setExposureTime(self, cmd, expTime):\n\n pass","def setExpTime(self, exptime):\n with self.lock:\n self.exptime = exptime","def time_to_fire(self):\n return(self.frequency < (time.time() - self.last_fired))","def _validate_exp(self):\n now = timegm(datetime.utcnow().utctimetuple())\n\n if self.authtype == 'jwt':\n if not hasattr(self, 'token'):\n # I pass here only one time, when I request a token\n self.token = None\n return True\n payload = jwt.decode(self.token, verify=False)\n try:\n exp = int(payload['exp'])\n except ValueError:\n raise jwt.DecodeError('Expiration Time claim (exp) must be an'\n ' integer.')\n\n if exp < now:\n # raise jwt.ExpiredSignatureError('Signature has expired')\n return False\n else:\n self.s.auth = JWTAuth(self.token)\n return True\n else:\n return True","def validate_exp(self, now, leeway):\n if 'exp' in self:\n exp = self['exp']\n if not _validate_numeric_time(exp):\n raise InvalidClaimError('exp')\n if exp < (now - leeway):\n raise ExpiredTokenError()","def is_time(self) -> bool:\n return self.times > 1","def set_exptime(self, exptime):\n exptime = u.Quantity(exptime, unit=u.s)\n if not np.isscalar(exptime):\n raise TypeError('Exposure time must be an integer, a float or an Astropy Unit object')\n if exptime.value <= 0:\n raise ValueError('Exposure time can not be zero or negative')\n self.exptime = exptime.value\n try:\n if self.cycle < self.exptime:\n warnings.warn('Exposure time ({:0.4f} seconds) higher than Cycle time ({:0.4f} seconds)'.\n format(self.exptime, self.cycle))\n except:\n pass","def check_time():\n times = get_times()\n time_difference = abs((times['local'] - times['target']).total_seconds())\n return time_difference < post_time_tol_seconds","def time_is_out(self):\n return self.get_simulation_time() > self.config.max_time","def verify_event_timing(self, event, item):\n return True","def __exp2_changed_callback(self, ndx):\n if self.recording_sequence:\n self.record_sequence()\n self.exp2_radio.setChecked(True)\n self.exp2_ifi_select.setCurrentIndex(0)\n self.camera.set_exposure(ndx, 0)\n self.rec_seq_button.setEnabled(False)\n et = np.int(np.round(self.camera.actual_exposure_time_ms))\n self.write_to_log('Exposure %d ms' % et)","def _badness(self, time):\n return (time - self.expected_time)**2","def check_lightcurve_time(light_curve, exposure_time, frame_time):\n logger = logging.getLogger('mirage.seed_image.tso.check_lightcurve_time')\n\n times = copy.deepcopy(light_curve[\"times\"].value)\n fluxes = copy.deepcopy(light_curve[\"fluxes\"].value)\n time_units = light_curve[\"times\"].unit\n flux_units = light_curve[\"fluxes\"].unit\n adjusted = False\n\n # Remove elements where time < 0.\n if np.min(times) < 0.:\n positive_times = times >= 0.\n times = times[positive_times]\n fluxes = fluxes[positive_times]\n adjusted = True\n\n # If the times begin at values significantly > 0,\n # then add entries to bring the start back to time = 0\n if np.min(times) > 0.:\n logger.info((\"Lightcurve time values do not start at zero. Prepending an entry with time=0 \"\n \"and flux = 1.\"))\n times = np.insert(times, 0, 0.)\n fluxes = np.insert(fluxes, 0, 1.)\n adjusted = True\n\n # If the ending time is less than the exposure's total\n # observation time, then add entries with flux=1\n if np.max(times) < exposure_time:\n logger.info((\"Lightcurve time values extend only to {} seconds. This is not long enough \"\n \"to cover the entire exposure time of {} seconds. Extending to cover the full \"\n \"exposure time with flux = 1.\".format(np.max(times), exposure_time)))\n times = np.append(times, exposure_time + 5 * frame_time)\n fluxes = np.append(fluxes, 1.)\n adjusted = True\n\n if adjusted:\n light_curve[\"times\"] = times * time_units\n light_curve[\"fluxes\"] = fluxes * flux_units\n\n return light_curve","def is_timeout(self) -> bool:\n return self.runtime.timeout <= 0.0","def after(self, time2):\r\n return self.to_seconds() > time2.to_seconds()","def __exp1_changed_callback(self, ndx):\n if self.recording_sequence:\n self.record_sequence()\n self.exp1_radio.setChecked(True)\n self.exp1_ifi_select.setCurrentIndex(0)\n self.camera.set_exposure(ndx, 0)\n self.rec_seq_button.setEnabled(False)\n et = np.int(np.round(self.camera.actual_exposure_time_ms))\n self.write_to_log('Exposure %d ms' % et)","def check_attack(self):\n now = time.time() * 1000\n if self.prev_time is None:\n return True\n else:\n next_time = self.prev_time + self.get_recharge\n if now >= next_time:\n return True\n else:\n return False","def is_dropped(upd_time, time_before):\n if (upd_time - time_before) / float(Config.BOUNDARY) >= 1.5:\n return True\n return False","def is_expired(self):\n if not self.is_signed:\n return True\n return int(self._token_claims.get(self.__class__.exp_claim, 0)) < int(\n time.time()\n )","def exceeded(self):\r\n return int(time.time()) - self.start_time >= self.length","def epsilon(self, length: int, time: int) -> float:\n return (self.beta ** (1.0 / (length / 2))) ** time","def timedout(self):\n\n return self.duration() > self.check.timeout","def evaluate(self, time) -> float:\n ...","def haveTime(self):\n if self.timeout is None:\n return True\n return time.time() <= self._stop","def test_EXPIRY_DURATION(self):\n self.assertIsInstance(constants.EXPIRY_DURATION, int,\n \"constants.EXPIRY_DURATION must be an integer.\")","def after(self, time2):\n return self.to_seconds() > time2.to_seconds()","def exposuretime(self):\n _, = self.exposuretimes\n return _","def is_expired(self):\n return int(time.time()) - self.time > self.interval","def _verify_timeout(self, doc):\n expires = doc['expires']\n if expires == 0:\n return False\n if expires >= self._time():\n return False\n return True","def spike_duration(self, spike_duration):\n\n self._spike_duration = spike_duration","def evaluateTime(self, *args):\n return _osgAnimation.Motion_evaluateTime(self, *args)","def overtime(self):\n if self._overtime != '':\n return True\n return False","def check_time(self, m, s):\r\n if m*60 + s > 5400:\r\n self.unit.s = 0\r\n self.unit.m = 90\r\n return\r\n if s < 0:\r\n s = 0\r\n if m < 0:\r\n m = 0\r\n self.unit.s = s\r\n self.unit.m = m","def test_expand_data_1500_correct_len():\n # TODO: should it round up to allow last snippet of time?\n exp = expand_data(log, 1500)\n assert len(exp) == (log['end'].iloc[-1] / 1500)","def test_timestep(self):\n class Mock(object):\n def __init__(self):\n self.t = 0.0\n self.dt = None\n\n def evolve(self1, t, dt):\n if self1.dt is not None:\n self.assertAlmostEqual(self1.dt, dt)\n else:\n self1.dt = dt\n\n self.assertAlmostEqual(self1.t, t)\n\n self1.t += self1.dt\n\n t_max = 10.0\n dt = 0.2\n\n G = Mock()\n simulation.Simulation(G, dt=dt).run(t_max)\n self.assertAlmostEqual(G.dt, dt)","def check_observation(self):\n last_obs_time = self.get_obs_time()\n last_obs_time_tz = last_obs_time.astimezone(\n ZoneInfo(self._config['db']['DisplayTimezone']))\n time_diff = datetime.now(tz=last_obs_time.tzinfo) - last_obs_time\n\n if int(time_diff.total_seconds() / 60) > \\\n int(self._config['observation']['Timeout']):\n if self._state['email_sent'] == 'False':\n if send_email(self._config['email'],\n 'env-logger: observation inactivity warning',\n 'No observations have been received in the env-logger '\n 'backend after {} (timeout {} minutes). Please check for '\n 'possible problems.'.format(last_obs_time_tz.isoformat(),\n self._config['observation']['Timeout'])):\n self._state['email_sent'] = 'True'\n else:\n self._state['email_sent'] = 'False'\n elif self._state['email_sent'] == 'True':\n send_email(self._config['email'],\n 'env-logger: observation received',\n 'An observation has been received at '\n f'{last_obs_time_tz.isoformat()}.')\n self._state['email_sent'] = 'False'","def excitationPulse(self, time, power):\n t = time * ns + self.step # Should center at one step before 0\n if self.step <= 200 * ps: # resolution warrants modelling the pulse\n width = 200.0 * ps # self.step\n\n if t < width * 10: # Only evaulate when the value is significant\n amp = power / (width * sqrt_2pi) # normalized amplitude\n value = amp * np.exp(-1.0 * (t) * (t) / (2 * width * width))\n value = value\n else:\n value = 0.0\n else: # impulsive limit, just dump all the excitons in at t=0\n # if time >= 0 - self.step/2 and time < 0 + self.step/2:\n if t > -0.5 * self.step and t <= 0.5 * self.step:\n value = power / self.step\n else:\n value = 0.0\n return (value*self.step)","def validity_by_time(self):\n conn = psycopg2.connect(self.conn)\n permissable_maximum_age_secs = 600 # 600s = 10mins\n query = \"SELECT time FROM steve_sense_sensor_logs ORDER BY time DESC LIMIT 1\"\n cur = conn.cursor()\n cur.execute(query)\n queryResult = cur.fetchall()\n age_seconds = (datetime.datetime.now(\n timezone.utc) - queryResult[0][0]).seconds\n cur.close()\n conn.close()\n if age_seconds > permissable_maximum_age_secs:\n print(\"Check Sensor, last sample is \"+str(age_seconds)+\" old\")\n return False\n else:\n return True","def _matchTime(self, time: float):\n return self._comparator['Time'] < time","def tune_exposure_time(camera, target, initial_exptime, min_exptime=0, max_exptime=None,\n max_steps=5, tolerance=0.1, cutout_size=256, bias=None, **kwargs):\n camera.logger.info(f\"Tuning exposure time for {camera}.\")\n\n images_dir = camera.get_config(\"directories.images\", None)\n if images_dir:\n images_dir = os.path.join(images_dir, \"temp\")\n os.makedirs(images_dir, exist_ok=True)\n\n # Parse quantities\n initial_exptime = get_quantity_value(initial_exptime, \"second\") * u.second\n\n if min_exptime is not None:\n min_exptime = get_quantity_value(min_exptime, \"second\") * u.second\n if max_exptime is not None:\n max_exptime = get_quantity_value(max_exptime, \"second\") * u.second\n\n try:\n bit_depth = camera.bit_depth.to_value(\"bit\")\n except NotImplementedError:\n bit_depth = 16\n\n saturated_counts = 2 ** bit_depth\n\n prefix = images_dir if images_dir is None else images_dir + \"/\"\n with tempfile.NamedTemporaryFile(suffix=\".fits\", prefix=prefix, delete=False) as tf:\n\n exptime = initial_exptime\n\n for step in range(max_steps):\n\n # Check if exposure time is within valid range\n if (exptime == max_exptime) or (exptime == min_exptime):\n break\n\n # Get an image\n cutout = camera.get_cutout(exptime, tf.name, cutout_size, keep_file=False, **kwargs)\n cutout = cutout.astype(\"float32\")\n if bias is not None:\n cutout -= bias\n\n # Measure average counts\n normalised_counts = np.median(cutout) / saturated_counts\n\n camera.logger.debug(f\"Normalised counts for {exptime} exposure on {camera}:\"\n f\" {normalised_counts}\")\n\n # Check if tolerance condition is met\n if tolerance:\n if abs(normalised_counts - target) < tolerance:\n break\n\n # Update exposure time\n exptime = exptime * target / normalised_counts\n if max_exptime is not None:\n exptime = min(exptime, max_exptime)\n if min_exptime is not None:\n exptime = max(exptime, min_exptime)\n\n camera.logger.info(f\"Tuned exposure time for {camera}: {exptime}\")\n\n return exptime","def _check_maxexp(np_type, maxexp):\n dt = np.dtype(np_type)\n np_type = dt.type\n two = np_type(2).reshape((1,)) # to avoid upcasting\n return (np.isfinite(two ** (maxexp - 1)) and\n not np.isfinite(two ** maxexp))","def is_expired(self):\n\n if self._lifetime is not None and self._lifetime > 0:\n # 300 seconds waite is the tolerance !\n # The unit of lifetime is millisecond\n if (time.time() - self._create_date) * 1000 > self._lifetime + 300000:\n return True\n\n return False","def isCalibrationExpired(self):\n return (getI1ProTimeUntilCalibrationExpire() < 200)","def find_exposure_time(cam,targetIntensity=100,margin=5):\n from numpy import mean\n\n if targetIntensity < 0 or targetIntensity > 255:\n print(\"Invalid target intensity\")\n return 1\n minExposure = 0.01 # Smallest value in ms\n maxExposure = 80\n counter = 0\n\n # Calculate exposures at the different end\n Image = cam.grab_image(timeout='1s', copy=True,\n exposure_time=number_to_millisecond(minExposure))\n minIntensity = mean(Image)\n\n Image = cam.grab_image(timeout='1s', copy=True,\n exposure_time=number_to_millisecond(maxExposure))\n maxIntensity = mean(Image)\n\n midIntensity = 1\n while midIntensity < (targetIntensity - margin) or\\\n midIntensity > (targetIntensity+margin) and counter < 20:\n # Set exposure, take a picture and check how good it was\n counter = counter + 1\n\n midExposure = (maxExposure + minExposure) / 2\n Image = cam.grab_image(timeout='1s',\n copy=True,\n exposure_time=number_to_millisecond(midExposure))\n midIntensity = mean(Image)\n\n if midIntensity > targetIntensity: # Exposure time too short\n maxExposure = midExposure\n # maxIntensity = midIntensity\n else: # Exposure time too long\n minExposure = midExposure\n # minIntensity = midIntensity\n if counter == 100:\n print(\"WARNING: Find exposure function ran max number of iterations!\\\n No really suitable exposure setting found\")\n # Update the exposure time of the camera and return the target exposure\n cam.set_defaults(exposure_time=number_to_millisecond(midExposure))\n return midExposure#number_to_millisecond(midExposure)","def GAME_TIME_ADVANCE(dt):","def checkGracePeriodDuration(self):\n if (not self.isInGraceInvulnerability):\n return\n if (time.time()-self.gracePeriodStartTime > shipDamagedInvulerabilityGracePeriodLength):\n #if the grace period is over...\n self.disableGracePeriod()","def valid(t):\n return float(t) > time.time()","def test_upload_time(self):\n time_val = 1345427105 # just a realistic time val, ~ 8/19/12 6:45pm\n self.assertIsNone(self.model.last_uploaded(),\n \"Did not return None even though upload entry doesn't exist\")\n self.model.set_last_uploaded(time_val)\n self.assertEquals(time_val, self.model.last_uploaded(),\n \"Created initial val, but appears incorect\")\n self.model.set_last_uploaded(time_val + 10)\n self.assertEquals(time_val + 10, self.model.last_uploaded(),\n \"Updated value, but appears incorrect\")","def important_event(time: int) -> bool:\n last_event = get_events(True)[0]\n try:\n time_event = int(last_event.split('\\n')[0].strip(\"'\"))\n except ValueError:\n time_event = int(last_event.split('\\n')[-1].strip(\"'\"))\n if time - time_event < 60:\n return 'gol' in last_event or 'cartão' in last_event\n return False","def __luredWakeupTime(self, suitId):\n return self.__suitIsLured(suitId) and \\\n self.currentlyLuredSuits[suitId][0] > 0 and \\\n random.randint(0, 99) < \\\n self.currentlyLuredSuits[suitId][2]","def is_exploring(self, step):\n return np.random.rand() < self._epsilon(step)","def T_elapsed(T_amount: BlockHeight) -> bool:\n T_now = getCurrentBlockHeight()\n return T_now - T_init >= T_amount","def _check_pulse(self):\n timedelta = time.time() - self.heartbeat\n update_delay = float(1/self.qbpm.frequency)\n time_to_update = False\n if timedelta > update_delay:\n time_to_update = True\n self.heartbeat = time.time()\n return time_to_update","def tick(self):\n if time.time() - self.t > self.speed:\n self.t = time.time()\n return True\n else:\n return False","def _is_noise(self, t):\n\t\tfor ts in self.noise_itv:\n\t\t\tif len(ts) == 2:\n\t\t\t\ttime1 = ts[0]\n\t\t\t\ttime2 = ts[1]\n\t\t\t\tif time1 <= t and t <= time2:\n\t\t\t\t\treturn True\n\t\t\telse:\n\t\t\t\tend_time = ts[0]\n\t\t\t\tif t >= end_time:\n\t\t\t\t\treturn True\n\t\treturn False","def extended(self):\n if self.expires_at:\n return self.expires_at - self.issued_at > timedelta(days=30)\n return False","def check_convergency(self):\n if self.vars['ema_trace'][self.vars['step']] <= self.settings[\"emaSpeedTol\"]:\n return True\n else:\n return False","def set_exposure(self, exposure):\n self.logger.info(f'Setting exposure to {exposure}')\n self._driver.ExposureTime.SetValue(exposure)","def expired(self):\n return rospy.get_rostime() - self.start_time > self.duration","def timestep(self):\n self.survive()\n self.move()\n self.set_survival_probability(self.vital_var)\n self.reproduce()\n # self.save_frame()\n if self.time % self.save_state_frequency == 0:\n self.save_state(self.state_file.format(self.time))\n if self.time % self.save_stats_frequency == 0:\n self.write_stats()\n # self.connected_component()\n self.time += 1\n\n if self.pop_size > 0:\n return True\n else:\n return False","def mood_duration_millis():\n return max(200, int(state.normal(750, 500)))","def is_chunk_timeout(self, chunk_timeout): \n return time() - self._chunk_timeout_time > chunk_timeout","def delta_time(self):\n delta_time = time.time() - self.time\n if delta_time >= 1.0 / self.target_fps:\n self.time = time.time()\n # end if\n return delta_time","def test_duration_property(self):\n recording_dt = 0.1\n recording_shape = {\n 'no_timesteps': 1000,\n 'no_sweeps': 10,\n 'no_channels': 4,\n }\n expected_duration = recording_shape['no_timesteps'] * recording_dt\n test_rec = rt.Recording(\n np.zeros(\n [\n recording_shape['no_channels'],\n recording_shape['no_timesteps'],\n recording_shape['no_sweeps'],\n ]\n ),\n dt=recording_dt,\n )\n npt.assert_almost_equal(\n test_rec.duration,\n expected_duration,\n err_msg='Expected {} for `duration` property; got {} instead.'.format(\n expected_duration, test_rec.duration\n ),\n )","def expired(self) -> bool:\n if not self.use_wts:\n return False\n\n return datetime.now() > self.expire","def discrete_time(self):\n return bool(self._ll_tree_sequence.get_discrete_time())","def checkAtFinalTime():\n global final_time\n if final_time <= current_second:\n return True\n return False","def delete_expired(self):\n check_time = datetime.now()\n if self.can_expire and self.duration:\n exp_times = deepcopy(self.exp_times)\n for key in exp_times:\n if exp_times[key] < check_time:\n self.delete(key)","def is_limited(self) -> bool:\n return self.__times > ActionState.UNLIMITED","def is_delayed(self) -> bool:\n if self.periodic and self.is_attached():\n return self.runtime.cost > self.runtime.tasklet.tick\n\n return False","def __sleep(self):\n if self.sleep_duration > 0:\n gevent.sleep(self.sleep_duration)\n else:\n self.__warn(\n f\"The average tick took longer than the set tick duration of {self.__tick_duration}. \"\n f\"Program is to heavy to run real time\")","def exp(self) -> t.Optional[int]:\n return self.claims.get(\"exp\")","def rate_limiting(cls):\n this_click_time = time.time()\n time_to_last_click = None\n if cls.last_click_time:\n time_to_last_click = this_click_time - cls.last_click_time\n cls.last_click_time = this_click_time\n return time_to_last_click and time_to_last_click < 0.7","def test_time_supp_length_matches_no_timesteps(self):\n for no_timesteps in [5, 578, 993, 300072]:\n for dt in [0.1, 0.5, 3.0]:\n test_rec = rt.Recording(np.empty([6, no_timesteps, 1]), dt=dt)\n self.assertEqual(\n len(test_rec.time_supp),\n no_timesteps,\n 'Expected length of time_supp {} to match no_timesteps of '\n 'input {}.'.format(len(test_rec.time_supp), no_timesteps),\n )","def timed_out(self):\n return self.enabled and (\n self.elapsed >= self.timeout\n or math.isclose(self.elapsed, self.timeout)\n )","def check_timer(self, wanted_time):\n if time.time() - self.start_time >= wanted_time:\n return True\n return False","def setHoldTime(self, channel, time, unitCode=0):\n # Ensure compliance with level boundary conditions\n\n resp = self.XAPCommand('GHOLD', channel, time, unitCode=unitCode)\n return float(resp)","def ComputeTimeReward(self, currentTime, expectedTime):\r\n return (expectedTime - currentTime) * 1 if currentTime < expectedTime else (expectedTime - currentTime) * 1","def __checkTimer(self):\n if self.__endTime is None:\n raise AssertionError('The end time had not been set.')\n if time.time() > self.__endTime:\n self._logError('Maximum Run Time Reached !!')\n raise _MaxRunTimeReachedError('')","def _timeout_request(start_time, request_timeout):\n return int(round(time() * 1000)) - start_time >= request_timeout","def test_time(self):\n M = simulation.StateMonitor(self.G, 'v')\n sim = simulation.Simulation(self.G, M, dt=self.dt)\n sim.run(self.t_max)\n self.assertTrue(np.allclose(M.t, np.arange(0, self.t_max, self.dt)))","def isTimeRemaining(self):\n if self.run_type.startswith('timed'):\n time_since_start = (time.time() - self.start_times['run'])\n remaining_time = self.max_time * 60 - time_since_start\n if remaining_time < 0:\n return False\n else:\n return True","def calculateDelayedEventTime(self, raw_time):\n return self.event_time","def is_over(self, time):\n over = (not self.enable_loop()) and (time >= self.get_duration())\n return over","def is_equidistant(self) -> bool:\n if len(self.time) < 3:\n return True\n return len(self.time.to_series().diff().dropna().unique()) == 1","def explores(self, explores):\n\n self._explores = explores","def fine_tune(self, duration = 2):\n\n with sr.Microphone() as source:\n self.recorder.adjust_for_ambient_noise(source, duration=duration)\n return self.recorder.energy_threshold","def test_do_apogee_science_1000s_after_500s_cart7(self):\n\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLeadCart7'])\n self._update_cart(7, 'APOGEE')\n cmdState = self.actorState.doApogeeScience\n cmdState.reinitialize(self.cmd)\n self.assertEqual(cmdState.expTime, 500)\n self.assertEqual(cmdState.keywords['expTime'], 500)\n\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLead1000sCart7'])\n self._update_cart(7, 'APOGEE')\n cmdState = self.actorState.doApogeeScience\n cmdState.reinitialize(self.cmd)\n self.assertEqual(cmdState.expTime, 1000)\n self.assertEqual(cmdState.keywords['expTime'], 1000)","def __check_total_duration(self, duration: int) -> bool:\n available_duration = N_EIGHTHS_PER_MEASURE * (self.n_measures - 1)\n return self.current_time_in_eighths + duration <= available_duration","def Exposure(self, time):\r\n IS_EXPOSURE_CMD_SET_EXPOSURE = 12 #there is a whole list to implement\r\n TIME = DOUBLE(time)\r\n nSizeOfParam = 8\r\n CALL('Exposure', self, \r\n UINT(IS_EXPOSURE_CMD_SET_EXPOSURE), \r\n byref(TIME), \r\n UINT(nSizeOfParam))","def test_custom_time(self):\n interval = 0.5\n M = simulation.StateMonitor(self.G, 'v', interval=interval)\n sim = simulation.Simulation(self.G, M, dt=self.dt)\n sim.run(self.t_max)\n self.assertTrue(np.allclose(M.t, np.arange(0, self.t_max, interval)))","def simulate_until(self, stop_time, dt=None):\n while self.t < stop_time:\n self.step(dt)","def isExpired(self):\n return True/False","def get_timings(self):\n exp=lib.is_Exposure_d8(self.hcam,7)*1E-3\n frame_rate=lib.is_SetFrameRate(self.hcam,0x8000)\n return self.AcqTimes(exp,1./frame_rate)","def test_exp():\n x = np.linspace(-3,3,13)\n\n default_use_numexpr = accel_math._USE_NUMEXPR\n\n accel_math._USE_NUMEXPR = True\n r1 = accel_math._exp(x)\n\n accel_math._USE_NUMEXPR = False\n r2 = accel_math._exp(x)\n\n np.testing.assert_almost_equal(r1,r2)\n\n accel_math._USE_NUMEXPR = default_use_numexpr","def guard_time(self):\n return uniform(0, self.max_guard_time)","def _about_to_expire(self, secret: Secret) -> bool:\n return secret.is_expired(datetime.now(UTC) + self.expiry_margin)"],"string":"[\n \"def exp(self, exposure_time):\\n print(f\\\"exp: {exposure_time}\\\")\\n self.device_control.exposure = exposure_time\\n yield\",\n \"def exposuretime(self) -> ErrorValue:\\n return ErrorValue(self._data['ExpTime'], self._data.setdefault('ExpTimeError',0.0))\",\n \"def exptime(et=0.02):\\n if et < 0.02:\\n et = 0.02\\n logger.error('Exposure time less than 0.02 seconds specified, using 0.02.')\\n print camera.exptime(et)\\n camera.status.update()\",\n \"def setExposureTime(self, cmd, expTime):\\n\\n pass\",\n \"def setExpTime(self, exptime):\\n with self.lock:\\n self.exptime = exptime\",\n \"def time_to_fire(self):\\n return(self.frequency < (time.time() - self.last_fired))\",\n \"def _validate_exp(self):\\n now = timegm(datetime.utcnow().utctimetuple())\\n\\n if self.authtype == 'jwt':\\n if not hasattr(self, 'token'):\\n # I pass here only one time, when I request a token\\n self.token = None\\n return True\\n payload = jwt.decode(self.token, verify=False)\\n try:\\n exp = int(payload['exp'])\\n except ValueError:\\n raise jwt.DecodeError('Expiration Time claim (exp) must be an'\\n ' integer.')\\n\\n if exp < now:\\n # raise jwt.ExpiredSignatureError('Signature has expired')\\n return False\\n else:\\n self.s.auth = JWTAuth(self.token)\\n return True\\n else:\\n return True\",\n \"def validate_exp(self, now, leeway):\\n if 'exp' in self:\\n exp = self['exp']\\n if not _validate_numeric_time(exp):\\n raise InvalidClaimError('exp')\\n if exp < (now - leeway):\\n raise ExpiredTokenError()\",\n \"def is_time(self) -> bool:\\n return self.times > 1\",\n \"def set_exptime(self, exptime):\\n exptime = u.Quantity(exptime, unit=u.s)\\n if not np.isscalar(exptime):\\n raise TypeError('Exposure time must be an integer, a float or an Astropy Unit object')\\n if exptime.value <= 0:\\n raise ValueError('Exposure time can not be zero or negative')\\n self.exptime = exptime.value\\n try:\\n if self.cycle < self.exptime:\\n warnings.warn('Exposure time ({:0.4f} seconds) higher than Cycle time ({:0.4f} seconds)'.\\n format(self.exptime, self.cycle))\\n except:\\n pass\",\n \"def check_time():\\n times = get_times()\\n time_difference = abs((times['local'] - times['target']).total_seconds())\\n return time_difference < post_time_tol_seconds\",\n \"def time_is_out(self):\\n return self.get_simulation_time() > self.config.max_time\",\n \"def verify_event_timing(self, event, item):\\n return True\",\n \"def __exp2_changed_callback(self, ndx):\\n if self.recording_sequence:\\n self.record_sequence()\\n self.exp2_radio.setChecked(True)\\n self.exp2_ifi_select.setCurrentIndex(0)\\n self.camera.set_exposure(ndx, 0)\\n self.rec_seq_button.setEnabled(False)\\n et = np.int(np.round(self.camera.actual_exposure_time_ms))\\n self.write_to_log('Exposure %d ms' % et)\",\n \"def _badness(self, time):\\n return (time - self.expected_time)**2\",\n \"def check_lightcurve_time(light_curve, exposure_time, frame_time):\\n logger = logging.getLogger('mirage.seed_image.tso.check_lightcurve_time')\\n\\n times = copy.deepcopy(light_curve[\\\"times\\\"].value)\\n fluxes = copy.deepcopy(light_curve[\\\"fluxes\\\"].value)\\n time_units = light_curve[\\\"times\\\"].unit\\n flux_units = light_curve[\\\"fluxes\\\"].unit\\n adjusted = False\\n\\n # Remove elements where time < 0.\\n if np.min(times) < 0.:\\n positive_times = times >= 0.\\n times = times[positive_times]\\n fluxes = fluxes[positive_times]\\n adjusted = True\\n\\n # If the times begin at values significantly > 0,\\n # then add entries to bring the start back to time = 0\\n if np.min(times) > 0.:\\n logger.info((\\\"Lightcurve time values do not start at zero. Prepending an entry with time=0 \\\"\\n \\\"and flux = 1.\\\"))\\n times = np.insert(times, 0, 0.)\\n fluxes = np.insert(fluxes, 0, 1.)\\n adjusted = True\\n\\n # If the ending time is less than the exposure's total\\n # observation time, then add entries with flux=1\\n if np.max(times) < exposure_time:\\n logger.info((\\\"Lightcurve time values extend only to {} seconds. This is not long enough \\\"\\n \\\"to cover the entire exposure time of {} seconds. Extending to cover the full \\\"\\n \\\"exposure time with flux = 1.\\\".format(np.max(times), exposure_time)))\\n times = np.append(times, exposure_time + 5 * frame_time)\\n fluxes = np.append(fluxes, 1.)\\n adjusted = True\\n\\n if adjusted:\\n light_curve[\\\"times\\\"] = times * time_units\\n light_curve[\\\"fluxes\\\"] = fluxes * flux_units\\n\\n return light_curve\",\n \"def is_timeout(self) -> bool:\\n return self.runtime.timeout <= 0.0\",\n \"def after(self, time2):\\r\\n return self.to_seconds() > time2.to_seconds()\",\n \"def __exp1_changed_callback(self, ndx):\\n if self.recording_sequence:\\n self.record_sequence()\\n self.exp1_radio.setChecked(True)\\n self.exp1_ifi_select.setCurrentIndex(0)\\n self.camera.set_exposure(ndx, 0)\\n self.rec_seq_button.setEnabled(False)\\n et = np.int(np.round(self.camera.actual_exposure_time_ms))\\n self.write_to_log('Exposure %d ms' % et)\",\n \"def check_attack(self):\\n now = time.time() * 1000\\n if self.prev_time is None:\\n return True\\n else:\\n next_time = self.prev_time + self.get_recharge\\n if now >= next_time:\\n return True\\n else:\\n return False\",\n \"def is_dropped(upd_time, time_before):\\n if (upd_time - time_before) / float(Config.BOUNDARY) >= 1.5:\\n return True\\n return False\",\n \"def is_expired(self):\\n if not self.is_signed:\\n return True\\n return int(self._token_claims.get(self.__class__.exp_claim, 0)) < int(\\n time.time()\\n )\",\n \"def exceeded(self):\\r\\n return int(time.time()) - self.start_time >= self.length\",\n \"def epsilon(self, length: int, time: int) -> float:\\n return (self.beta ** (1.0 / (length / 2))) ** time\",\n \"def timedout(self):\\n\\n return self.duration() > self.check.timeout\",\n \"def evaluate(self, time) -> float:\\n ...\",\n \"def haveTime(self):\\n if self.timeout is None:\\n return True\\n return time.time() <= self._stop\",\n \"def test_EXPIRY_DURATION(self):\\n self.assertIsInstance(constants.EXPIRY_DURATION, int,\\n \\\"constants.EXPIRY_DURATION must be an integer.\\\")\",\n \"def after(self, time2):\\n return self.to_seconds() > time2.to_seconds()\",\n \"def exposuretime(self):\\n _, = self.exposuretimes\\n return _\",\n \"def is_expired(self):\\n return int(time.time()) - self.time > self.interval\",\n \"def _verify_timeout(self, doc):\\n expires = doc['expires']\\n if expires == 0:\\n return False\\n if expires >= self._time():\\n return False\\n return True\",\n \"def spike_duration(self, spike_duration):\\n\\n self._spike_duration = spike_duration\",\n \"def evaluateTime(self, *args):\\n return _osgAnimation.Motion_evaluateTime(self, *args)\",\n \"def overtime(self):\\n if self._overtime != '':\\n return True\\n return False\",\n \"def check_time(self, m, s):\\r\\n if m*60 + s > 5400:\\r\\n self.unit.s = 0\\r\\n self.unit.m = 90\\r\\n return\\r\\n if s < 0:\\r\\n s = 0\\r\\n if m < 0:\\r\\n m = 0\\r\\n self.unit.s = s\\r\\n self.unit.m = m\",\n \"def test_expand_data_1500_correct_len():\\n # TODO: should it round up to allow last snippet of time?\\n exp = expand_data(log, 1500)\\n assert len(exp) == (log['end'].iloc[-1] / 1500)\",\n \"def test_timestep(self):\\n class Mock(object):\\n def __init__(self):\\n self.t = 0.0\\n self.dt = None\\n\\n def evolve(self1, t, dt):\\n if self1.dt is not None:\\n self.assertAlmostEqual(self1.dt, dt)\\n else:\\n self1.dt = dt\\n\\n self.assertAlmostEqual(self1.t, t)\\n\\n self1.t += self1.dt\\n\\n t_max = 10.0\\n dt = 0.2\\n\\n G = Mock()\\n simulation.Simulation(G, dt=dt).run(t_max)\\n self.assertAlmostEqual(G.dt, dt)\",\n \"def check_observation(self):\\n last_obs_time = self.get_obs_time()\\n last_obs_time_tz = last_obs_time.astimezone(\\n ZoneInfo(self._config['db']['DisplayTimezone']))\\n time_diff = datetime.now(tz=last_obs_time.tzinfo) - last_obs_time\\n\\n if int(time_diff.total_seconds() / 60) > \\\\\\n int(self._config['observation']['Timeout']):\\n if self._state['email_sent'] == 'False':\\n if send_email(self._config['email'],\\n 'env-logger: observation inactivity warning',\\n 'No observations have been received in the env-logger '\\n 'backend after {} (timeout {} minutes). Please check for '\\n 'possible problems.'.format(last_obs_time_tz.isoformat(),\\n self._config['observation']['Timeout'])):\\n self._state['email_sent'] = 'True'\\n else:\\n self._state['email_sent'] = 'False'\\n elif self._state['email_sent'] == 'True':\\n send_email(self._config['email'],\\n 'env-logger: observation received',\\n 'An observation has been received at '\\n f'{last_obs_time_tz.isoformat()}.')\\n self._state['email_sent'] = 'False'\",\n \"def excitationPulse(self, time, power):\\n t = time * ns + self.step # Should center at one step before 0\\n if self.step <= 200 * ps: # resolution warrants modelling the pulse\\n width = 200.0 * ps # self.step\\n\\n if t < width * 10: # Only evaulate when the value is significant\\n amp = power / (width * sqrt_2pi) # normalized amplitude\\n value = amp * np.exp(-1.0 * (t) * (t) / (2 * width * width))\\n value = value\\n else:\\n value = 0.0\\n else: # impulsive limit, just dump all the excitons in at t=0\\n # if time >= 0 - self.step/2 and time < 0 + self.step/2:\\n if t > -0.5 * self.step and t <= 0.5 * self.step:\\n value = power / self.step\\n else:\\n value = 0.0\\n return (value*self.step)\",\n \"def validity_by_time(self):\\n conn = psycopg2.connect(self.conn)\\n permissable_maximum_age_secs = 600 # 600s = 10mins\\n query = \\\"SELECT time FROM steve_sense_sensor_logs ORDER BY time DESC LIMIT 1\\\"\\n cur = conn.cursor()\\n cur.execute(query)\\n queryResult = cur.fetchall()\\n age_seconds = (datetime.datetime.now(\\n timezone.utc) - queryResult[0][0]).seconds\\n cur.close()\\n conn.close()\\n if age_seconds > permissable_maximum_age_secs:\\n print(\\\"Check Sensor, last sample is \\\"+str(age_seconds)+\\\" old\\\")\\n return False\\n else:\\n return True\",\n \"def _matchTime(self, time: float):\\n return self._comparator['Time'] < time\",\n \"def tune_exposure_time(camera, target, initial_exptime, min_exptime=0, max_exptime=None,\\n max_steps=5, tolerance=0.1, cutout_size=256, bias=None, **kwargs):\\n camera.logger.info(f\\\"Tuning exposure time for {camera}.\\\")\\n\\n images_dir = camera.get_config(\\\"directories.images\\\", None)\\n if images_dir:\\n images_dir = os.path.join(images_dir, \\\"temp\\\")\\n os.makedirs(images_dir, exist_ok=True)\\n\\n # Parse quantities\\n initial_exptime = get_quantity_value(initial_exptime, \\\"second\\\") * u.second\\n\\n if min_exptime is not None:\\n min_exptime = get_quantity_value(min_exptime, \\\"second\\\") * u.second\\n if max_exptime is not None:\\n max_exptime = get_quantity_value(max_exptime, \\\"second\\\") * u.second\\n\\n try:\\n bit_depth = camera.bit_depth.to_value(\\\"bit\\\")\\n except NotImplementedError:\\n bit_depth = 16\\n\\n saturated_counts = 2 ** bit_depth\\n\\n prefix = images_dir if images_dir is None else images_dir + \\\"/\\\"\\n with tempfile.NamedTemporaryFile(suffix=\\\".fits\\\", prefix=prefix, delete=False) as tf:\\n\\n exptime = initial_exptime\\n\\n for step in range(max_steps):\\n\\n # Check if exposure time is within valid range\\n if (exptime == max_exptime) or (exptime == min_exptime):\\n break\\n\\n # Get an image\\n cutout = camera.get_cutout(exptime, tf.name, cutout_size, keep_file=False, **kwargs)\\n cutout = cutout.astype(\\\"float32\\\")\\n if bias is not None:\\n cutout -= bias\\n\\n # Measure average counts\\n normalised_counts = np.median(cutout) / saturated_counts\\n\\n camera.logger.debug(f\\\"Normalised counts for {exptime} exposure on {camera}:\\\"\\n f\\\" {normalised_counts}\\\")\\n\\n # Check if tolerance condition is met\\n if tolerance:\\n if abs(normalised_counts - target) < tolerance:\\n break\\n\\n # Update exposure time\\n exptime = exptime * target / normalised_counts\\n if max_exptime is not None:\\n exptime = min(exptime, max_exptime)\\n if min_exptime is not None:\\n exptime = max(exptime, min_exptime)\\n\\n camera.logger.info(f\\\"Tuned exposure time for {camera}: {exptime}\\\")\\n\\n return exptime\",\n \"def _check_maxexp(np_type, maxexp):\\n dt = np.dtype(np_type)\\n np_type = dt.type\\n two = np_type(2).reshape((1,)) # to avoid upcasting\\n return (np.isfinite(two ** (maxexp - 1)) and\\n not np.isfinite(two ** maxexp))\",\n \"def is_expired(self):\\n\\n if self._lifetime is not None and self._lifetime > 0:\\n # 300 seconds waite is the tolerance !\\n # The unit of lifetime is millisecond\\n if (time.time() - self._create_date) * 1000 > self._lifetime + 300000:\\n return True\\n\\n return False\",\n \"def isCalibrationExpired(self):\\n return (getI1ProTimeUntilCalibrationExpire() < 200)\",\n \"def find_exposure_time(cam,targetIntensity=100,margin=5):\\n from numpy import mean\\n\\n if targetIntensity < 0 or targetIntensity > 255:\\n print(\\\"Invalid target intensity\\\")\\n return 1\\n minExposure = 0.01 # Smallest value in ms\\n maxExposure = 80\\n counter = 0\\n\\n # Calculate exposures at the different end\\n Image = cam.grab_image(timeout='1s', copy=True,\\n exposure_time=number_to_millisecond(minExposure))\\n minIntensity = mean(Image)\\n\\n Image = cam.grab_image(timeout='1s', copy=True,\\n exposure_time=number_to_millisecond(maxExposure))\\n maxIntensity = mean(Image)\\n\\n midIntensity = 1\\n while midIntensity < (targetIntensity - margin) or\\\\\\n midIntensity > (targetIntensity+margin) and counter < 20:\\n # Set exposure, take a picture and check how good it was\\n counter = counter + 1\\n\\n midExposure = (maxExposure + minExposure) / 2\\n Image = cam.grab_image(timeout='1s',\\n copy=True,\\n exposure_time=number_to_millisecond(midExposure))\\n midIntensity = mean(Image)\\n\\n if midIntensity > targetIntensity: # Exposure time too short\\n maxExposure = midExposure\\n # maxIntensity = midIntensity\\n else: # Exposure time too long\\n minExposure = midExposure\\n # minIntensity = midIntensity\\n if counter == 100:\\n print(\\\"WARNING: Find exposure function ran max number of iterations!\\\\\\n No really suitable exposure setting found\\\")\\n # Update the exposure time of the camera and return the target exposure\\n cam.set_defaults(exposure_time=number_to_millisecond(midExposure))\\n return midExposure#number_to_millisecond(midExposure)\",\n \"def GAME_TIME_ADVANCE(dt):\",\n \"def checkGracePeriodDuration(self):\\n if (not self.isInGraceInvulnerability):\\n return\\n if (time.time()-self.gracePeriodStartTime > shipDamagedInvulerabilityGracePeriodLength):\\n #if the grace period is over...\\n self.disableGracePeriod()\",\n \"def valid(t):\\n return float(t) > time.time()\",\n \"def test_upload_time(self):\\n time_val = 1345427105 # just a realistic time val, ~ 8/19/12 6:45pm\\n self.assertIsNone(self.model.last_uploaded(),\\n \\\"Did not return None even though upload entry doesn't exist\\\")\\n self.model.set_last_uploaded(time_val)\\n self.assertEquals(time_val, self.model.last_uploaded(),\\n \\\"Created initial val, but appears incorect\\\")\\n self.model.set_last_uploaded(time_val + 10)\\n self.assertEquals(time_val + 10, self.model.last_uploaded(),\\n \\\"Updated value, but appears incorrect\\\")\",\n \"def important_event(time: int) -> bool:\\n last_event = get_events(True)[0]\\n try:\\n time_event = int(last_event.split('\\\\n')[0].strip(\\\"'\\\"))\\n except ValueError:\\n time_event = int(last_event.split('\\\\n')[-1].strip(\\\"'\\\"))\\n if time - time_event < 60:\\n return 'gol' in last_event or 'cartão' in last_event\\n return False\",\n \"def __luredWakeupTime(self, suitId):\\n return self.__suitIsLured(suitId) and \\\\\\n self.currentlyLuredSuits[suitId][0] > 0 and \\\\\\n random.randint(0, 99) < \\\\\\n self.currentlyLuredSuits[suitId][2]\",\n \"def is_exploring(self, step):\\n return np.random.rand() < self._epsilon(step)\",\n \"def T_elapsed(T_amount: BlockHeight) -> bool:\\n T_now = getCurrentBlockHeight()\\n return T_now - T_init >= T_amount\",\n \"def _check_pulse(self):\\n timedelta = time.time() - self.heartbeat\\n update_delay = float(1/self.qbpm.frequency)\\n time_to_update = False\\n if timedelta > update_delay:\\n time_to_update = True\\n self.heartbeat = time.time()\\n return time_to_update\",\n \"def tick(self):\\n if time.time() - self.t > self.speed:\\n self.t = time.time()\\n return True\\n else:\\n return False\",\n \"def _is_noise(self, t):\\n\\t\\tfor ts in self.noise_itv:\\n\\t\\t\\tif len(ts) == 2:\\n\\t\\t\\t\\ttime1 = ts[0]\\n\\t\\t\\t\\ttime2 = ts[1]\\n\\t\\t\\t\\tif time1 <= t and t <= time2:\\n\\t\\t\\t\\t\\treturn True\\n\\t\\t\\telse:\\n\\t\\t\\t\\tend_time = ts[0]\\n\\t\\t\\t\\tif t >= end_time:\\n\\t\\t\\t\\t\\treturn True\\n\\t\\treturn False\",\n \"def extended(self):\\n if self.expires_at:\\n return self.expires_at - self.issued_at > timedelta(days=30)\\n return False\",\n \"def check_convergency(self):\\n if self.vars['ema_trace'][self.vars['step']] <= self.settings[\\\"emaSpeedTol\\\"]:\\n return True\\n else:\\n return False\",\n \"def set_exposure(self, exposure):\\n self.logger.info(f'Setting exposure to {exposure}')\\n self._driver.ExposureTime.SetValue(exposure)\",\n \"def expired(self):\\n return rospy.get_rostime() - self.start_time > self.duration\",\n \"def timestep(self):\\n self.survive()\\n self.move()\\n self.set_survival_probability(self.vital_var)\\n self.reproduce()\\n # self.save_frame()\\n if self.time % self.save_state_frequency == 0:\\n self.save_state(self.state_file.format(self.time))\\n if self.time % self.save_stats_frequency == 0:\\n self.write_stats()\\n # self.connected_component()\\n self.time += 1\\n\\n if self.pop_size > 0:\\n return True\\n else:\\n return False\",\n \"def mood_duration_millis():\\n return max(200, int(state.normal(750, 500)))\",\n \"def is_chunk_timeout(self, chunk_timeout): \\n return time() - self._chunk_timeout_time > chunk_timeout\",\n \"def delta_time(self):\\n delta_time = time.time() - self.time\\n if delta_time >= 1.0 / self.target_fps:\\n self.time = time.time()\\n # end if\\n return delta_time\",\n \"def test_duration_property(self):\\n recording_dt = 0.1\\n recording_shape = {\\n 'no_timesteps': 1000,\\n 'no_sweeps': 10,\\n 'no_channels': 4,\\n }\\n expected_duration = recording_shape['no_timesteps'] * recording_dt\\n test_rec = rt.Recording(\\n np.zeros(\\n [\\n recording_shape['no_channels'],\\n recording_shape['no_timesteps'],\\n recording_shape['no_sweeps'],\\n ]\\n ),\\n dt=recording_dt,\\n )\\n npt.assert_almost_equal(\\n test_rec.duration,\\n expected_duration,\\n err_msg='Expected {} for `duration` property; got {} instead.'.format(\\n expected_duration, test_rec.duration\\n ),\\n )\",\n \"def expired(self) -> bool:\\n if not self.use_wts:\\n return False\\n\\n return datetime.now() > self.expire\",\n \"def discrete_time(self):\\n return bool(self._ll_tree_sequence.get_discrete_time())\",\n \"def checkAtFinalTime():\\n global final_time\\n if final_time <= current_second:\\n return True\\n return False\",\n \"def delete_expired(self):\\n check_time = datetime.now()\\n if self.can_expire and self.duration:\\n exp_times = deepcopy(self.exp_times)\\n for key in exp_times:\\n if exp_times[key] < check_time:\\n self.delete(key)\",\n \"def is_limited(self) -> bool:\\n return self.__times > ActionState.UNLIMITED\",\n \"def is_delayed(self) -> bool:\\n if self.periodic and self.is_attached():\\n return self.runtime.cost > self.runtime.tasklet.tick\\n\\n return False\",\n \"def __sleep(self):\\n if self.sleep_duration > 0:\\n gevent.sleep(self.sleep_duration)\\n else:\\n self.__warn(\\n f\\\"The average tick took longer than the set tick duration of {self.__tick_duration}. \\\"\\n f\\\"Program is to heavy to run real time\\\")\",\n \"def exp(self) -> t.Optional[int]:\\n return self.claims.get(\\\"exp\\\")\",\n \"def rate_limiting(cls):\\n this_click_time = time.time()\\n time_to_last_click = None\\n if cls.last_click_time:\\n time_to_last_click = this_click_time - cls.last_click_time\\n cls.last_click_time = this_click_time\\n return time_to_last_click and time_to_last_click < 0.7\",\n \"def test_time_supp_length_matches_no_timesteps(self):\\n for no_timesteps in [5, 578, 993, 300072]:\\n for dt in [0.1, 0.5, 3.0]:\\n test_rec = rt.Recording(np.empty([6, no_timesteps, 1]), dt=dt)\\n self.assertEqual(\\n len(test_rec.time_supp),\\n no_timesteps,\\n 'Expected length of time_supp {} to match no_timesteps of '\\n 'input {}.'.format(len(test_rec.time_supp), no_timesteps),\\n )\",\n \"def timed_out(self):\\n return self.enabled and (\\n self.elapsed >= self.timeout\\n or math.isclose(self.elapsed, self.timeout)\\n )\",\n \"def check_timer(self, wanted_time):\\n if time.time() - self.start_time >= wanted_time:\\n return True\\n return False\",\n \"def setHoldTime(self, channel, time, unitCode=0):\\n # Ensure compliance with level boundary conditions\\n\\n resp = self.XAPCommand('GHOLD', channel, time, unitCode=unitCode)\\n return float(resp)\",\n \"def ComputeTimeReward(self, currentTime, expectedTime):\\r\\n return (expectedTime - currentTime) * 1 if currentTime < expectedTime else (expectedTime - currentTime) * 1\",\n \"def __checkTimer(self):\\n if self.__endTime is None:\\n raise AssertionError('The end time had not been set.')\\n if time.time() > self.__endTime:\\n self._logError('Maximum Run Time Reached !!')\\n raise _MaxRunTimeReachedError('')\",\n \"def _timeout_request(start_time, request_timeout):\\n return int(round(time() * 1000)) - start_time >= request_timeout\",\n \"def test_time(self):\\n M = simulation.StateMonitor(self.G, 'v')\\n sim = simulation.Simulation(self.G, M, dt=self.dt)\\n sim.run(self.t_max)\\n self.assertTrue(np.allclose(M.t, np.arange(0, self.t_max, self.dt)))\",\n \"def isTimeRemaining(self):\\n if self.run_type.startswith('timed'):\\n time_since_start = (time.time() - self.start_times['run'])\\n remaining_time = self.max_time * 60 - time_since_start\\n if remaining_time < 0:\\n return False\\n else:\\n return True\",\n \"def calculateDelayedEventTime(self, raw_time):\\n return self.event_time\",\n \"def is_over(self, time):\\n over = (not self.enable_loop()) and (time >= self.get_duration())\\n return over\",\n \"def is_equidistant(self) -> bool:\\n if len(self.time) < 3:\\n return True\\n return len(self.time.to_series().diff().dropna().unique()) == 1\",\n \"def explores(self, explores):\\n\\n self._explores = explores\",\n \"def fine_tune(self, duration = 2):\\n\\n with sr.Microphone() as source:\\n self.recorder.adjust_for_ambient_noise(source, duration=duration)\\n return self.recorder.energy_threshold\",\n \"def test_do_apogee_science_1000s_after_500s_cart7(self):\\n\\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLeadCart7'])\\n self._update_cart(7, 'APOGEE')\\n cmdState = self.actorState.doApogeeScience\\n cmdState.reinitialize(self.cmd)\\n self.assertEqual(cmdState.expTime, 500)\\n self.assertEqual(cmdState.keywords['expTime'], 500)\\n\\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLead1000sCart7'])\\n self._update_cart(7, 'APOGEE')\\n cmdState = self.actorState.doApogeeScience\\n cmdState.reinitialize(self.cmd)\\n self.assertEqual(cmdState.expTime, 1000)\\n self.assertEqual(cmdState.keywords['expTime'], 1000)\",\n \"def __check_total_duration(self, duration: int) -> bool:\\n available_duration = N_EIGHTHS_PER_MEASURE * (self.n_measures - 1)\\n return self.current_time_in_eighths + duration <= available_duration\",\n \"def Exposure(self, time):\\r\\n IS_EXPOSURE_CMD_SET_EXPOSURE = 12 #there is a whole list to implement\\r\\n TIME = DOUBLE(time)\\r\\n nSizeOfParam = 8\\r\\n CALL('Exposure', self, \\r\\n UINT(IS_EXPOSURE_CMD_SET_EXPOSURE), \\r\\n byref(TIME), \\r\\n UINT(nSizeOfParam))\",\n \"def test_custom_time(self):\\n interval = 0.5\\n M = simulation.StateMonitor(self.G, 'v', interval=interval)\\n sim = simulation.Simulation(self.G, M, dt=self.dt)\\n sim.run(self.t_max)\\n self.assertTrue(np.allclose(M.t, np.arange(0, self.t_max, interval)))\",\n \"def simulate_until(self, stop_time, dt=None):\\n while self.t < stop_time:\\n self.step(dt)\",\n \"def isExpired(self):\\n return True/False\",\n \"def get_timings(self):\\n exp=lib.is_Exposure_d8(self.hcam,7)*1E-3\\n frame_rate=lib.is_SetFrameRate(self.hcam,0x8000)\\n return self.AcqTimes(exp,1./frame_rate)\",\n \"def test_exp():\\n x = np.linspace(-3,3,13)\\n\\n default_use_numexpr = accel_math._USE_NUMEXPR\\n\\n accel_math._USE_NUMEXPR = True\\n r1 = accel_math._exp(x)\\n\\n accel_math._USE_NUMEXPR = False\\n r2 = accel_math._exp(x)\\n\\n np.testing.assert_almost_equal(r1,r2)\\n\\n accel_math._USE_NUMEXPR = default_use_numexpr\",\n \"def guard_time(self):\\n return uniform(0, self.max_guard_time)\",\n \"def _about_to_expire(self, secret: Secret) -> bool:\\n return secret.is_expired(datetime.now(UTC) + self.expiry_margin)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6508764","0.6255665","0.62178487","0.615677","0.57449126","0.5718129","0.562681","0.560696","0.5600589","0.5502671","0.54754275","0.54733014","0.5451332","0.5331526","0.529389","0.52561027","0.5224857","0.5195893","0.5194161","0.51847905","0.51787597","0.51708823","0.5164096","0.516151","0.51563543","0.5128906","0.5110004","0.5107061","0.5092745","0.50908405","0.50787985","0.50677943","0.506563","0.5057097","0.5045766","0.5039357","0.50273323","0.50153506","0.49983722","0.49860993","0.49858907","0.49657658","0.49502572","0.49489132","0.49486795","0.49469966","0.49450952","0.4942598","0.49225974","0.4922355","0.4920734","0.4913474","0.49049914","0.490453","0.49020043","0.4900217","0.48997605","0.48916352","0.48900992","0.48845503","0.48769727","0.48690078","0.4865471","0.48605007","0.48499867","0.48462734","0.48350704","0.4830496","0.48224762","0.48178232","0.48173565","0.48164526","0.4816118","0.48138097","0.47986743","0.4787773","0.47682443","0.47654238","0.47588697","0.47537604","0.475016","0.47447678","0.4740874","0.4730716","0.47162125","0.47124946","0.4702591","0.47003716","0.4698047","0.46947765","0.46946338","0.4694088","0.4692679","0.46907756","0.46888813","0.4686828","0.4686386","0.46837866","0.46777448","0.4677685"],"string":"[\n \"0.6508764\",\n \"0.6255665\",\n \"0.62178487\",\n \"0.615677\",\n \"0.57449126\",\n \"0.5718129\",\n \"0.562681\",\n \"0.560696\",\n \"0.5600589\",\n \"0.5502671\",\n \"0.54754275\",\n \"0.54733014\",\n \"0.5451332\",\n \"0.5331526\",\n \"0.529389\",\n \"0.52561027\",\n \"0.5224857\",\n \"0.5195893\",\n \"0.5194161\",\n \"0.51847905\",\n \"0.51787597\",\n \"0.51708823\",\n \"0.5164096\",\n \"0.516151\",\n \"0.51563543\",\n \"0.5128906\",\n \"0.5110004\",\n \"0.5107061\",\n \"0.5092745\",\n \"0.50908405\",\n \"0.50787985\",\n \"0.50677943\",\n \"0.506563\",\n \"0.5057097\",\n \"0.5045766\",\n \"0.5039357\",\n \"0.50273323\",\n \"0.50153506\",\n \"0.49983722\",\n \"0.49860993\",\n \"0.49858907\",\n \"0.49657658\",\n \"0.49502572\",\n \"0.49489132\",\n \"0.49486795\",\n \"0.49469966\",\n \"0.49450952\",\n \"0.4942598\",\n \"0.49225974\",\n \"0.4922355\",\n \"0.4920734\",\n \"0.4913474\",\n \"0.49049914\",\n \"0.490453\",\n \"0.49020043\",\n \"0.4900217\",\n \"0.48997605\",\n \"0.48916352\",\n \"0.48900992\",\n \"0.48845503\",\n \"0.48769727\",\n \"0.48690078\",\n \"0.4865471\",\n \"0.48605007\",\n \"0.48499867\",\n \"0.48462734\",\n \"0.48350704\",\n \"0.4830496\",\n \"0.48224762\",\n \"0.48178232\",\n \"0.48173565\",\n \"0.48164526\",\n \"0.4816118\",\n \"0.48138097\",\n \"0.47986743\",\n \"0.4787773\",\n \"0.47682443\",\n \"0.47654238\",\n \"0.47588697\",\n \"0.47537604\",\n \"0.475016\",\n \"0.47447678\",\n \"0.4740874\",\n \"0.4730716\",\n \"0.47162125\",\n \"0.47124946\",\n \"0.4702591\",\n \"0.47003716\",\n \"0.4698047\",\n \"0.46947765\",\n \"0.46946338\",\n \"0.4694088\",\n \"0.4692679\",\n \"0.46907756\",\n \"0.46888813\",\n \"0.4686828\",\n \"0.4686386\",\n \"0.46837866\",\n \"0.46777448\",\n \"0.4677685\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.4705112"},"document_rank":{"kind":"string","value":"86"}}},{"rowIdx":499,"cells":{"query":{"kind":"string","value":"Tests if expTime is set to 1000s after a normal length exposure."},"document":{"kind":"string","value":"def test_do_apogee_science_1000s_after_500s_cart7(self):\n\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLeadCart7'])\n self._update_cart(7, 'APOGEE')\n cmdState = self.actorState.doApogeeScience\n cmdState.reinitialize(self.cmd)\n self.assertEqual(cmdState.expTime, 500)\n self.assertEqual(cmdState.keywords['expTime'], 500)\n\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLead1000sCart7'])\n self._update_cart(7, 'APOGEE')\n cmdState = self.actorState.doApogeeScience\n cmdState.reinitialize(self.cmd)\n self.assertEqual(cmdState.expTime, 1000)\n self.assertEqual(cmdState.keywords['expTime'], 1000)"},"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 exp(self, exposure_time):\n print(f\"exp: {exposure_time}\")\n self.device_control.exposure = exposure_time\n yield","def setExposureTime(self, cmd, expTime):\n\n pass","def exposuretime(self) -> ErrorValue:\n return ErrorValue(self._data['ExpTime'], self._data.setdefault('ExpTimeError',0.0))","def exptime(et=0.02):\n if et < 0.02:\n et = 0.02\n logger.error('Exposure time less than 0.02 seconds specified, using 0.02.')\n print camera.exptime(et)\n camera.status.update()","def time_to_fire(self):\n return(self.frequency < (time.time() - self.last_fired))","def is_time(self) -> bool:\n return self.times > 1","def _validate_exp(self):\n now = timegm(datetime.utcnow().utctimetuple())\n\n if self.authtype == 'jwt':\n if not hasattr(self, 'token'):\n # I pass here only one time, when I request a token\n self.token = None\n return True\n payload = jwt.decode(self.token, verify=False)\n try:\n exp = int(payload['exp'])\n except ValueError:\n raise jwt.DecodeError('Expiration Time claim (exp) must be an'\n ' integer.')\n\n if exp < now:\n # raise jwt.ExpiredSignatureError('Signature has expired')\n return False\n else:\n self.s.auth = JWTAuth(self.token)\n return True\n else:\n return True","def check_time():\n times = get_times()\n time_difference = abs((times['local'] - times['target']).total_seconds())\n return time_difference < post_time_tol_seconds","def setExpTime(self, exptime):\n with self.lock:\n self.exptime = exptime","def validate_exp(self, now, leeway):\n if 'exp' in self:\n exp = self['exp']\n if not _validate_numeric_time(exp):\n raise InvalidClaimError('exp')\n if exp < (now - leeway):\n raise ExpiredTokenError()","def is_expired(self):\n if not self.is_signed:\n return True\n return int(self._token_claims.get(self.__class__.exp_claim, 0)) < int(\n time.time()\n )","def set_exptime(self, exptime):\n exptime = u.Quantity(exptime, unit=u.s)\n if not np.isscalar(exptime):\n raise TypeError('Exposure time must be an integer, a float or an Astropy Unit object')\n if exptime.value <= 0:\n raise ValueError('Exposure time can not be zero or negative')\n self.exptime = exptime.value\n try:\n if self.cycle < self.exptime:\n warnings.warn('Exposure time ({:0.4f} seconds) higher than Cycle time ({:0.4f} seconds)'.\n format(self.exptime, self.cycle))\n except:\n pass","def exceeded(self):\r\n return int(time.time()) - self.start_time >= self.length","def time_is_out(self):\n return self.get_simulation_time() > self.config.max_time","def realtime(self):\n return self._time is None","def valid(t):\n return float(t) > time.time()","def overtime(self):\n if self._overtime != '':\n return True\n return False","def check_attack(self):\n now = time.time() * 1000\n if self.prev_time is None:\n return True\n else:\n next_time = self.prev_time + self.get_recharge\n if now >= next_time:\n return True\n else:\n return False","def checkAtFinalTime():\n global final_time\n if final_time <= current_second:\n return True\n return False","def haveTime(self):\n if self.timeout is None:\n return True\n return time.time() <= self._stop","def _verify_timeout(self, doc):\n expires = doc['expires']\n if expires == 0:\n return False\n if expires >= self._time():\n return False\n return True","def verify_event_timing(self, event, item):\n return True","def is_expired(self):\n return int(time.time()) - self.time > self.interval","def _badness(self, time):\n return (time - self.expected_time)**2","def check_lightcurve_time(light_curve, exposure_time, frame_time):\n logger = logging.getLogger('mirage.seed_image.tso.check_lightcurve_time')\n\n times = copy.deepcopy(light_curve[\"times\"].value)\n fluxes = copy.deepcopy(light_curve[\"fluxes\"].value)\n time_units = light_curve[\"times\"].unit\n flux_units = light_curve[\"fluxes\"].unit\n adjusted = False\n\n # Remove elements where time < 0.\n if np.min(times) < 0.:\n positive_times = times >= 0.\n times = times[positive_times]\n fluxes = fluxes[positive_times]\n adjusted = True\n\n # If the times begin at values significantly > 0,\n # then add entries to bring the start back to time = 0\n if np.min(times) > 0.:\n logger.info((\"Lightcurve time values do not start at zero. Prepending an entry with time=0 \"\n \"and flux = 1.\"))\n times = np.insert(times, 0, 0.)\n fluxes = np.insert(fluxes, 0, 1.)\n adjusted = True\n\n # If the ending time is less than the exposure's total\n # observation time, then add entries with flux=1\n if np.max(times) < exposure_time:\n logger.info((\"Lightcurve time values extend only to {} seconds. This is not long enough \"\n \"to cover the entire exposure time of {} seconds. Extending to cover the full \"\n \"exposure time with flux = 1.\".format(np.max(times), exposure_time)))\n times = np.append(times, exposure_time + 5 * frame_time)\n fluxes = np.append(fluxes, 1.)\n adjusted = True\n\n if adjusted:\n light_curve[\"times\"] = times * time_units\n light_curve[\"fluxes\"] = fluxes * flux_units\n\n return light_curve","def is_timeout(self) -> bool:\n return self.runtime.timeout <= 0.0","def expired(self):\n return rospy.get_rostime() - self.start_time > self.duration","def _check_maxexp(np_type, maxexp):\n dt = np.dtype(np_type)\n np_type = dt.type\n two = np_type(2).reshape((1,)) # to avoid upcasting\n return (np.isfinite(two ** (maxexp - 1)) and\n not np.isfinite(two ** maxexp))","def tick(self):\n if time.time() - self.t > self.speed:\n self.t = time.time()\n return True\n else:\n return False","def evaluate(self, time) -> float:\n ...","def is_real_time(self):\n return time.time() - self.timestamp < self._DEADLINE_SEC","def is_expired(self):\n\n if self._lifetime is not None and self._lifetime > 0:\n # 300 seconds waite is the tolerance !\n # The unit of lifetime is millisecond\n if (time.time() - self._create_date) * 1000 > self._lifetime + 300000:\n return True\n\n return False","def _matchTime(self, time: float):\n return self._comparator['Time'] < time","def evaluateTime(self, *args):\n return _osgAnimation.Motion_evaluateTime(self, *args)","def check_time(self, m, s):\r\n if m*60 + s > 5400:\r\n self.unit.s = 0\r\n self.unit.m = 90\r\n return\r\n if s < 0:\r\n s = 0\r\n if m < 0:\r\n m = 0\r\n self.unit.s = s\r\n self.unit.m = m","def discrete_time(self):\n return bool(self._ll_tree_sequence.get_discrete_time())","def after(self, time2):\r\n return self.to_seconds() > time2.to_seconds()","def test_upload_time(self):\n time_val = 1345427105 # just a realistic time val, ~ 8/19/12 6:45pm\n self.assertIsNone(self.model.last_uploaded(),\n \"Did not return None even though upload entry doesn't exist\")\n self.model.set_last_uploaded(time_val)\n self.assertEquals(time_val, self.model.last_uploaded(),\n \"Created initial val, but appears incorect\")\n self.model.set_last_uploaded(time_val + 10)\n self.assertEquals(time_val + 10, self.model.last_uploaded(),\n \"Updated value, but appears incorrect\")","def validity_by_time(self):\n conn = psycopg2.connect(self.conn)\n permissable_maximum_age_secs = 600 # 600s = 10mins\n query = \"SELECT time FROM steve_sense_sensor_logs ORDER BY time DESC LIMIT 1\"\n cur = conn.cursor()\n cur.execute(query)\n queryResult = cur.fetchall()\n age_seconds = (datetime.datetime.now(\n timezone.utc) - queryResult[0][0]).seconds\n cur.close()\n conn.close()\n if age_seconds > permissable_maximum_age_secs:\n print(\"Check Sensor, last sample is \"+str(age_seconds)+\" old\")\n return False\n else:\n return True","def is_sampling_for_minmax(self):\n return (self._level_change_time is not None) and \\\n (get_time() - self._level_change_time) < self._duration_in_sec","def check_convergency(self):\n if self.vars['ema_trace'][self.vars['step']] <= self.settings[\"emaSpeedTol\"]:\n return True\n else:\n return False","def extended(self):\n if self.expires_at:\n return self.expires_at - self.issued_at > timedelta(days=30)\n return False","def valid(self):\n delta = datetime.datetime.now() - self._last_access\n return ((delta.seconds < 7200) and not self.is_empty()) or \\\n (delta.seconds < 60)","def __luredWakeupTime(self, suitId):\n return self.__suitIsLured(suitId) and \\\n self.currentlyLuredSuits[suitId][0] > 0 and \\\n random.randint(0, 99) < \\\n self.currentlyLuredSuits[suitId][2]","def epsilon(self, length: int, time: int) -> float:\n return (self.beta ** (1.0 / (length / 2))) ** time","def __exp1_changed_callback(self, ndx):\n if self.recording_sequence:\n self.record_sequence()\n self.exp1_radio.setChecked(True)\n self.exp1_ifi_select.setCurrentIndex(0)\n self.camera.set_exposure(ndx, 0)\n self.rec_seq_button.setEnabled(False)\n et = np.int(np.round(self.camera.actual_exposure_time_ms))\n self.write_to_log('Exposure %d ms' % et)","def isPeriodTimerEffective(self):\n return 1","def is_dropped(upd_time, time_before):\n if (upd_time - time_before) / float(Config.BOUNDARY) >= 1.5:\n return True\n return False","def test_exp():\n x = np.linspace(-3,3,13)\n\n default_use_numexpr = accel_math._USE_NUMEXPR\n\n accel_math._USE_NUMEXPR = True\n r1 = accel_math._exp(x)\n\n accel_math._USE_NUMEXPR = False\n r2 = accel_math._exp(x)\n\n np.testing.assert_almost_equal(r1,r2)\n\n accel_math._USE_NUMEXPR = default_use_numexpr","def isTimeRemaining(self):\n if self.run_type.startswith('timed'):\n time_since_start = (time.time() - self.start_times['run'])\n remaining_time = self.max_time * 60 - time_since_start\n if remaining_time < 0:\n return False\n else:\n return True","def _isBasisDuration(self):\n invdur = 1/self.getDurationNoDot()\n if invdur % 1 > 0:\n return False\n else:\n return True","def __exp2_changed_callback(self, ndx):\n if self.recording_sequence:\n self.record_sequence()\n self.exp2_radio.setChecked(True)\n self.exp2_ifi_select.setCurrentIndex(0)\n self.camera.set_exposure(ndx, 0)\n self.rec_seq_button.setEnabled(False)\n et = np.int(np.round(self.camera.actual_exposure_time_ms))\n self.write_to_log('Exposure %d ms' % et)","def exp(self) -> t.Optional[int]:\n return self.claims.get(\"exp\")","def after(self, time2):\n return self.to_seconds() > time2.to_seconds()","def test_EXPIRY_DURATION(self):\n self.assertIsInstance(constants.EXPIRY_DURATION, int,\n \"constants.EXPIRY_DURATION must be an integer.\")","def timedout(self):\n\n return self.duration() > self.check.timeout","def check_timer(self, wanted_time):\n if time.time() - self.start_time >= wanted_time:\n return True\n return False","def test_expand_data_1500_correct_len():\n # TODO: should it round up to allow last snippet of time?\n exp = expand_data(log, 1500)\n assert len(exp) == (log['end'].iloc[-1] / 1500)","def isCalibrationExpired(self):\n return (getI1ProTimeUntilCalibrationExpire() < 200)","def hit(self):\n if self._power == 0 :\n return False\n self._power -= 1\n return True","def important_event(time: int) -> bool:\n last_event = get_events(True)[0]\n try:\n time_event = int(last_event.split('\\n')[0].strip(\"'\"))\n except ValueError:\n time_event = int(last_event.split('\\n')[-1].strip(\"'\"))\n if time - time_event < 60:\n return 'gol' in last_event or 'cartão' in last_event\n return False","def check_expiration(self, cur_time):\n\n\t\ttime_limit = 1000\n\t\ttime_elapsed = cur_time - self.time_created\n\n\t\t# Erase cache after an arbitrary amount of time\n\t\tif time_elapsed > time_limit:\n\t\t\tself.cache_expiration()","def is_equidistant(self) -> bool:\n if len(self.time) < 3:\n return True\n return len(self.time.to_series().diff().dropna().unique()) == 1","def delta_time(self):\n delta_time = time.time() - self.time\n if delta_time >= 1.0 / self.target_fps:\n self.time = time.time()\n # end if\n return delta_time","def _check_bullet_cooldown(self):\n time_now = pygame.time.get_ticks()\n if time_now - self.last_bullet_fired >= self.bullet_cooldown:\n self.shoot_disabled = False","def _check_goauth_expiration(self, expiry):\n now = int(time.time())\n time_left = int(expiry) - now\n # 10 days\n min_time_left = 60*60*24*10\n if time_left < min_time_left:\n return False\n else:\n return True","def test_time_supp_length_matches_no_timesteps(self):\n for no_timesteps in [5, 578, 993, 300072]:\n for dt in [0.1, 0.5, 3.0]:\n test_rec = rt.Recording(np.empty([6, no_timesteps, 1]), dt=dt)\n self.assertEqual(\n len(test_rec.time_supp),\n no_timesteps,\n 'Expected length of time_supp {} to match no_timesteps of '\n 'input {}.'.format(len(test_rec.time_supp), no_timesteps),\n )","def T_elapsed(T_amount: BlockHeight) -> bool:\n T_now = getCurrentBlockHeight()\n return T_now - T_init >= T_amount","def exposuretime(self):\n _, = self.exposuretimes\n return _","def delete_expired(self):\n check_time = datetime.now()\n if self.can_expire and self.duration:\n exp_times = deepcopy(self.exp_times)\n for key in exp_times:\n if exp_times[key] < check_time:\n self.delete(key)","def ComputeTimeReward(self, currentTime, expectedTime):\r\n return (expectedTime - currentTime) * 1 if currentTime < expectedTime else (expectedTime - currentTime) * 1","def is_limited(self) -> bool:\n return self.__times > ActionState.UNLIMITED","def is_exploring(self, step):\n return np.random.rand() < self._epsilon(step)","def test_duration_property(self):\n recording_dt = 0.1\n recording_shape = {\n 'no_timesteps': 1000,\n 'no_sweeps': 10,\n 'no_channels': 4,\n }\n expected_duration = recording_shape['no_timesteps'] * recording_dt\n test_rec = rt.Recording(\n np.zeros(\n [\n recording_shape['no_channels'],\n recording_shape['no_timesteps'],\n recording_shape['no_sweeps'],\n ]\n ),\n dt=recording_dt,\n )\n npt.assert_almost_equal(\n test_rec.duration,\n expected_duration,\n err_msg='Expected {} for `duration` property; got {} instead.'.format(\n expected_duration, test_rec.duration\n ),\n )","def rate_limiting(cls):\n this_click_time = time.time()\n time_to_last_click = None\n if cls.last_click_time:\n time_to_last_click = this_click_time - cls.last_click_time\n cls.last_click_time = this_click_time\n return time_to_last_click and time_to_last_click < 0.7","def isDefaultedAt(self, time):\n return time > self.getDefaultTime()","def test_fields_effort_time_units_dictionary_success(self, _mock_check):\n field = EffortField(time_units={\"minute\": (\"minute\", \"minutes\")})\n\n errors = field.check()\n self.assertEqual(len(errors), 0)","def excitationPulse(self, time, power):\n t = time * ns + self.step # Should center at one step before 0\n if self.step <= 200 * ps: # resolution warrants modelling the pulse\n width = 200.0 * ps # self.step\n\n if t < width * 10: # Only evaulate when the value is significant\n amp = power / (width * sqrt_2pi) # normalized amplitude\n value = amp * np.exp(-1.0 * (t) * (t) / (2 * width * width))\n value = value\n else:\n value = 0.0\n else: # impulsive limit, just dump all the excitons in at t=0\n # if time >= 0 - self.step/2 and time < 0 + self.step/2:\n if t > -0.5 * self.step and t <= 0.5 * self.step:\n value = power / self.step\n else:\n value = 0.0\n return (value*self.step)","def metropolis ( delta ):\n\n import numpy as np\n \n exponent_guard = 75.0\n\n if delta > exponent_guard: # Too high, reject without evaluating\n return False\n elif delta < 0.0: # Downhill, accept without evaluating\n return True\n else:\n zeta = np.random.rand() # Uniform random number in range (0,1)\n return np.exp(-delta) > zeta # Metropolis test","def is_expired(self):\n\n return time.time() * 1000 - self._refreshed_on > self._expire","def is_expired(self):\n return timeutils.utcnow_ts() > self.expire_ts","def is_expired(self) -> bool:\n return now() > self.expires","def io_operation(self, time):\n self._io_time -= time\n if self._io_time <= 0:\n self._io = False\n return True\n return False","def _is_noise(self, t):\n\t\tfor ts in self.noise_itv:\n\t\t\tif len(ts) == 2:\n\t\t\t\ttime1 = ts[0]\n\t\t\t\ttime2 = ts[1]\n\t\t\t\tif time1 <= t and t <= time2:\n\t\t\t\t\treturn True\n\t\t\telse:\n\t\t\t\tend_time = ts[0]\n\t\t\t\tif t >= end_time:\n\t\t\t\t\treturn True\n\t\treturn False","def _long_range_normed_exposure_between_bounds(self, time1: float, time2: float) -> _VectorisedFloat:\n exposure = 0.\n for start, stop in self.exposed.presence_interval().boundaries():\n if stop < time1:\n continue\n elif start > time2:\n break\n elif start <= time1 and time2<= stop:\n exposure += self.concentration_model.normed_integrated_concentration(time1, time2)\n elif start <= time1 and stop < time2:\n exposure += self.concentration_model.normed_integrated_concentration(time1, stop)\n elif time1 < start and time2 <= stop:\n exposure += self.concentration_model.normed_integrated_concentration(start, time2)\n elif time1 <= start and stop < time2:\n exposure += self.concentration_model.normed_integrated_concentration(start, stop)\n return exposure","def _timeout_request(start_time, request_timeout):\n return int(round(time() * 1000)) - start_time >= request_timeout","def time_until_full(self):\n if ((datetime.datetime.utcnow() - self.initial_time).total_seconds() \n > UPDATE_PERIOD\n and self.space_decay_rate() < 0):\n secs_until_full = self.available_space() / -self.space_decay_rate() \n return datetime.timedelta(seconds=secs_until_full)","def isFreeTimeExpired(self):\n assert self.notify.debugStateCall(self, 'loginFSM', 'gameFSM')\n if self.accountOldAuth:\n return 0\n\n # check for the config overrides\n # if true, free-time-expired takes precedence over unlimited-free-time\n if base.config.GetBool(\"free-time-expired\", 0):\n return 1\n if base.config.GetBool(\"unlimited-free-time\", 0):\n return 0\n\n # -1 == never expires (paid/exempt)\n if self.freeTimeExpiresAt == -1:\n return 0\n\n # 0 == expired\n if self.freeTimeExpiresAt == 0:\n return 1\n\n if self.freeTimeExpiresAt < -1:\n self.notify.warning('freeTimeExpiresAt is less than -1 (%s)' %\n self.freeTimeExpiresAt)\n\n # freeTimeExpiresAt is an epoch time\n # is it in the past?\n if self.freeTimeExpiresAt < time.time():\n return 1\n else:\n return 0","def is_expired(self):\n if self.access_token is None:\n logging.debug('Access token not found')\n return True\n else:\n return (self.expiration <= datetime.now())","def checkGracePeriodDuration(self):\n if (not self.isInGraceInvulnerability):\n return\n if (time.time()-self.gracePeriodStartTime > shipDamagedInvulerabilityGracePeriodLength):\n #if the grace period is over...\n self.disableGracePeriod()","def _is_percent_of_time(percent_of_time):\n assert 0 <= percent_of_time\n assert percent_of_time <= 100\n random_number = random.uniform(0, 100)\n return random_number <= percent_of_time","def _safe_limit_check(self):\n if self.rem == 40:\n self.time_start = time.time()\n elif time.time() - self.time_start >= 11:\n self.rem = 40\n self.time_start = time.time()\n elif self.rem <= 0:\n t = 11 - (time.time() - self.time_start)\n\n if t <= 0:\n self.rem = 40\n self.time_start = time.time()\n else:\n if self.policy == Limit.Sleep:\n time.sleep(t)\n elif self.policy == Limit.Ignore:\n return False\n\n self.rem -= 1\n return True","def close_to_exceeding(self) -> bool:\n mean = self.current / self.num_cuts\n if self.max_frames is not None:\n return self.current + mean > self.max_frames\n if self.max_samples is not None:\n return self.current + mean > self.max_samples\n if self.max_duration is not None:\n return self.current + mean > self.max_duration\n return False","def expired(self):\n return int(time.time()) > self.expires_at","def __checkTimer(self):\n if self.__endTime is None:\n raise AssertionError('The end time had not been set.')\n if time.time() > self.__endTime:\n self._logError('Maximum Run Time Reached !!')\n raise _MaxRunTimeReachedError('')","def tune_exposure_time(camera, target, initial_exptime, min_exptime=0, max_exptime=None,\n max_steps=5, tolerance=0.1, cutout_size=256, bias=None, **kwargs):\n camera.logger.info(f\"Tuning exposure time for {camera}.\")\n\n images_dir = camera.get_config(\"directories.images\", None)\n if images_dir:\n images_dir = os.path.join(images_dir, \"temp\")\n os.makedirs(images_dir, exist_ok=True)\n\n # Parse quantities\n initial_exptime = get_quantity_value(initial_exptime, \"second\") * u.second\n\n if min_exptime is not None:\n min_exptime = get_quantity_value(min_exptime, \"second\") * u.second\n if max_exptime is not None:\n max_exptime = get_quantity_value(max_exptime, \"second\") * u.second\n\n try:\n bit_depth = camera.bit_depth.to_value(\"bit\")\n except NotImplementedError:\n bit_depth = 16\n\n saturated_counts = 2 ** bit_depth\n\n prefix = images_dir if images_dir is None else images_dir + \"/\"\n with tempfile.NamedTemporaryFile(suffix=\".fits\", prefix=prefix, delete=False) as tf:\n\n exptime = initial_exptime\n\n for step in range(max_steps):\n\n # Check if exposure time is within valid range\n if (exptime == max_exptime) or (exptime == min_exptime):\n break\n\n # Get an image\n cutout = camera.get_cutout(exptime, tf.name, cutout_size, keep_file=False, **kwargs)\n cutout = cutout.astype(\"float32\")\n if bias is not None:\n cutout -= bias\n\n # Measure average counts\n normalised_counts = np.median(cutout) / saturated_counts\n\n camera.logger.debug(f\"Normalised counts for {exptime} exposure on {camera}:\"\n f\" {normalised_counts}\")\n\n # Check if tolerance condition is met\n if tolerance:\n if abs(normalised_counts - target) < tolerance:\n break\n\n # Update exposure time\n exptime = exptime * target / normalised_counts\n if max_exptime is not None:\n exptime = min(exptime, max_exptime)\n if min_exptime is not None:\n exptime = max(exptime, min_exptime)\n\n camera.logger.info(f\"Tuned exposure time for {camera}: {exptime}\")\n\n return exptime","def _check_pulse(self):\n timedelta = time.time() - self.heartbeat\n update_delay = float(1/self.qbpm.frequency)\n time_to_update = False\n if timedelta > update_delay:\n time_to_update = True\n self.heartbeat = time.time()\n return time_to_update","def testStretchedExpData(nTimes = 1000, beta = 0.5, sigma = 0.05, linear=False):\n\n if linear:\n Times = rangeLin(1.0e-3, 1.0e+3, nTimes) # in seconds\n else:\n Times = rangeLog(1.0e-3, 1.0e+3, nTimes) # in seconds\n\n Data = np.exp(-1.*(Times**beta))\n Data += sigma*np.random.randn( len(Data) )\n\n return Times, Data","def expired(self) -> bool:\n if not self.use_wts:\n return False\n\n return datetime.now() > self.expire","def is_over(self, time):\n over = (not self.enable_loop()) and (time >= self.get_duration())\n return over","def sanity_check(self):\n res = True\n res = res and self.detected\n res = res and np.sum(self.diffs) < 30000 # experimental value\n return res"],"string":"[\n \"def exp(self, exposure_time):\\n print(f\\\"exp: {exposure_time}\\\")\\n self.device_control.exposure = exposure_time\\n yield\",\n \"def setExposureTime(self, cmd, expTime):\\n\\n pass\",\n \"def exposuretime(self) -> ErrorValue:\\n return ErrorValue(self._data['ExpTime'], self._data.setdefault('ExpTimeError',0.0))\",\n \"def exptime(et=0.02):\\n if et < 0.02:\\n et = 0.02\\n logger.error('Exposure time less than 0.02 seconds specified, using 0.02.')\\n print camera.exptime(et)\\n camera.status.update()\",\n \"def time_to_fire(self):\\n return(self.frequency < (time.time() - self.last_fired))\",\n \"def is_time(self) -> bool:\\n return self.times > 1\",\n \"def _validate_exp(self):\\n now = timegm(datetime.utcnow().utctimetuple())\\n\\n if self.authtype == 'jwt':\\n if not hasattr(self, 'token'):\\n # I pass here only one time, when I request a token\\n self.token = None\\n return True\\n payload = jwt.decode(self.token, verify=False)\\n try:\\n exp = int(payload['exp'])\\n except ValueError:\\n raise jwt.DecodeError('Expiration Time claim (exp) must be an'\\n ' integer.')\\n\\n if exp < now:\\n # raise jwt.ExpiredSignatureError('Signature has expired')\\n return False\\n else:\\n self.s.auth = JWTAuth(self.token)\\n return True\\n else:\\n return True\",\n \"def check_time():\\n times = get_times()\\n time_difference = abs((times['local'] - times['target']).total_seconds())\\n return time_difference < post_time_tol_seconds\",\n \"def setExpTime(self, exptime):\\n with self.lock:\\n self.exptime = exptime\",\n \"def validate_exp(self, now, leeway):\\n if 'exp' in self:\\n exp = self['exp']\\n if not _validate_numeric_time(exp):\\n raise InvalidClaimError('exp')\\n if exp < (now - leeway):\\n raise ExpiredTokenError()\",\n \"def is_expired(self):\\n if not self.is_signed:\\n return True\\n return int(self._token_claims.get(self.__class__.exp_claim, 0)) < int(\\n time.time()\\n )\",\n \"def set_exptime(self, exptime):\\n exptime = u.Quantity(exptime, unit=u.s)\\n if not np.isscalar(exptime):\\n raise TypeError('Exposure time must be an integer, a float or an Astropy Unit object')\\n if exptime.value <= 0:\\n raise ValueError('Exposure time can not be zero or negative')\\n self.exptime = exptime.value\\n try:\\n if self.cycle < self.exptime:\\n warnings.warn('Exposure time ({:0.4f} seconds) higher than Cycle time ({:0.4f} seconds)'.\\n format(self.exptime, self.cycle))\\n except:\\n pass\",\n \"def exceeded(self):\\r\\n return int(time.time()) - self.start_time >= self.length\",\n \"def time_is_out(self):\\n return self.get_simulation_time() > self.config.max_time\",\n \"def realtime(self):\\n return self._time is None\",\n \"def valid(t):\\n return float(t) > time.time()\",\n \"def overtime(self):\\n if self._overtime != '':\\n return True\\n return False\",\n \"def check_attack(self):\\n now = time.time() * 1000\\n if self.prev_time is None:\\n return True\\n else:\\n next_time = self.prev_time + self.get_recharge\\n if now >= next_time:\\n return True\\n else:\\n return False\",\n \"def checkAtFinalTime():\\n global final_time\\n if final_time <= current_second:\\n return True\\n return False\",\n \"def haveTime(self):\\n if self.timeout is None:\\n return True\\n return time.time() <= self._stop\",\n \"def _verify_timeout(self, doc):\\n expires = doc['expires']\\n if expires == 0:\\n return False\\n if expires >= self._time():\\n return False\\n return True\",\n \"def verify_event_timing(self, event, item):\\n return True\",\n \"def is_expired(self):\\n return int(time.time()) - self.time > self.interval\",\n \"def _badness(self, time):\\n return (time - self.expected_time)**2\",\n \"def check_lightcurve_time(light_curve, exposure_time, frame_time):\\n logger = logging.getLogger('mirage.seed_image.tso.check_lightcurve_time')\\n\\n times = copy.deepcopy(light_curve[\\\"times\\\"].value)\\n fluxes = copy.deepcopy(light_curve[\\\"fluxes\\\"].value)\\n time_units = light_curve[\\\"times\\\"].unit\\n flux_units = light_curve[\\\"fluxes\\\"].unit\\n adjusted = False\\n\\n # Remove elements where time < 0.\\n if np.min(times) < 0.:\\n positive_times = times >= 0.\\n times = times[positive_times]\\n fluxes = fluxes[positive_times]\\n adjusted = True\\n\\n # If the times begin at values significantly > 0,\\n # then add entries to bring the start back to time = 0\\n if np.min(times) > 0.:\\n logger.info((\\\"Lightcurve time values do not start at zero. Prepending an entry with time=0 \\\"\\n \\\"and flux = 1.\\\"))\\n times = np.insert(times, 0, 0.)\\n fluxes = np.insert(fluxes, 0, 1.)\\n adjusted = True\\n\\n # If the ending time is less than the exposure's total\\n # observation time, then add entries with flux=1\\n if np.max(times) < exposure_time:\\n logger.info((\\\"Lightcurve time values extend only to {} seconds. This is not long enough \\\"\\n \\\"to cover the entire exposure time of {} seconds. Extending to cover the full \\\"\\n \\\"exposure time with flux = 1.\\\".format(np.max(times), exposure_time)))\\n times = np.append(times, exposure_time + 5 * frame_time)\\n fluxes = np.append(fluxes, 1.)\\n adjusted = True\\n\\n if adjusted:\\n light_curve[\\\"times\\\"] = times * time_units\\n light_curve[\\\"fluxes\\\"] = fluxes * flux_units\\n\\n return light_curve\",\n \"def is_timeout(self) -> bool:\\n return self.runtime.timeout <= 0.0\",\n \"def expired(self):\\n return rospy.get_rostime() - self.start_time > self.duration\",\n \"def _check_maxexp(np_type, maxexp):\\n dt = np.dtype(np_type)\\n np_type = dt.type\\n two = np_type(2).reshape((1,)) # to avoid upcasting\\n return (np.isfinite(two ** (maxexp - 1)) and\\n not np.isfinite(two ** maxexp))\",\n \"def tick(self):\\n if time.time() - self.t > self.speed:\\n self.t = time.time()\\n return True\\n else:\\n return False\",\n \"def evaluate(self, time) -> float:\\n ...\",\n \"def is_real_time(self):\\n return time.time() - self.timestamp < self._DEADLINE_SEC\",\n \"def is_expired(self):\\n\\n if self._lifetime is not None and self._lifetime > 0:\\n # 300 seconds waite is the tolerance !\\n # The unit of lifetime is millisecond\\n if (time.time() - self._create_date) * 1000 > self._lifetime + 300000:\\n return True\\n\\n return False\",\n \"def _matchTime(self, time: float):\\n return self._comparator['Time'] < time\",\n \"def evaluateTime(self, *args):\\n return _osgAnimation.Motion_evaluateTime(self, *args)\",\n \"def check_time(self, m, s):\\r\\n if m*60 + s > 5400:\\r\\n self.unit.s = 0\\r\\n self.unit.m = 90\\r\\n return\\r\\n if s < 0:\\r\\n s = 0\\r\\n if m < 0:\\r\\n m = 0\\r\\n self.unit.s = s\\r\\n self.unit.m = m\",\n \"def discrete_time(self):\\n return bool(self._ll_tree_sequence.get_discrete_time())\",\n \"def after(self, time2):\\r\\n return self.to_seconds() > time2.to_seconds()\",\n \"def test_upload_time(self):\\n time_val = 1345427105 # just a realistic time val, ~ 8/19/12 6:45pm\\n self.assertIsNone(self.model.last_uploaded(),\\n \\\"Did not return None even though upload entry doesn't exist\\\")\\n self.model.set_last_uploaded(time_val)\\n self.assertEquals(time_val, self.model.last_uploaded(),\\n \\\"Created initial val, but appears incorect\\\")\\n self.model.set_last_uploaded(time_val + 10)\\n self.assertEquals(time_val + 10, self.model.last_uploaded(),\\n \\\"Updated value, but appears incorrect\\\")\",\n \"def validity_by_time(self):\\n conn = psycopg2.connect(self.conn)\\n permissable_maximum_age_secs = 600 # 600s = 10mins\\n query = \\\"SELECT time FROM steve_sense_sensor_logs ORDER BY time DESC LIMIT 1\\\"\\n cur = conn.cursor()\\n cur.execute(query)\\n queryResult = cur.fetchall()\\n age_seconds = (datetime.datetime.now(\\n timezone.utc) - queryResult[0][0]).seconds\\n cur.close()\\n conn.close()\\n if age_seconds > permissable_maximum_age_secs:\\n print(\\\"Check Sensor, last sample is \\\"+str(age_seconds)+\\\" old\\\")\\n return False\\n else:\\n return True\",\n \"def is_sampling_for_minmax(self):\\n return (self._level_change_time is not None) and \\\\\\n (get_time() - self._level_change_time) < self._duration_in_sec\",\n \"def check_convergency(self):\\n if self.vars['ema_trace'][self.vars['step']] <= self.settings[\\\"emaSpeedTol\\\"]:\\n return True\\n else:\\n return False\",\n \"def extended(self):\\n if self.expires_at:\\n return self.expires_at - self.issued_at > timedelta(days=30)\\n return False\",\n \"def valid(self):\\n delta = datetime.datetime.now() - self._last_access\\n return ((delta.seconds < 7200) and not self.is_empty()) or \\\\\\n (delta.seconds < 60)\",\n \"def __luredWakeupTime(self, suitId):\\n return self.__suitIsLured(suitId) and \\\\\\n self.currentlyLuredSuits[suitId][0] > 0 and \\\\\\n random.randint(0, 99) < \\\\\\n self.currentlyLuredSuits[suitId][2]\",\n \"def epsilon(self, length: int, time: int) -> float:\\n return (self.beta ** (1.0 / (length / 2))) ** time\",\n \"def __exp1_changed_callback(self, ndx):\\n if self.recording_sequence:\\n self.record_sequence()\\n self.exp1_radio.setChecked(True)\\n self.exp1_ifi_select.setCurrentIndex(0)\\n self.camera.set_exposure(ndx, 0)\\n self.rec_seq_button.setEnabled(False)\\n et = np.int(np.round(self.camera.actual_exposure_time_ms))\\n self.write_to_log('Exposure %d ms' % et)\",\n \"def isPeriodTimerEffective(self):\\n return 1\",\n \"def is_dropped(upd_time, time_before):\\n if (upd_time - time_before) / float(Config.BOUNDARY) >= 1.5:\\n return True\\n return False\",\n \"def test_exp():\\n x = np.linspace(-3,3,13)\\n\\n default_use_numexpr = accel_math._USE_NUMEXPR\\n\\n accel_math._USE_NUMEXPR = True\\n r1 = accel_math._exp(x)\\n\\n accel_math._USE_NUMEXPR = False\\n r2 = accel_math._exp(x)\\n\\n np.testing.assert_almost_equal(r1,r2)\\n\\n accel_math._USE_NUMEXPR = default_use_numexpr\",\n \"def isTimeRemaining(self):\\n if self.run_type.startswith('timed'):\\n time_since_start = (time.time() - self.start_times['run'])\\n remaining_time = self.max_time * 60 - time_since_start\\n if remaining_time < 0:\\n return False\\n else:\\n return True\",\n \"def _isBasisDuration(self):\\n invdur = 1/self.getDurationNoDot()\\n if invdur % 1 > 0:\\n return False\\n else:\\n return True\",\n \"def __exp2_changed_callback(self, ndx):\\n if self.recording_sequence:\\n self.record_sequence()\\n self.exp2_radio.setChecked(True)\\n self.exp2_ifi_select.setCurrentIndex(0)\\n self.camera.set_exposure(ndx, 0)\\n self.rec_seq_button.setEnabled(False)\\n et = np.int(np.round(self.camera.actual_exposure_time_ms))\\n self.write_to_log('Exposure %d ms' % et)\",\n \"def exp(self) -> t.Optional[int]:\\n return self.claims.get(\\\"exp\\\")\",\n \"def after(self, time2):\\n return self.to_seconds() > time2.to_seconds()\",\n \"def test_EXPIRY_DURATION(self):\\n self.assertIsInstance(constants.EXPIRY_DURATION, int,\\n \\\"constants.EXPIRY_DURATION must be an integer.\\\")\",\n \"def timedout(self):\\n\\n return self.duration() > self.check.timeout\",\n \"def check_timer(self, wanted_time):\\n if time.time() - self.start_time >= wanted_time:\\n return True\\n return False\",\n \"def test_expand_data_1500_correct_len():\\n # TODO: should it round up to allow last snippet of time?\\n exp = expand_data(log, 1500)\\n assert len(exp) == (log['end'].iloc[-1] / 1500)\",\n \"def isCalibrationExpired(self):\\n return (getI1ProTimeUntilCalibrationExpire() < 200)\",\n \"def hit(self):\\n if self._power == 0 :\\n return False\\n self._power -= 1\\n return True\",\n \"def important_event(time: int) -> bool:\\n last_event = get_events(True)[0]\\n try:\\n time_event = int(last_event.split('\\\\n')[0].strip(\\\"'\\\"))\\n except ValueError:\\n time_event = int(last_event.split('\\\\n')[-1].strip(\\\"'\\\"))\\n if time - time_event < 60:\\n return 'gol' in last_event or 'cartão' in last_event\\n return False\",\n \"def check_expiration(self, cur_time):\\n\\n\\t\\ttime_limit = 1000\\n\\t\\ttime_elapsed = cur_time - self.time_created\\n\\n\\t\\t# Erase cache after an arbitrary amount of time\\n\\t\\tif time_elapsed > time_limit:\\n\\t\\t\\tself.cache_expiration()\",\n \"def is_equidistant(self) -> bool:\\n if len(self.time) < 3:\\n return True\\n return len(self.time.to_series().diff().dropna().unique()) == 1\",\n \"def delta_time(self):\\n delta_time = time.time() - self.time\\n if delta_time >= 1.0 / self.target_fps:\\n self.time = time.time()\\n # end if\\n return delta_time\",\n \"def _check_bullet_cooldown(self):\\n time_now = pygame.time.get_ticks()\\n if time_now - self.last_bullet_fired >= self.bullet_cooldown:\\n self.shoot_disabled = False\",\n \"def _check_goauth_expiration(self, expiry):\\n now = int(time.time())\\n time_left = int(expiry) - now\\n # 10 days\\n min_time_left = 60*60*24*10\\n if time_left < min_time_left:\\n return False\\n else:\\n return True\",\n \"def test_time_supp_length_matches_no_timesteps(self):\\n for no_timesteps in [5, 578, 993, 300072]:\\n for dt in [0.1, 0.5, 3.0]:\\n test_rec = rt.Recording(np.empty([6, no_timesteps, 1]), dt=dt)\\n self.assertEqual(\\n len(test_rec.time_supp),\\n no_timesteps,\\n 'Expected length of time_supp {} to match no_timesteps of '\\n 'input {}.'.format(len(test_rec.time_supp), no_timesteps),\\n )\",\n \"def T_elapsed(T_amount: BlockHeight) -> bool:\\n T_now = getCurrentBlockHeight()\\n return T_now - T_init >= T_amount\",\n \"def exposuretime(self):\\n _, = self.exposuretimes\\n return _\",\n \"def delete_expired(self):\\n check_time = datetime.now()\\n if self.can_expire and self.duration:\\n exp_times = deepcopy(self.exp_times)\\n for key in exp_times:\\n if exp_times[key] < check_time:\\n self.delete(key)\",\n \"def ComputeTimeReward(self, currentTime, expectedTime):\\r\\n return (expectedTime - currentTime) * 1 if currentTime < expectedTime else (expectedTime - currentTime) * 1\",\n \"def is_limited(self) -> bool:\\n return self.__times > ActionState.UNLIMITED\",\n \"def is_exploring(self, step):\\n return np.random.rand() < self._epsilon(step)\",\n \"def test_duration_property(self):\\n recording_dt = 0.1\\n recording_shape = {\\n 'no_timesteps': 1000,\\n 'no_sweeps': 10,\\n 'no_channels': 4,\\n }\\n expected_duration = recording_shape['no_timesteps'] * recording_dt\\n test_rec = rt.Recording(\\n np.zeros(\\n [\\n recording_shape['no_channels'],\\n recording_shape['no_timesteps'],\\n recording_shape['no_sweeps'],\\n ]\\n ),\\n dt=recording_dt,\\n )\\n npt.assert_almost_equal(\\n test_rec.duration,\\n expected_duration,\\n err_msg='Expected {} for `duration` property; got {} instead.'.format(\\n expected_duration, test_rec.duration\\n ),\\n )\",\n \"def rate_limiting(cls):\\n this_click_time = time.time()\\n time_to_last_click = None\\n if cls.last_click_time:\\n time_to_last_click = this_click_time - cls.last_click_time\\n cls.last_click_time = this_click_time\\n return time_to_last_click and time_to_last_click < 0.7\",\n \"def isDefaultedAt(self, time):\\n return time > self.getDefaultTime()\",\n \"def test_fields_effort_time_units_dictionary_success(self, _mock_check):\\n field = EffortField(time_units={\\\"minute\\\": (\\\"minute\\\", \\\"minutes\\\")})\\n\\n errors = field.check()\\n self.assertEqual(len(errors), 0)\",\n \"def excitationPulse(self, time, power):\\n t = time * ns + self.step # Should center at one step before 0\\n if self.step <= 200 * ps: # resolution warrants modelling the pulse\\n width = 200.0 * ps # self.step\\n\\n if t < width * 10: # Only evaulate when the value is significant\\n amp = power / (width * sqrt_2pi) # normalized amplitude\\n value = amp * np.exp(-1.0 * (t) * (t) / (2 * width * width))\\n value = value\\n else:\\n value = 0.0\\n else: # impulsive limit, just dump all the excitons in at t=0\\n # if time >= 0 - self.step/2 and time < 0 + self.step/2:\\n if t > -0.5 * self.step and t <= 0.5 * self.step:\\n value = power / self.step\\n else:\\n value = 0.0\\n return (value*self.step)\",\n \"def metropolis ( delta ):\\n\\n import numpy as np\\n \\n exponent_guard = 75.0\\n\\n if delta > exponent_guard: # Too high, reject without evaluating\\n return False\\n elif delta < 0.0: # Downhill, accept without evaluating\\n return True\\n else:\\n zeta = np.random.rand() # Uniform random number in range (0,1)\\n return np.exp(-delta) > zeta # Metropolis test\",\n \"def is_expired(self):\\n\\n return time.time() * 1000 - self._refreshed_on > self._expire\",\n \"def is_expired(self):\\n return timeutils.utcnow_ts() > self.expire_ts\",\n \"def is_expired(self) -> bool:\\n return now() > self.expires\",\n \"def io_operation(self, time):\\n self._io_time -= time\\n if self._io_time <= 0:\\n self._io = False\\n return True\\n return False\",\n \"def _is_noise(self, t):\\n\\t\\tfor ts in self.noise_itv:\\n\\t\\t\\tif len(ts) == 2:\\n\\t\\t\\t\\ttime1 = ts[0]\\n\\t\\t\\t\\ttime2 = ts[1]\\n\\t\\t\\t\\tif time1 <= t and t <= time2:\\n\\t\\t\\t\\t\\treturn True\\n\\t\\t\\telse:\\n\\t\\t\\t\\tend_time = ts[0]\\n\\t\\t\\t\\tif t >= end_time:\\n\\t\\t\\t\\t\\treturn True\\n\\t\\treturn False\",\n \"def _long_range_normed_exposure_between_bounds(self, time1: float, time2: float) -> _VectorisedFloat:\\n exposure = 0.\\n for start, stop in self.exposed.presence_interval().boundaries():\\n if stop < time1:\\n continue\\n elif start > time2:\\n break\\n elif start <= time1 and time2<= stop:\\n exposure += self.concentration_model.normed_integrated_concentration(time1, time2)\\n elif start <= time1 and stop < time2:\\n exposure += self.concentration_model.normed_integrated_concentration(time1, stop)\\n elif time1 < start and time2 <= stop:\\n exposure += self.concentration_model.normed_integrated_concentration(start, time2)\\n elif time1 <= start and stop < time2:\\n exposure += self.concentration_model.normed_integrated_concentration(start, stop)\\n return exposure\",\n \"def _timeout_request(start_time, request_timeout):\\n return int(round(time() * 1000)) - start_time >= request_timeout\",\n \"def time_until_full(self):\\n if ((datetime.datetime.utcnow() - self.initial_time).total_seconds() \\n > UPDATE_PERIOD\\n and self.space_decay_rate() < 0):\\n secs_until_full = self.available_space() / -self.space_decay_rate() \\n return datetime.timedelta(seconds=secs_until_full)\",\n \"def isFreeTimeExpired(self):\\n assert self.notify.debugStateCall(self, 'loginFSM', 'gameFSM')\\n if self.accountOldAuth:\\n return 0\\n\\n # check for the config overrides\\n # if true, free-time-expired takes precedence over unlimited-free-time\\n if base.config.GetBool(\\\"free-time-expired\\\", 0):\\n return 1\\n if base.config.GetBool(\\\"unlimited-free-time\\\", 0):\\n return 0\\n\\n # -1 == never expires (paid/exempt)\\n if self.freeTimeExpiresAt == -1:\\n return 0\\n\\n # 0 == expired\\n if self.freeTimeExpiresAt == 0:\\n return 1\\n\\n if self.freeTimeExpiresAt < -1:\\n self.notify.warning('freeTimeExpiresAt is less than -1 (%s)' %\\n self.freeTimeExpiresAt)\\n\\n # freeTimeExpiresAt is an epoch time\\n # is it in the past?\\n if self.freeTimeExpiresAt < time.time():\\n return 1\\n else:\\n return 0\",\n \"def is_expired(self):\\n if self.access_token is None:\\n logging.debug('Access token not found')\\n return True\\n else:\\n return (self.expiration <= datetime.now())\",\n \"def checkGracePeriodDuration(self):\\n if (not self.isInGraceInvulnerability):\\n return\\n if (time.time()-self.gracePeriodStartTime > shipDamagedInvulerabilityGracePeriodLength):\\n #if the grace period is over...\\n self.disableGracePeriod()\",\n \"def _is_percent_of_time(percent_of_time):\\n assert 0 <= percent_of_time\\n assert percent_of_time <= 100\\n random_number = random.uniform(0, 100)\\n return random_number <= percent_of_time\",\n \"def _safe_limit_check(self):\\n if self.rem == 40:\\n self.time_start = time.time()\\n elif time.time() - self.time_start >= 11:\\n self.rem = 40\\n self.time_start = time.time()\\n elif self.rem <= 0:\\n t = 11 - (time.time() - self.time_start)\\n\\n if t <= 0:\\n self.rem = 40\\n self.time_start = time.time()\\n else:\\n if self.policy == Limit.Sleep:\\n time.sleep(t)\\n elif self.policy == Limit.Ignore:\\n return False\\n\\n self.rem -= 1\\n return True\",\n \"def close_to_exceeding(self) -> bool:\\n mean = self.current / self.num_cuts\\n if self.max_frames is not None:\\n return self.current + mean > self.max_frames\\n if self.max_samples is not None:\\n return self.current + mean > self.max_samples\\n if self.max_duration is not None:\\n return self.current + mean > self.max_duration\\n return False\",\n \"def expired(self):\\n return int(time.time()) > self.expires_at\",\n \"def __checkTimer(self):\\n if self.__endTime is None:\\n raise AssertionError('The end time had not been set.')\\n if time.time() > self.__endTime:\\n self._logError('Maximum Run Time Reached !!')\\n raise _MaxRunTimeReachedError('')\",\n \"def tune_exposure_time(camera, target, initial_exptime, min_exptime=0, max_exptime=None,\\n max_steps=5, tolerance=0.1, cutout_size=256, bias=None, **kwargs):\\n camera.logger.info(f\\\"Tuning exposure time for {camera}.\\\")\\n\\n images_dir = camera.get_config(\\\"directories.images\\\", None)\\n if images_dir:\\n images_dir = os.path.join(images_dir, \\\"temp\\\")\\n os.makedirs(images_dir, exist_ok=True)\\n\\n # Parse quantities\\n initial_exptime = get_quantity_value(initial_exptime, \\\"second\\\") * u.second\\n\\n if min_exptime is not None:\\n min_exptime = get_quantity_value(min_exptime, \\\"second\\\") * u.second\\n if max_exptime is not None:\\n max_exptime = get_quantity_value(max_exptime, \\\"second\\\") * u.second\\n\\n try:\\n bit_depth = camera.bit_depth.to_value(\\\"bit\\\")\\n except NotImplementedError:\\n bit_depth = 16\\n\\n saturated_counts = 2 ** bit_depth\\n\\n prefix = images_dir if images_dir is None else images_dir + \\\"/\\\"\\n with tempfile.NamedTemporaryFile(suffix=\\\".fits\\\", prefix=prefix, delete=False) as tf:\\n\\n exptime = initial_exptime\\n\\n for step in range(max_steps):\\n\\n # Check if exposure time is within valid range\\n if (exptime == max_exptime) or (exptime == min_exptime):\\n break\\n\\n # Get an image\\n cutout = camera.get_cutout(exptime, tf.name, cutout_size, keep_file=False, **kwargs)\\n cutout = cutout.astype(\\\"float32\\\")\\n if bias is not None:\\n cutout -= bias\\n\\n # Measure average counts\\n normalised_counts = np.median(cutout) / saturated_counts\\n\\n camera.logger.debug(f\\\"Normalised counts for {exptime} exposure on {camera}:\\\"\\n f\\\" {normalised_counts}\\\")\\n\\n # Check if tolerance condition is met\\n if tolerance:\\n if abs(normalised_counts - target) < tolerance:\\n break\\n\\n # Update exposure time\\n exptime = exptime * target / normalised_counts\\n if max_exptime is not None:\\n exptime = min(exptime, max_exptime)\\n if min_exptime is not None:\\n exptime = max(exptime, min_exptime)\\n\\n camera.logger.info(f\\\"Tuned exposure time for {camera}: {exptime}\\\")\\n\\n return exptime\",\n \"def _check_pulse(self):\\n timedelta = time.time() - self.heartbeat\\n update_delay = float(1/self.qbpm.frequency)\\n time_to_update = False\\n if timedelta > update_delay:\\n time_to_update = True\\n self.heartbeat = time.time()\\n return time_to_update\",\n \"def testStretchedExpData(nTimes = 1000, beta = 0.5, sigma = 0.05, linear=False):\\n\\n if linear:\\n Times = rangeLin(1.0e-3, 1.0e+3, nTimes) # in seconds\\n else:\\n Times = rangeLog(1.0e-3, 1.0e+3, nTimes) # in seconds\\n\\n Data = np.exp(-1.*(Times**beta))\\n Data += sigma*np.random.randn( len(Data) )\\n\\n return Times, Data\",\n \"def expired(self) -> bool:\\n if not self.use_wts:\\n return False\\n\\n return datetime.now() > self.expire\",\n \"def is_over(self, time):\\n over = (not self.enable_loop()) and (time >= self.get_duration())\\n return over\",\n \"def sanity_check(self):\\n res = True\\n res = res and self.detected\\n res = res and np.sum(self.diffs) < 30000 # experimental value\\n return res\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6262144","0.6255858","0.6163135","0.61418873","0.5915087","0.5863674","0.5856211","0.57416385","0.55517083","0.5540617","0.55379456","0.5453827","0.5453151","0.54436797","0.5430154","0.5369838","0.5325574","0.5313959","0.5313157","0.53118265","0.5288747","0.52797335","0.5260478","0.5257042","0.52416027","0.51850665","0.5179103","0.5174016","0.5171707","0.51668525","0.5157539","0.51347667","0.51273763","0.50815827","0.5079341","0.5075893","0.5067881","0.5054975","0.50516963","0.504854","0.5042227","0.50301766","0.5020313","0.50202614","0.501119","0.5011094","0.5005053","0.5001828","0.5001057","0.49995127","0.49883458","0.49882838","0.4983302","0.49812782","0.4975712","0.49748138","0.49719593","0.4971577","0.4961053","0.4960821","0.4955817","0.4934189","0.4920372","0.49197683","0.49140066","0.49114564","0.4909697","0.4906464","0.48975718","0.48962536","0.4889649","0.48894712","0.48854095","0.48846924","0.48666143","0.4862617","0.48583996","0.4856517","0.48520264","0.48464453","0.48449537","0.48434305","0.48421896","0.4840959","0.48378775","0.48365378","0.483607","0.48342377","0.48322853","0.48285756","0.48283836","0.4827491","0.48272526","0.4824871","0.4823129","0.48221514","0.4821971","0.4820364","0.48164126","0.4811015","0.47907817"],"string":"[\n \"0.6262144\",\n \"0.6255858\",\n \"0.6163135\",\n \"0.61418873\",\n \"0.5915087\",\n \"0.5863674\",\n \"0.5856211\",\n \"0.57416385\",\n \"0.55517083\",\n \"0.5540617\",\n \"0.55379456\",\n \"0.5453827\",\n \"0.5453151\",\n \"0.54436797\",\n \"0.5430154\",\n \"0.5369838\",\n \"0.5325574\",\n \"0.5313959\",\n \"0.5313157\",\n \"0.53118265\",\n \"0.5288747\",\n \"0.52797335\",\n \"0.5260478\",\n \"0.5257042\",\n \"0.52416027\",\n \"0.51850665\",\n \"0.5179103\",\n \"0.5174016\",\n \"0.5171707\",\n \"0.51668525\",\n \"0.5157539\",\n \"0.51347667\",\n \"0.51273763\",\n \"0.50815827\",\n \"0.5079341\",\n \"0.5075893\",\n \"0.5067881\",\n \"0.5054975\",\n \"0.50516963\",\n \"0.504854\",\n \"0.5042227\",\n \"0.50301766\",\n \"0.5020313\",\n \"0.50202614\",\n \"0.501119\",\n \"0.5011094\",\n \"0.5005053\",\n \"0.5001828\",\n \"0.5001057\",\n \"0.49995127\",\n \"0.49883458\",\n \"0.49882838\",\n \"0.4983302\",\n \"0.49812782\",\n \"0.4975712\",\n \"0.49748138\",\n \"0.49719593\",\n \"0.4971577\",\n \"0.4961053\",\n \"0.4960821\",\n \"0.4955817\",\n \"0.4934189\",\n \"0.4920372\",\n \"0.49197683\",\n \"0.49140066\",\n \"0.49114564\",\n \"0.4909697\",\n \"0.4906464\",\n \"0.48975718\",\n \"0.48962536\",\n \"0.4889649\",\n \"0.48894712\",\n \"0.48854095\",\n \"0.48846924\",\n \"0.48666143\",\n \"0.4862617\",\n \"0.48583996\",\n \"0.4856517\",\n \"0.48520264\",\n \"0.48464453\",\n \"0.48449537\",\n \"0.48434305\",\n \"0.48421896\",\n \"0.4840959\",\n \"0.48378775\",\n \"0.48365378\",\n \"0.483607\",\n \"0.48342377\",\n \"0.48322853\",\n \"0.48285756\",\n \"0.48283836\",\n \"0.4827491\",\n \"0.48272526\",\n \"0.4824871\",\n \"0.4823129\",\n \"0.48221514\",\n \"0.4821971\",\n \"0.4820364\",\n \"0.48164126\",\n \"0.4811015\",\n \"0.47907817\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":4,"numItemsPerPage":100,"numTotalItems":95772,"offset":400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3MzUyMTk5NSwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzM1MjU1OTUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.0CsekaW_6aNR_IXN25Vbr4J0G5Fo9dnTBYzv_88JmvUr1XyEj3ZjkEdBuR96FFWch4dletKGMFp2cUYchArYAA","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 |
|---|---|---|---|---|---|---|
Initializes indicating root Python module. The application will look for all `Resource` classes defined in the given root module. | def __init__(self, root):
self._root = root
if not self.get_resources():
raise Exception('Your application has no Resource.') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, basedir=None):\n # ------------------------------------------------------------------------\n super(Resources, self).__init__()\n self.xInitialize(basedir or \"resources\")",
"def __init__(self):\n self.modules = {}",
"def init(self):\n\n self.loaded = False\n ... | [
"0.6172543",
"0.6130026",
"0.58406955",
"0.5820272",
"0.5808664",
"0.56877095",
"0.5673514",
"0.5664736",
"0.5635875",
"0.561636",
"0.5615964",
"0.559234",
"0.5569267",
"0.5522192",
"0.5514438",
"0.5474632",
"0.54634255",
"0.54632753",
"0.5462733",
"0.54501873",
"0.5443123",
... | 0.7221802 | 0 |
Starts WSGI application flow. | def __call__(self, environ, start_response):
middleware = Middleware(environ, start_response)
middleware.application = self
return middleware | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\r\n run_wsgi_app(app)",
"def main():\n run_wsgi_app(APP)",
"def start():\n from paste.deploy import loadapp, loadserver\n from moksha.config.environment import load_environment\n from moksha.config.middleware import make_app\n ini = 'config:' + path('development.ini').abspath()\n ... | [
"0.79540753",
"0.77699536",
"0.72703",
"0.7218581",
"0.7189519",
"0.71686983",
"0.7069771",
"0.70377684",
"0.70257485",
"0.6954285",
"0.69124424",
"0.6888019",
"0.6877595",
"0.68580186",
"0.68424517",
"0.677765",
"0.66754097",
"0.66459525",
"0.6637033",
"0.6628596",
"0.662671... | 0.0 | -1 |
Sinusoid position encoding table | def get_sinusoid_encoding_table(n_position, d_hid, padding_idx=None):
def cal_angle(position, hid_idx):
return position / np.power(10000, 2 * (hid_idx // 2) / d_hid)
def get_posi_angle_vec(position):
return [cal_angle(position, hid_j) for hid_j in range(d_hid)]
sinusoid_table = np.array(
[get_posi_angle_vec(pos_i) for pos_i in range(n_position)]
)
sinusoid_table[:, 0::2] = np.sin(sinusoid_table[:, 0::2]) # dim 2i
sinusoid_table[:, 1::2] = np.cos(sinusoid_table[:, 1::2]) # dim 2i+1
if padding_idx is not None:
# zero vector for padding dimension
sinusoid_table[padding_idx] = 0.0
return torch.FloatTensor(sinusoid_table) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_sinusoid_encoding_table(self, n_position, d_hid):\n denominator = torch.Tensor([\n 1.0 / np.power(10000, 2 * (hid_j // 2) / d_hid)\n for hid_j in range(d_hid)\n ])\n denominator = denominator.view(1, -1)\n pos_tensor = torch.arange(n_position).unsqueeze(-1... | [
"0.7326898",
"0.72803426",
"0.66477567",
"0.6008105",
"0.6005823",
"0.59894025",
"0.56817",
"0.5652626",
"0.56051815",
"0.5601691",
"0.5469565",
"0.5458949",
"0.5339877",
"0.53386784",
"0.53131545",
"0.5309653",
"0.52948576",
"0.52931553",
"0.52630687",
"0.5255187",
"0.524431... | 0.6543115 | 3 |
Process data and return preprocessor instance | def process_data(self, clip_name) -> Preprocessor:
config: Config = Config.get_config()
folder_name = config.video_data
video_data_file = ''.join(clip_name.split('.')[:-1]) + '.json'
video = Video.from_json(os.path.join(folder_name, video_data_file))
# Convert to usable data type period_running_person division, alle fragment soorten
preprocessor = Preprocessor(video)
return preprocessor | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess(self,data):\n preprocessObj = PreprocessData()\n preprocess_data = preprocessObj.preprocess(data)\n return preprocess_data",
"def preprocess(data):\n raise NotImplementedError",
"def main():\n p = DataPreprocessor()\n p.preprocess_and_save_data(p.path_to_file)",
"... | [
"0.69076425",
"0.66020375",
"0.64183813",
"0.62324464",
"0.61948276",
"0.6038848",
"0.59573555",
"0.5956903",
"0.5925527",
"0.5921275",
"0.59206593",
"0.5867471",
"0.58528507",
"0.5809913",
"0.5783746",
"0.5756985",
"0.5732583",
"0.5712453",
"0.57105845",
"0.56719923",
"0.566... | 0.6266177 | 3 |
Function to construct all plottable files. In principle to be used for visualisation. | def get_plottables(self, period_person_division, running_person_identifiers, running_fragments, turning_fragments):
period_running_person_division = {period: {person: coords for person,
coords in period_dictionary.items() if
person in running_person_identifiers}
for period, period_dictionary in period_person_division.items()}
running_plottables = {
period: {person: coords for person, coords in period_dictionary.items() if person in running_person_identifiers}
for period, period_dictionary in period_person_division.items() if
any(lower <= period <= upper for (lower, upper) in running_fragments)}
turning_plottables = {
period: {person: coords for person, coords in period_dictionary.items() if person in running_person_identifiers}
for period, period_dictionary in period_person_division.items() if
any(lower <= period <= upper for (lower, upper) in turning_fragments)}
period_running_person_division = dict(filter(lambda x: x[1] != {}, period_running_person_division.items()))
running_plottables = dict(filter(lambda x: x[1] != {}, running_plottables.items()))
turning_plottables = dict(filter(lambda x: x[1] != {}, turning_plottables.items()))
return period_running_person_division, running_plottables, turning_plottables | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_html(self, workdir, templatePath, imgFormat):\n plot_tables = []\n plot_set = [ self._expectedPlots_globalAvg, self._expectedPlots_Nino, self._expectedPlots_transportDiags ]\n\n # build up the plot_tables array\n for k in range(len(plot_set)):\n plot_table = []\n ... | [
"0.6867469",
"0.6389346",
"0.63584435",
"0.63152426",
"0.6292773",
"0.6279732",
"0.62315065",
"0.6176681",
"0.6134976",
"0.6134058",
"0.6121338",
"0.6118336",
"0.6118336",
"0.60832316",
"0.6075302",
"0.60436225",
"0.6041428",
"0.6038445",
"0.59721166",
"0.5969328",
"0.5969005... | 0.0 | -1 |
Initialize function which will be called to create the base frame upon which the animation takes place. This is used for blitting to create smoother animations | def func_init(self):
self.points.set_data([], [])
for line in self.lines:
line.set_data([],[])
self.annotation.set_text('')
return tuple(self.lines) + (self.points, self.annotation) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_frame(self : \"animation\",\n init_frame : \"matplotlib.figure.Figure\",\n init_ax : \"matplotlib.axes._subplots.AxesSubplot\"\n ):\n self._cframe = init_frame.canvas.copy_from_bbox(init_ax.bbox)",
"def _init_anim(self):\n pass",
... | [
"0.723336",
"0.72250724",
"0.70384264",
"0.70372236",
"0.6962778",
"0.69174445",
"0.6851278",
"0.6720123",
"0.6609182",
"0.6556792",
"0.65386903",
"0.65386903",
"0.65386903",
"0.65386903",
"0.6523569",
"0.64849484",
"0.64721674",
"0.6449021",
"0.64271384",
"0.64042795",
"0.64... | 0.0 | -1 |
Function that is used by matplotlib.animation.FuncAnimation to iteratively plot given a frame | def plot_person(self, frame, plottables, image_h, image_w, zoom=True, pad=3):
for person in plottables[frame].keys():
plot_coords = plottables[frame][person]
plot_coords[:, 1] = plot_coords[:, 1] + image_h
coord_dict = {key: value for key, value in dict(enumerate(plot_coords[:, :2])).items() if
not (value == 0).any()}
present_keypoints = set(coord_dict.keys())
present_connections = [connection for connection in self.connections if
len(present_keypoints & set(connection)) == 2]
plot_lines = [np.transpose([coord_dict[a], coord_dict[b]]) for a, b in present_connections]
for coords, line in zip_longest(plot_lines, self.lines):
if isinstance(coords, np.ndarray):
line.set_data(coords[0],coords[1])
else:
line.set_data([],[])
plot_coords = plot_coords[~(plot_coords == 0).any(axis=1)]
self.points.set_data(plot_coords[:, 0], plot_coords[:, 1])
self.annotation.set_text('Frame: {}'.format(frame))
self.ax.set_xlabel('X coordinate')
self.ax.set_ylabel('Y coordinate')
if zoom:
aspect = image_w / image_h
xlow, xhigh = plot_coords[:, 0].min(), plot_coords[:, 0].max() # get x higher and lower limit
xdiff = xhigh - xlow # calculate the total range of x
xpad = ((self.ydiff * aspect) - xdiff) / 2 # calculate how much the xlimits should be padded on either side to set aspect ratio correctly
self.ax.set_xlim(xlow - xpad, xhigh + xpad) # set new limits
break
return tuple(self.lines) + (self.points, self.annotation) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def animate(i):\r\n plot_x.set_data(history_samples[i][:, 0], history_samples[i][:, 1])",
"def run_animation(self):\n\n def _get_frame(frame_index, plots):\n \"\"\" Should be called by run_animations only. \"\"\"\n\n # TODO Using the indices of the self.frames, plot in correct loc... | [
"0.70611054",
"0.69869083",
"0.6971987",
"0.689324",
"0.68860537",
"0.6854017",
"0.68523353",
"0.65770304",
"0.65645885",
"0.6556076",
"0.65512234",
"0.6524661",
"0.6517934",
"0.65143037",
"0.6452433",
"0.64289904",
"0.64282256",
"0.6403286",
"0.6378409",
"0.63592017",
"0.624... | 0.0 | -1 |
Complete pipeline to process and plot data. | def run_animation(self, clip_name, fragment, zoom=True, pad=3, interval=100):
preprocessor = self.process_data(clip_name)
period_person_division = preprocessor.period_person_division
running_person_identifiers = preprocessor.get_running_person_identifiers()
running_fragments = preprocessor.get_running_fragments()
turning_fragments = preprocessor.get_turning_fragments()
period_running_person_division, running_plottables, turning_plottables = self.get_plottables(period_person_division, running_person_identifiers, running_fragments, turning_fragments)
if fragment == 'run':
plottables = running_plottables
elif fragment == 'turn':
plottables = turning_plottables
else:
plottables = period_running_person_division
self.set_axis_limits(plottables, preprocessor.height, preprocessor.width, zoom=zoom, pad=pad)
animate = animation.FuncAnimation(fig=self.fig, func=self.plot_person, frames=plottables.keys(), fargs=(plottables,
preprocessor.height, preprocessor.width, zoom, pad), interval=interval, init_func=self.func_init, blit=False, repeat=False)
plt.show() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n self.set_pipeline()\n self.pipeline.fit(self.X, self.y)",
"def main():\n df_data = import_clean_process()\n plot_data_matplotlib(df_data)\n return",
"def pipeline_finished(self, pipeline):\n\n # Get the sizes of all output adios files\n self._get_adios_meta... | [
"0.6797422",
"0.67031926",
"0.63262737",
"0.62594944",
"0.6251043",
"0.62087804",
"0.61756724",
"0.61126584",
"0.61017734",
"0.60401547",
"0.59446293",
"0.59367925",
"0.592344",
"0.5875977",
"0.58692324",
"0.5868876",
"0.5862814",
"0.5774588",
"0.5762678",
"0.5713469",
"0.569... | 0.0 | -1 |
Initializes the dataset for loading. | def __init__(
self, train_batch_size=1, val_batch_size=1, cuda=False,
num_workers=1, path=None, random_resize_crop=(0, 0),
scale=(0, 0), horizontal_flip_prob=0.0, vertical_flip_prob=0.0,
gaussian_blur_prob=0.0, rotate_degree=0.0, cutout_prob=0.0,
cutout_dim=(8, 8), hue_saturation_prob=0.0, contrast_prob=0.0
):
self.cuda = cuda
self.num_workers = num_workers
self.path = path
self.train_batch_size = train_batch_size
self.val_batch_size = val_batch_size
self.sampler = None
if not os.path.exists(self.path):
raise ValueError('Invalid path specified.')
# Set data augmentation parameters
self.random_resize_crop = random_resize_crop
self.scale = scale
self.horizontal_flip_prob = horizontal_flip_prob
self.vertical_flip_prob = vertical_flip_prob
self.gaussian_blur_prob = gaussian_blur_prob
self.rotate_degree = rotate_degree
self.cutout_prob = cutout_prob
self.cutout_dim = cutout_dim
self.hue_saturation_prob = hue_saturation_prob
self.contrast_prob = contrast_prob
# Get dataset statistics
self.image_size = self._get_image_size()
self.mean = self._get_mean()
self.std = self._get_std()
# Get data
self._split_data() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_al_dataset(self):\n\n self._init_dataset()\n\n train_dataset = self.datasets['train']\n\n dataset_size = len(train_dataset)\n self.budget = math.ceil(self.budget_frac*dataset_size)\n Sampler.__init__(self, config, self.budget) # TODO: Weird place to initialise this\... | [
"0.76784205",
"0.757365",
"0.7362059",
"0.7325153",
"0.7320442",
"0.72897947",
"0.720113",
"0.7199336",
"0.7177944",
"0.7079859",
"0.705883",
"0.7033235",
"0.7033188",
"0.6956903",
"0.69027686",
"0.6867748",
"0.68586814",
"0.6850223",
"0.68302983",
"0.6828051",
"0.6822883",
... | 0.0 | -1 |
Split data into training and validation set. | def _split_data(self):
# Set training data
self.train_data = torchvision.datasets.ImageFolder(
os.path.join(self.path, 'train'),
transform=self._transform()
)
self.classes = self.train_data.classes
# Set validation data
self.val_data = torchvision.datasets.ImageFolder(
os.path.join(self.path, 'test'),
transform=self._transform(train=False)
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split_data_into_training_and_validation(self, data):\n training_dataset = self.get_data_from_indices(data, np.arange(self.num_training_samples))\n validation_dataset = self.get_data_from_indices(data, np.arange(self.num_training_samples,\n ... | [
"0.8642924",
"0.83752245",
"0.8353596",
"0.8348435",
"0.81380725",
"0.80903614",
"0.8082711",
"0.7984082",
"0.7881793",
"0.78108215",
"0.7794041",
"0.76179",
"0.761665",
"0.7565056",
"0.75570375",
"0.7532845",
"0.75105983",
"0.75036824",
"0.7495741",
"0.7445284",
"0.7443028",... | 0.7568678 | 13 |
Return shape of data i.e. image size. | def _get_image_size(self):
return (3, 224, 224) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def image_shape(self):\n return self.data.shape[:2]",
"def image_shape(self):\n return self.data.shape[:2]",
"def shape(self):\n return self.data.shape",
"def shape(self):\n return self.data.shape",
"def shape(self):\n return self.data.shape",
"def shape(self):\n ... | [
"0.82124084",
"0.82124084",
"0.8147183",
"0.8147183",
"0.8147183",
"0.8147183",
"0.8147183",
"0.80937505",
"0.8010233",
"0.8006064",
"0.8006064",
"0.8006064",
"0.80019945",
"0.79247403",
"0.79092556",
"0.78679425",
"0.786282",
"0.7814866",
"0.7725889",
"0.76113486",
"0.75898"... | 0.0 | -1 |
Returns mean of the entire dataset. | def _get_mean(self):
return (0.485, 0.456, 0.406) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean(self):\r\n return np.mean(self.data_array)",
"def mean(self):\n return self.data.mean(axis=-1, keepdims=True)",
"def mean(self):\n return self.aggregate(np.mean)",
"def Mean(data):\n return data.mean()",
"def mean(self):\n mean = sum(self.data)/self.size\n ret... | [
"0.82411206",
"0.8131355",
"0.8031648",
"0.8015793",
"0.79474837",
"0.7917345",
"0.7879034",
"0.78769094",
"0.7875092",
"0.78153133",
"0.76866186",
"0.767841",
"0.7648848",
"0.7648848",
"0.75604665",
"0.7517856",
"0.74952906",
"0.7446794",
"0.7446794",
"0.7446794",
"0.7443946... | 0.0 | -1 |
Returns standard deviation of the entire dataset. | def _get_std(self):
return (0.229, 0.224, 0.225) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_std_dev(self, data):\n mean = 0\n data_arr = []\n for i in data:\n data_arr.append(i[1])\n return statistics.stdev(data_arr)",
"def get_stddev(self):\r\n for i in range(1,len(self.data[0])):\r\n self.stddev.append(np.std(self.data[:,i]))",
... | [
"0.84144866",
"0.82050383",
"0.8168596",
"0.8070408",
"0.7985524",
"0.796877",
"0.79068154",
"0.78719604",
"0.78662646",
"0.7861871",
"0.7861871",
"0.7852831",
"0.78476846",
"0.7799383",
"0.77913153",
"0.7748432",
"0.7714268",
"0.7689626",
"0.76288074",
"0.76285523",
"0.76158... | 0.0 | -1 |
Return data based on train mode. | def data(self, train=True):
data = self.train_data if train else self.val_data
return data.data, data.targets | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data_train(self):\n return self.get_data(self.file_train, self.batch)",
"def get_train_data():\n # train set\n train = pd.read_csv(\"train.csv\")\n\n return train",
"def getTrainingData(self):\n raise NotImplementedError",
"def train_data(self):\n return self._train_data... | [
"0.71724296",
"0.70787793",
"0.7011355",
"0.6915143",
"0.67346495",
"0.6732012",
"0.66541547",
"0.66510093",
"0.66510093",
"0.66229326",
"0.6598379",
"0.658925",
"0.6583259",
"0.65264785",
"0.6473328",
"0.645411",
"0.6418035",
"0.6416727",
"0.6339897",
"0.6322232",
"0.6320401... | 0.6745248 | 4 |
Unnormalize a given image. | def unnormalize(self, image, transpose=False):
return unnormalize(image, self.mean, self.std, transpose) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalise(image):",
"def normalize_image(img):\n arr = np.array(img)\n new_img = Image.fromarray(normalize(arr).astype('uint8'),'L')\n return new_img",
"def reverse_normalize(image):\n\n reverse = transforms.Normalize(mean=[-0.485 / 0.229, -0.456 / 0.224, -0.406 / 0.255],\n ... | [
"0.78914344",
"0.76616216",
"0.7482308",
"0.7246689",
"0.7187682",
"0.71326315",
"0.71250784",
"0.69919527",
"0.6929422",
"0.6927052",
"0.6911609",
"0.6908462",
"0.6908327",
"0.69034034",
"0.6890873",
"0.6881274",
"0.6876974",
"0.68578804",
"0.6824972",
"0.68119633",
"0.67838... | 0.7967136 | 0 |
Normalize a given image. | def normalize(self, image, transpose=False, data_type=None):
return normalize(image, self.mean, self.std, transpose) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalise(image):",
"def normalize(image):\n min = np.min(image)\n max = np.max(image)\n normalImg = 255*(image - min) / (max - min)\n return normalImg",
"def normalize_image(img):\n min_, max_ = float(np.min(img)), float(np.max(img))\n return (img - min_) / (max_ - min_)",
"def normali... | [
"0.82951486",
"0.8158422",
"0.81137586",
"0.8056085",
"0.8043467",
"0.80207026",
"0.79855645",
"0.79698676",
"0.79609406",
"0.79318285",
"0.79120314",
"0.78832763",
"0.78212625",
"0.7805976",
"0.78015596",
"0.77725065",
"0.77711695",
"0.77530694",
"0.77530694",
"0.774932",
"0... | 0.73125774 | 39 |
Handle imbalanced dataset through sampler. | def create_class_imbalance_sampler(self):
count = [0] * len(self.classes)
for item in self.train_data.imgs:
count[item[1]] += 1
weight_per_class = [0.] * len(self.classes)
for i in range(len(self.classes)):
weight_per_class[i] = float(sum(count)) / float(count[i])
weights = [0] * len(self.train_data.imgs)
for idx, val in enumerate(self.train_data.imgs):
weights[idx] = weight_per_class[val[1]]
weights = torch.DoubleTensor(weights)
self.sampler = torch.utils.data.sampler.WeightedRandomSampler(
weights, len(weights)
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def balanced_sampling(dat: pd.DataFrame, logger=None):\n if logger == None:\n logging.basicConfig(\n level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n logger = logging.getLogger(__name__)\n \n \n # upsampling\n logger.info('Start balanced s... | [
"0.62204057",
"0.61685914",
"0.5826256",
"0.5715278",
"0.5707387",
"0.5623797",
"0.561231",
"0.55672514",
"0.5549182",
"0.54543215",
"0.5443967",
"0.5442228",
"0.5435967",
"0.54301053",
"0.5364784",
"0.53321433",
"0.53314674",
"0.5326067",
"0.5314146",
"0.5309174",
"0.5304186... | 0.6245745 | 0 |
Load user with specified user ID. | def load_user(user_id):
return User.query.get(int(user_id)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_user(user_id):\n return User.get_by_id(int(user_id))",
"def load_user(user_id):\n return User.get_by_id(int(user_id))",
"def load_user(user_id):\n return User.get_by_id(int(user_id))",
"def load_user(user_id):\r\n return User.query.get(int(user_id))",
"def load_user(id):\n return Us... | [
"0.8794154",
"0.8794154",
"0.8794154",
"0.86955374",
"0.8691932",
"0.8611956",
"0.857735",
"0.8548633",
"0.8518415",
"0.8518415",
"0.8510647",
"0.8510647",
"0.8510647",
"0.8510647",
"0.8504149",
"0.84574586",
"0.8455236",
"0.84108514",
"0.83591974",
"0.8340407",
"0.83372307",... | 0.8645434 | 10 |
Get the selected locale from user settings. | def get_locale():
setting = Setting.query.filter(Setting.name == 'default_language').first()
if setting is not None:
return setting.value
# Return default language when none found
return 'en' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_locale():\n localLang = request.args.get('locale')\n supportLang = app.config['LANGUAGES']\n if localLang in supportLang:\n return localLang\n userId = request.args.get('login_as')\n if userId:\n localLang = users[int(userId)]['locale']\n if localLang in supportLang:\n ... | [
"0.7412174",
"0.7108176",
"0.69538045",
"0.69421023",
"0.68359756",
"0.67491263",
"0.67384523",
"0.6731309",
"0.650032",
"0.63808835",
"0.6361166",
"0.63441944",
"0.63441944",
"0.6340159",
"0.62725174",
"0.61259097",
"0.6097418",
"0.6096102",
"0.60663605",
"0.60374147",
"0.60... | 0.73380387 | 1 |
Jinja2 filter to slugify text. | def slug(value):
return slugify(value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def slugified(text):\n return re.sub(\"-+\", \"-\", re.sub(r\"\\W\", \"-\", text.lower()))",
"def slugify(text: str) -> str:\n return text.strip().replace(', ', '-').replace(' ', '_').lower()",
"def slugify(text):\n concatenated = re.sub('\\s+', '-', text.lower())\n return re.sub('[^A-Za-z0-9_-]', ... | [
"0.7214419",
"0.71937776",
"0.70771027",
"0.6860676",
"0.6856058",
"0.6818637",
"0.68092954",
"0.67907774",
"0.6787663",
"0.67330647",
"0.67148125",
"0.66974",
"0.66480976",
"0.6628109",
"0.6619934",
"0.6606258",
"0.6593922",
"0.6590047",
"0.6588239",
"0.65801233",
"0.6554873... | 0.7127615 | 2 |
Jinja2 filter to get language object from language code. | def language_name(value):
return pycountry.languages.get(alpha_2=value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_lang(context, field):\n lang = json.load(open(\"json/lang.json\", \"r\"))\n conf = json.load(open(\"json/serverconfig.json\", \"r\"))\n return lang[conf[str(context)][\"lang\"]][field]",
"def language_code(self) -> str:\n return pulumi.get(self, \"language_code\")",
"def get_language(se... | [
"0.6488083",
"0.6458506",
"0.64521635",
"0.6425052",
"0.6333819",
"0.63314784",
"0.62535805",
"0.6156458",
"0.61025834",
"0.60967314",
"0.60901237",
"0.60439485",
"0.602857",
"0.60120213",
"0.59964323",
"0.5989398",
"0.5981419",
"0.5978724",
"0.59718126",
"0.59527946",
"0.593... | 0.6110068 | 8 |
Decodes a Base58Check encoded key. | def from_b58check(key):
return HDKey.from_bytes(base58.b58decode_check(key))[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def base58_decode(v: bytes) -> bytes:\n try:\n prefix_len = next(\n len(encoding[2])\n for encoding in base58_encodings\n if len(v) == encoding[1] and v.startswith(encoding[0])\n )\n except StopIteration:\n raise ValueError('Invalid encoding, prefix or le... | [
"0.65961087",
"0.6403686",
"0.6391344",
"0.63413113",
"0.6321229",
"0.6299899",
"0.61630493",
"0.6157103",
"0.61495435",
"0.60469747",
"0.600818",
"0.59588367",
"0.5914103",
"0.5791583",
"0.57892734",
"0.5774782",
"0.5729094",
"0.5713923",
"0.5695626",
"0.5672472",
"0.5671971... | 0.74329513 | 0 |
Generates either a HDPrivateKey or HDPublicKey from the underlying bytes. | def from_bytes(b):
if len(b) < 78:
raise ValueError("b must be at least 78 bytes long.")
version = int.from_bytes(b[:4], 'big')
depth = b[4]
parent_fingerprint = b[5:9]
index = int.from_bytes(b[9:13], 'big')
chain_code = b[13:45]
key_bytes = b[45:78]
rv = None
if version == HDPrivateKey.MAINNET_VERSION or version == HDPrivateKey.TESTNET_VERSION:
if key_bytes[0] != 0:
raise ValueError("First byte of private key must be 0x00!")
private_key = int.from_bytes(key_bytes[1:], 'big')
rv = HDPrivateKey(key=private_key,
chain_code=chain_code,
index=index,
depth=depth,
parent_fingerprint=parent_fingerprint)
elif version == HDPublicKey.MAINNET_VERSION or version == HDPublicKey.TESTNET_VERSION:
if key_bytes[0] != 0x02 and key_bytes[0] != 0x03:
raise ValueError("First byte of public key must be 0x02 or 0x03!")
public_key = PublicKey.from_bytes(key_bytes)
rv = HDPublicKey(x=public_key.point.x,
y=public_key.point.y,
chain_code=chain_code,
index=index,
depth=depth,
parent_fingerprint=parent_fingerprint)
else:
raise ValueError("incorrect encoding.")
return (rv, b[78:]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_ecdh_key_pair() -> tuple[X25519PrivateKey, bytes]:\n private_key = X25519PrivateKey.generate()\n public_key_raw = private_key.public_key().public_bytes(\n serialization.Encoding.Raw, serialization.PublicFormat.Raw\n )\n return private_key, public_key_raw",
"def mk_keyobj_from_priv... | [
"0.6803569",
"0.6298475",
"0.6296541",
"0.61843973",
"0.6125002",
"0.6038086",
"0.6034926",
"0.6032014",
"0.6002514",
"0.5997152",
"0.598115",
"0.59766436",
"0.59530914",
"0.59374905",
"0.59370124",
"0.5930606",
"0.588195",
"0.5862614",
"0.5829133",
"0.5813407",
"0.58064556",... | 0.7741583 | 0 |
Whether or not this is a master node. | def master(self):
return self.depth == 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_node_master(self) -> bool:\n self._assert_local_rank_set()\n return self.local_rank == 0",
"def is_master(self):\n return self._is_master",
"def is_master(self):\n return MPControl.is_master",
"def is_master(self) -> bool:\n return self.zone.SharedRoomID and self.zon... | [
"0.8737156",
"0.8224543",
"0.8093627",
"0.8079041",
"0.787273",
"0.7678137",
"0.7496142",
"0.7409133",
"0.7236752",
"0.7206599",
"0.71834207",
"0.6667358",
"0.6657551",
"0.66142035",
"0.64824533",
"0.6475769",
"0.6441394",
"0.6434042",
"0.639641",
"0.6376803",
"0.6363649",
... | 0.71505064 | 11 |
Whether or not this is a hardened node. Hardened nodes are those with indices >= 0x80000000. | def hardened(self):
# A hardened key is a key with index >= 2 ** 31, so
# we check that the MSB of a uint32 is set.
return self.index & 0x80000000 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def node_leaf(self):\r\n return self.zero_son is None and self.one_son is None",
"def is_internal(self):\n if self.is_leaf() or self.is_semileaf():\n return False\n return True",
"def node_inode(self):\n return False",
"def node_inode(self):\n return False",
"d... | [
"0.62713253",
"0.60492986",
"0.5942298",
"0.5942298",
"0.5901078",
"0.57642645",
"0.5762194",
"0.5736317",
"0.57134473",
"0.5682844",
"0.5674507",
"0.5665041",
"0.56444204",
"0.5642746",
"0.56300306",
"0.55741334",
"0.55603236",
"0.55570173",
"0.55541235",
"0.5552279",
"0.552... | 0.68602026 | 0 |
Returns the identifier for the key. | def identifier(self):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_key_id(self):",
"def key(key):\n return key",
"def key_id(self):\n return self._key_id",
"def key(self):\n return str(self._id)",
"def key(self) -> str:\n return pulumi.get(self, \"key\")",
"def key(self) -> str:\n return pulumi.get(self, \"key\")",
"def key(s... | [
"0.8199289",
"0.8123676",
"0.79820096",
"0.79350626",
"0.78921616",
"0.78921616",
"0.78921616",
"0.78921616",
"0.78921616",
"0.78921616",
"0.78921616",
"0.78921616",
"0.78921616",
"0.78921616",
"0.78921616",
"0.78921616",
"0.78921616",
"0.78921616",
"0.78921616",
"0.78921616",
... | 0.0 | -1 |
Returns the key's fingerprint, which is the first 4 bytes of its identifier. | def fingerprint(self):
return self.identifier[:4] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fingerprint(public_key):\r\n\r\n return hashlib.new('ripemd160', hashlib.sha256(public_key).digest()).digest()[:4]",
"def fingerprint(self, key):\n base64_pub = self.base64_pub_encode(key)\n return SHA256.new(base64_pub.encode('utf-8')).digest()",
"def fingerprint(self):\n return se... | [
"0.77391666",
"0.76859707",
"0.7634195",
"0.7514036",
"0.7471615",
"0.7366445",
"0.7218066",
"0.71334374",
"0.70777875",
"0.7041138",
"0.68841106",
"0.68285894",
"0.6695113",
"0.6680278",
"0.66001993",
"0.66001993",
"0.66001993",
"0.65500057",
"0.6528393",
"0.6461605",
"0.642... | 0.7981021 | 0 |
Generates a Base58Check encoding of this key. | def to_b58check(self, testnet=False):
b = self.testnet_bytes if testnet else bytes(self)
return base58.b58encode_check(b) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_base58(self) -> str:\n return base58.b58encode(self.raw).decode('utf-8')",
"def to_base58(self) -> str:\n return base58.b58encode(self.raw).decode('utf-8')",
"def __str__(self):\n return gphBase58CheckEncode(self._hex)",
"def forge_base58(value: str) -> bytes:\n return base58_d... | [
"0.7132694",
"0.7132694",
"0.69438237",
"0.6799692",
"0.676327",
"0.66251224",
"0.63663113",
"0.6311434",
"0.630213",
"0.620253",
"0.61336774",
"0.61109304",
"0.6091969",
"0.60715467",
"0.60662615",
"0.60591286",
"0.6051299",
"0.60092396",
"0.59555876",
"0.5883445",
"0.586220... | 0.65914536 | 6 |
Serialization of the key for testnet. | def testnet_bytes(self):
return self._serialize(True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def serialize_key(key: str) -> bytes:\n return key.encode(\"utf-8\")",
"def _dumpKey(self, key):\n return self.serializer.dumpKey((self.path, self._internalNs, key))",
"def raw(self) -> bytes:\n return bytes(self._signing_key)",
"def save(self):\n if not self.fileKey:\n log... | [
"0.6948801",
"0.6768897",
"0.66655487",
"0.65602565",
"0.6537538",
"0.64810574",
"0.64295965",
"0.6374775",
"0.6282263",
"0.6258551",
"0.6218504",
"0.61828756",
"0.6135277",
"0.6117363",
"0.6116815",
"0.610087",
"0.608277",
"0.607366",
"0.6041598",
"0.6024077",
"0.5981999",
... | 0.6667217 | 2 |
Get inventory list from config files builds a NetworkRunner inventory object and a mac_map dictionary according to ansible inventory file yaml definition | def __init__(self):
self.inventory = {}
self.mac_map = {}
for conffile in CONF.config_file:
# parse each config file
sections = {}
parser = cfg.ConfigParser(conffile, sections)
try:
parser.parse()
except IOError as e:
LOG.error(str(e))
# filter out sections that begin with the driver's tag
hosts = {k: v for k, v in sections.items()
if k.startswith(c.DRIVER_TAG)}
# munge the oslo_config data removing the device tag and
# turning lists with single item strings into strings
for host in hosts:
dev_id = host.partition(c.DRIVER_TAG)[2]
dev_cfg = {k: v[0] for k, v in hosts[host].items()}
for b in c.BOOLEANS:
if b in dev_cfg:
dev_cfg[b] = types.Boolean()(dev_cfg[b])
self.inventory[dev_id] = dev_cfg
# If mac is defined add it to the mac_map
if 'mac' in dev_cfg:
self.mac_map[dev_cfg['mac'].upper()] = dev_id
LOG.info('Ansible Host List: %s', ', '.join(self.inventory)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n\n # endpdoint = \"restconf/data/ietf-interfaces:interfaces\"\n # endpoint = f\"restconf/data/ietf-interfaces:interfaces/interface={name}\"\n\n if len(argv) > 1:\n try:\n inventory = load_inventory(argv[1])\n except FileExistsError as err:\n print(\"FileEx... | [
"0.57955146",
"0.5357593",
"0.5309615",
"0.52972466",
"0.52823687",
"0.52815616",
"0.5225071",
"0.5193531",
"0.51922613",
"0.5180207",
"0.5171256",
"0.5163886",
"0.51440394",
"0.5126848",
"0.5065334",
"0.5064806",
"0.5061558",
"0.50566524",
"0.5048825",
"0.5046078",
"0.503131... | 0.6786082 | 0 |
read (tables, columns) from the table definition file | def table_col(file_name='tpch'):
path = './data/' + file_name + "/sql/{}-create.sql".format("tpch")
regex = re.compile(';\($')
tbl_name = {}
tbl = ""
with open(path, 'r') as f:
for line in f.readlines():
if "CREATE TABLE" in line:
tbl = line.split()[2]
tbl_name[tbl.lower()] = []
elif line != "\n" and ');' not in line and regex.search(line) == None:
col = line.split()[0]
tbl_name[tbl.lower()].append(col.lower())
return tbl_name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tabdes(filename, body):\n # XXX checksums ignored\n head = Struct(\"!BiHBxxxB\")\n body = Struct(body)\n # foot = Struct(\"!4s\")\n\n data = []\n with open(filename, \"rb\") as f:\n buffer = f.read()\n _, _, count, length, _ = head.unpack_from(buffer, 0)\n offset = head.size\n ... | [
"0.6431829",
"0.6404322",
"0.6258304",
"0.61863047",
"0.6153",
"0.61336774",
"0.61302614",
"0.6072644",
"0.6022581",
"0.60137993",
"0.5962784",
"0.59596694",
"0.5934838",
"0.5925993",
"0.5887302",
"0.58700204",
"0.5861452",
"0.5848875",
"0.584234",
"0.5839805",
"0.5791649",
... | 0.58154535 | 20 |
Check whether a line contains legal select/project/join (SPJ) predicate | def is_legal_prdicate(predicate):
is_legal = 0
res = ''
regex = re.compile('^.*\ (like|\=|\<\=|\>\=|\<|\>|in|\ between\ )\ .*$')
if regex.search(predicate) is not None:
predicate = predicate.split('\t')
line = [x for x in predicate if x != ''][0]
if '\n' in line:
line = line[:-1]
# remove logic ops (and/when/or)
treg = re.compile('^and |^when |^or ')
if treg.search(line):
line = line[treg.search(line).end():]
# remove nested
rreg = re.compile('\($')
# remove alias
areg = re.compile('^.*(l1|l2|l3|n1|n2|n3).*$')
if rreg.search(line) is None and areg.search(line) is None:
is_legal = 1
res = line
return is_legal,res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_candidate(line):\n line = line.lower()\n line = prepare_text_line(line)\n return (has_content(line) and any(s in line for s in copyrights_hint.statement_markers))",
"def check_record(idline,nclline,sepline,qualiline):\n return check_idline(idline) and check_sepline(sepline)",
"def line_is_va... | [
"0.64510995",
"0.62487596",
"0.6135062",
"0.5924878",
"0.58464956",
"0.57694995",
"0.56707954",
"0.5648749",
"0.55708396",
"0.5511604",
"0.54753846",
"0.54356587",
"0.5420101",
"0.5379314",
"0.5345371",
"0.5341573",
"0.5319152",
"0.53119344",
"0.5308702",
"0.5283885",
"0.5272... | 0.5551145 | 9 |
Test case for get_liveness Get job service liveness | def test_get_liveness(self):
response = self.client.open('/api/v1//liveness',
method='GET',
content_type='application/json')
self.assert200(response, "Response body is : " + response.data.decode('utf-8')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def liveness():\n return '', 200",
"def test_get_refresh_job_status(self):\n pass",
"def liveness_probe():\n return \"I am still alive!\"",
"def test_estimate_liveness_batch(self):\n detection = self.detector.detectOne(VLImage.load(filename=SPOOF), detect68Landmarks=True)\n estimat... | [
"0.6060957",
"0.60050637",
"0.5874817",
"0.5739824",
"0.56933695",
"0.5687158",
"0.5626335",
"0.56105167",
"0.560023",
"0.55861163",
"0.55428433",
"0.5536615",
"0.55124384",
"0.54971635",
"0.5488803",
"0.5478777",
"0.5478777",
"0.54599184",
"0.54395",
"0.54195917",
"0.5348092... | 0.73525107 | 0 |
Test case for get_readiness Get job service readiness | def test_get_readiness(self):
response = self.client.open('/api/v1//readiness',
method='GET',
content_type='application/json')
self.assert200(response, "Response body is : " + response.data.decode('utf-8')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_refresh_job_status(self):\n pass",
"def test_readiness_endpoint(self):\n url = f'{BASE_URL}/ready'\n response = requests.get(url)\n response_json = response.json()\n assert response.status_code == 503\n assert response_json['status'] == 503",
"def test_sta... | [
"0.72830915",
"0.6839322",
"0.6632437",
"0.65635777",
"0.63915956",
"0.63915956",
"0.6313089",
"0.6205987",
"0.61734414",
"0.61597115",
"0.614555",
"0.6124894",
"0.6102056",
"0.6053104",
"0.604147",
"0.60116535",
"0.59794265",
"0.59655803",
"0.5928916",
"0.5915668",
"0.588532... | 0.7425097 | 0 |
Retrieves the list of all User objects | def get_all_users():
users = []
for mv in storage.all("User").values():
users.append(mv.to_dict())
return jsonify(users) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_users():\n return Users.query.all()",
"def get_all_users():",
"def get_all_users():\n return User.query.all()",
"def get_all_users(self):\n \n sql = \"select * from users\"\n return self._query_all(sql)",
"def get_users(self):\n users = []\n page = 1... | [
"0.83742595",
"0.828774",
"0.8259821",
"0.8236466",
"0.8208948",
"0.81540406",
"0.81540406",
"0.81540406",
"0.81540406",
"0.81478584",
"0.8116875",
"0.81126046",
"0.80643564",
"0.8059964",
"0.8054353",
"0.8028967",
"0.8026462",
"0.7979344",
"0.79498196",
"0.7948819",
"0.79406... | 0.7877465 | 27 |
Retrieves a User object | def get_user(user_id=None):
user = storage.get("User", user_id)
if user is None:
abort(404)
return jsonify(user.to_dict()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self):\n\n user_id = get_jwt_identity()\n user = user_crud.get(user_id)\n if not user:\n abort(404, message=\"User not Found\")\n\n return user",
"def get(self, user_id):\n return User.get(user_id)",
"def get_user(self, user, instance=None):\n instan... | [
"0.81341594",
"0.8094171",
"0.8086876",
"0.7977499",
"0.7955156",
"0.7948816",
"0.79354584",
"0.7924837",
"0.7887365",
"0.78764534",
"0.7852467",
"0.7792065",
"0.7780637",
"0.77725995",
"0.7761683",
"0.7751996",
"0.77192086",
"0.7679085",
"0.76748264",
"0.766108",
"0.76554185... | 0.751007 | 40 |
Deletes a User object | def delete_user(user_id=None):
user = storage.get("User", user_id)
if user is None:
abort(404)
else:
storage.delete(user)
storage.save()
return jsonify({}), 200 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_user(self, user):\n self.delete(user)",
"def delete_user():",
"def delete_user():\n #TODO user delete\n pass",
"def delete_user(self):\n\n User.user_list.remove(self)",
"def delete_user(self):\n User.user_list.remove(self)",
"def delete_user(self):\n User.user... | [
"0.8626425",
"0.85164607",
"0.83695376",
"0.8364185",
"0.8343344",
"0.8343344",
"0.8343344",
"0.83141226",
"0.82571805",
"0.8212667",
"0.82057565",
"0.8198734",
"0.8185502",
"0.815266",
"0.8147197",
"0.8142381",
"0.81233865",
"0.80933213",
"0.8089616",
"0.7982235",
"0.7977738... | 0.7958771 | 24 |
Updates a User object | def update_user(user_id):
user = storage.get("User", user_id)
if user is None:
abort(404)
json_input = request.get_json()
if json_input is None:
abort(400, "Not a JSON")
for key, value in json_input.items():
if key not in ['id', 'email', 'created_at', 'updated_at']:
setattr(user, key, value)
user.save()
return jsonify(user.to_dict()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_user():",
"def update_user(cls, **kwargs):\n return cls._do_call(\n 'PUT', cls.api_endpoint + 'users', params=kwargs)",
"def update_user():\n #TODO user update \n pass",
"def update(self, user: U) -> None:\n ...",
"def put(self, user_id):\r\n return update_u... | [
"0.8470099",
"0.8341868",
"0.817528",
"0.81275237",
"0.7892335",
"0.7821547",
"0.7795651",
"0.77814746",
"0.7775861",
"0.7737184",
"0.76707584",
"0.76067144",
"0.75910306",
"0.7590645",
"0.7536968",
"0.74962765",
"0.7480669",
"0.74541986",
"0.74528563",
"0.7435805",
"0.741409... | 0.7520065 | 15 |
=============================================================== save_obj(obj, saved_name ) =============================================================== this function is used to save any python object to your hard desk | def save_obj(obj, saved_name ):
with open( saved_name + '.pkl', 'wb') as f:
pickle.dump(obj, f, pickle.HIGHEST_PROTOCOL) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_obj(obj, name):\r\n with open('../pickle/' + name + '.pkl', 'wb') as fout:\r\n pickle.dump(obj, fout, pickle.HIGHEST_PROTOCOL)\r\n # end with\r",
"def save_obj(obj, name):\n \n with open(name + '.pkl', 'wb') as objec:\n pickle.dump(obj, objec)",
"def save_obj(obj,... | [
"0.83799785",
"0.83523476",
"0.834026",
"0.834026",
"0.8322952",
"0.8320533",
"0.81125903",
"0.805116",
"0.80221593",
"0.79732233",
"0.7954794",
"0.79475254",
"0.790895",
"0.78999376",
"0.7857288",
"0.7842152",
"0.7814447",
"0.7774819",
"0.76592255",
"0.7642796",
"0.76062477"... | 0.88148 | 0 |
=============================================================== load_obj(saved_name) =============================================================== this function is used to save any python object to your hard desk | def load_obj(saved_name):
with open( saved_name + '.pkl', 'rb') as f:
return pickle.load(f) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_obj(obj, saved_name ):\n with open( saved_name + '.pkl', 'wb') as f:\n pickle.dump(obj, f, pickle.HIGHEST_PROTOCOL)",
"def save_obj(obj, name):\n with open('../../data/' + name + '.pkl', 'wb') as f:\n pickle.dump(obj, f, pickle.HIGHEST_PROTOCOL)",
"def save_obj(obj, name):\n wit... | [
"0.81122315",
"0.7685448",
"0.7685448",
"0.7588679",
"0.75443125",
"0.74489355",
"0.74238276",
"0.7387553",
"0.730978",
"0.730978",
"0.7296159",
"0.7197405",
"0.71187323",
"0.7099137",
"0.7085125",
"0.7082581",
"0.70419323",
"0.70103645",
"0.70006555",
"0.6940859",
"0.6908531... | 0.82277983 | 0 |
=========================================================== DateFormatedSQL(x) =========================================================== this function converts the the date read from a list to a datetime format | def DateFormatedSQL(x):
x=[i[0] for i in x]
x1=[]
for i in x:
if len(i)==19:
x1.append(datetime.datetime(int(i[:4]),int(i[5:7]),int(i[8:10]),int(i[11:13]),int(i[14:16]),int(i[17:18]) ))
# elif len(i)==13:
# x1.append(datetime.datetime(int(i[:4]),int(i[5:7]),int(i[8:10]),int(i[11:13]),int(0),int(0) ))
# else:
# x1.append(datetime.datetime(int(i[:4]),int(i[5:7]),int(i[8:10]),int(0),int(0),int(0) ))
# del i,x
return x1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def change_format_from_input_to_datetime(list_d_t_t):\n data_output = []\n\n for row in list_d_t_t:\n data_output.append([datetime.datetime.strptime(row[0] + \" \" + row[1], \"%Y-%m-%d %H:%M:%S\"),\n datetime.datetime.strptime(row[0] + \" \" + row[2], \"%Y-%m-%d %H:%M:%S\")]... | [
"0.66734904",
"0.65000284",
"0.6259414",
"0.59757656",
"0.5600508",
"0.5579302",
"0.5578522",
"0.5551475",
"0.5513122",
"0.54512274",
"0.5435365",
"0.52705914",
"0.52298",
"0.5214014",
"0.5199284",
"0.51939476",
"0.5177129",
"0.5144611",
"0.51139647",
"0.5111645",
"0.5084982"... | 0.7940835 | 0 |
=========================================================== dateformated(x) =========================================================== this function converts the the date read from a list to a datetime format | def DateFormated(x):
x1=[]
for i in x:
if len(i)==19:
x1.append(datetime.datetime(int(i[:4]),int(i[5:7]),int(i[8:10]),int(i[11:13]),int(i[14:16]),int(i[17:18]) ))
# elif len(i)==13:
# x1.append(datetime.datetime(int(i[:4]),int(i[5:7]),int(i[8:10]),int(i[11:13]),int(0),int(0) ))
# else:
# x1.append(datetime.datetime(int(i[:4]),int(i[5:7]),int(i[8:10]),int(0),int(0),int(0) ))
# del i,x
return x1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def change_format_from_input_to_datetime(list_d_t_t):\n data_output = []\n\n for row in list_d_t_t:\n data_output.append([datetime.datetime.strptime(row[0] + \" \" + row[1], \"%Y-%m-%d %H:%M:%S\"),\n datetime.datetime.strptime(row[0] + \" \" + row[2], \"%Y-%m-%d %H:%M:%S\")]... | [
"0.73220545",
"0.6644235",
"0.64673054",
"0.63785565",
"0.6323779",
"0.63159305",
"0.6256937",
"0.6174311",
"0.5986844",
"0.58866596",
"0.5878423",
"0.58775616",
"0.58339506",
"0.579193",
"0.57800907",
"0.57769805",
"0.5757611",
"0.57572365",
"0.57409817",
"0.5732213",
"0.572... | 0.75249213 | 0 |
If there exists a record like dbsilomongomaster.alpha.xplain.io, returns the next number (4) | def get_new_service_num(route53_zone, service_name):
# Match records belonging to the service for particular service and
# environment.
match_regex = "(?<={})\d+(?=\.{}\.?)" \
.format(service_name, route53_zone.name)
# Initialize with 0 because we want 1-indexing
service_nums = [0]
for record in route53_zone.get_records():
match = re.search(match_regex, record.name)
if match:
service_num = int(match.group(0))
service_nums.append(service_num)
return max(service_nums) + 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_next_match_id():\n conn = get_connect()\n cursor = conn.execute(\"SELECT matchId FROM match WHERE isSearched = 0 LIMIT 1\")\n result_list = cursor.fetchone()\n conn.close()\n if result_list is None:\n print(\"no more matchId to be searched\")\n return None\n else:\n m... | [
"0.6664259",
"0.61382604",
"0.60998386",
"0.5928929",
"0.5735149",
"0.5713186",
"0.5704618",
"0.55747485",
"0.5572003",
"0.55479425",
"0.55387664",
"0.5533251",
"0.5508651",
"0.54968625",
"0.5493598",
"0.54908",
"0.5483527",
"0.5479922",
"0.54581887",
"0.5456278",
"0.5432718"... | 0.0 | -1 |
Check if a record exists matching the service pattern with the current host's ip | def record_exists(route53_zone, service_name, ip):
# Match records belonging to the service for particular service and
# environment.
match_regex = "{}\d+\.{}\.?".format(service_name, route53_zone.name)
for record in route53_zone.get_records():
match = re.match(match_regex, record.name)
if match and ip in record.resource_records:
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cusip_exists(record):\n cusips = helper.query_db('instruments', 'cusip')\n assert record['cusip'] in cusips",
"def name_matches_ip(name, ip, state):\n for client in state['clients']:\n if client['name'] == name:\n if client['ip'] == ip:\n return True\n el... | [
"0.6178328",
"0.6014736",
"0.59269434",
"0.58188164",
"0.56742144",
"0.56725705",
"0.56573004",
"0.5653265",
"0.56383586",
"0.56271714",
"0.5579105",
"0.5578969",
"0.55783236",
"0.5542878",
"0.55369085",
"0.55349123",
"0.5531589",
"0.5526352",
"0.5510327",
"0.5509592",
"0.548... | 0.7733625 | 0 |
Creates record with record_name and ip; updates record if it already exists with different ip does nothing if record already exists with same ip | def upsert_record(route53_zone, record_name, ip):
# Only upsert the dns record if it doesn't resolve to us.
try:
record_ip = socket.gethostbyname(record_name)
except socket.error:
# Ignore if we can't connect to the host
pass
else:
if ip == record_ip:
return
print str(dt.now()), "Registering host as", record_name
record = route53_zone.get_a(record_name)
if record and ip not in record.resource_records:
route53_zone.update_a(record_name, ip)
elif not record:
route53_zone.add_a(record_name, ip) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _update_record(self, record_name, ip):\n if ((not hasattr(self, '_current_zone')) or (not self._current_zone)) or ((not hasattr(self, '_new_zone_version_number')) or (not self._new_zone_version_number)):\n raise GandiApiException(\"Can't update record, no cloned zone available.\")\n \n... | [
"0.72148836",
"0.66041684",
"0.62076926",
"0.6207673",
"0.5900262",
"0.58394516",
"0.58283144",
"0.57992715",
"0.57729447",
"0.5762532",
"0.57310665",
"0.5682131",
"0.5672659",
"0.5666608",
"0.5655603",
"0.5637485",
"0.56220573",
"0.56179416",
"0.560817",
"0.56004244",
"0.559... | 0.7590886 | 0 |
Terminate an ec2 instance | def terminateInstance(region,zone,instance_id):
try:
ec2 = boto.ec2.connect_to_region(region+'-'+zone)
ec2.terminate_instances(instance_ids=[instance_id])
return True
except Exception as e:
logError(e)
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ec2_stop(resource, metadata):\n instances = resource.instances.filter(\n Filters=[{'Name': 'instance-state-name', 'Values': ['running']},\n {'Name': 'tag:Name', 'Values': [metadata['fqdn']]}, ])\n\n for instance in instances:\n print(\"Terminating vm id {0} name {1}\".format... | [
"0.80912846",
"0.80731577",
"0.79928845",
"0.7745165",
"0.7609396",
"0.7455729",
"0.74132353",
"0.7362064",
"0.7344869",
"0.7302483",
"0.72819716",
"0.71319824",
"0.711395",
"0.7096879",
"0.7086053",
"0.7067986",
"0.6984061",
"0.6978721",
"0.68962944",
"0.6884447",
"0.6829472... | 0.7719454 | 4 |
Create a new EC2 instance with specific parameters SecurityGroup (sg) and KeyPair (key) have to be previously created (see cassandgo initSG and cassandgo initKP) | def createInstance(ec2,ami,nb_nodes,placement,instance_type,key,sg,user_data=None):
reservation = ec2.run_instances(ami,min_count=nb_nodes,max_count=nb_nodes,placement = placement,key_name=key,security_groups=[sg],instance_type=instance_type,user_data=user_data)
instance = reservation.instances[0]
return instance | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_instance(ami, sg_name):\n instance = None\n ec2 = boto3.resource('ec2',region_name=\"us-east-1\")\n # TODO: Create an EC2 instance\n # Wait for the instance to enter the running state\n # Reload the instance attributes\n\n try:\n instance = ec2.create_instances(\n ImageId... | [
"0.7219868",
"0.68883014",
"0.67771643",
"0.6717516",
"0.67171246",
"0.66807824",
"0.6674608",
"0.66468847",
"0.65976626",
"0.6490849",
"0.6442486",
"0.63030493",
"0.62883216",
"0.6278427",
"0.6269443",
"0.61487126",
"0.61450726",
"0.61255866",
"0.6090022",
"0.6052359",
"0.60... | 0.7226294 | 0 |
Create a new SecurityGroup | def createSG(ec2,name,rules):
# check if the security group exists
group = None
sgGroups = [sg for sg in ec2.get_all_security_groups() if sg.name == name]
if sgGroups:
group = sgGroups[0]
ec2.delete_security_group(name=name, group_id=group)
print "Creating %s Security Group" % name
group = ec2.create_security_group(name, 'group for %s' % name)
if group:
# Set the inbound rules
for rule in rules:
if rule.src_group_name:
group.authorize(ip_protocol=rule.ip_protocol,from_port=rule.from_port,to_port=rule.to_port,cidr_ip=rule.cidr_ip,src_group=group)
else:
group.authorize(ip_protocol=rule.ip_protocol,from_port=rule.from_port,to_port=rule.to_port,cidr_ip=rule.cidr_ip,src_group=None)
return True
else:
logError('Error during '+name+' Security Group update')
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_security_group(self, body=None):\r\n return self.post(self.security_groups_path, body=body)",
"def create(self, body: CloudSecurityGroup) -> Dict:\n\t\treturn self._post(route=AWSSecurityGroupConsts.CLOUD_SECURITY_GROUP.value, body=body)",
"def security_group_create(auth=None, **kwargs):\n ... | [
"0.81746614",
"0.8173531",
"0.8123306",
"0.8045393",
"0.7995554",
"0.7991185",
"0.79661214",
"0.7898956",
"0.7896103",
"0.7488821",
"0.7426497",
"0.7370995",
"0.72724205",
"0.7255197",
"0.702857",
"0.6984043",
"0.6908669",
"0.6881222",
"0.68289787",
"0.6826571",
"0.6761301",
... | 0.72574544 | 13 |
List all instances for a specific region and zone | def listInstancesRegionZone(region,zone):
print "-"*80
print "# Region :",region," Zone", zone
print "-"*80
instances = getInstancesRegionZone(region,zone)
if instances:
for instance in instances:
print "[",instance.ami_launch_index,"]",instance.ip_address," (",instance.private_ip_address,") ",instance.instance_type," key=",instance.key_name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_instances(self, region):\n try:\n conn = ec2.connect_to_region(region, **self.credentials)\n region_instances = []\n reservations = conn.get_all_reservations()\n for reservation in reservations:\n for instance in reservation.instances:\n ... | [
"0.73566705",
"0.7152035",
"0.69493294",
"0.6796809",
"0.67603457",
"0.6752783",
"0.6647198",
"0.6643667",
"0.64551127",
"0.64104474",
"0.6406182",
"0.6393634",
"0.63902986",
"0.6389321",
"0.63319427",
"0.629142",
"0.628562",
"0.6270777",
"0.6261531",
"0.6253145",
"0.621456",... | 0.82746065 | 0 |
Create all Cassandra security groups in all regions | def createAllSG():
for info in conf_HVM:
ec2 = boto.ec2.connect_to_region(info['region']+'-'+info['zone'])
createSG(ec2,'SG-Cassandra-'+info['region']+'-'+info['zone'],CASSANDRA_RULES) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_groups():\n groups = [\"iDRAC-Administrators\", \"iDRAC-Operators\", \"iDRAC-Readonly\"]\n group_priviledges = [\"0x000001ff\", \"0x000000f9\", \"0x00000001\"]\n for host in online_hosts:\n for index in [1,2,3]:\n print index,\" \", groups[index-1]\n with settings(w... | [
"0.65404814",
"0.641292",
"0.6315235",
"0.63037133",
"0.62225246",
"0.611194",
"0.6016119",
"0.589653",
"0.58127975",
"0.5788823",
"0.57725734",
"0.5730021",
"0.571415",
"0.56577706",
"0.56387746",
"0.55405027",
"0.54687124",
"0.5450472",
"0.54221886",
"0.5418091",
"0.5405399... | 0.71990424 | 0 |
Create all key pairs in all regions | def createAllKP():
if not os.path.exists(keysDir):
os.makedirs(keysDir)
for info in conf_HVM:
keyName = 'Key-'+info['region']+'-'+info['zone']
try:
os.remove(keysDir+'/'+keyName+'.pem')
except OSError:
pass
print "Key creation :",keyName
ec2 = boto.ec2.connect_to_region(info['region']+'-'+info['zone'])
# check if the key pair exists
kps = [kp for kp in ec2.get_all_key_pairs() if kp.name == keyName]
if kps:
ec2.delete_key_pair(keyName)
key = ec2.create_key_pair(keyName)
key.save(keysDir) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_keys():",
"def createAllSG():\n\tfor info in conf_HVM:\n\t\tec2 = boto.ec2.connect_to_region(info['region']+'-'+info['zone'])\n\t\tcreateSG(ec2,'SG-Cassandra-'+info['region']+'-'+info['zone'],CASSANDRA_RULES)",
"def setup_space_keys(cls):\n if cls.KEYS:\n return\n\n from pkg_re... | [
"0.65445393",
"0.6132496",
"0.60415924",
"0.5918604",
"0.59134144",
"0.587338",
"0.5822073",
"0.5657623",
"0.5650972",
"0.5635661",
"0.5604821",
"0.5563397",
"0.5509014",
"0.5504165",
"0.5494566",
"0.54587173",
"0.5435119",
"0.54258394",
"0.54082614",
"0.5393367",
"0.5384728"... | 0.7191877 | 0 |
Constructor for the ManagementAccessToken class | def __init__(self,
access_token=None,
token_type=None,
error=None):
# Initialize members of the class
self.access_token = access_token
self.token_type = token_type
self.error = error | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, access_token):\n self.access_token = access_token",
"def __init__(self, access_token=None):\n self.access_token = access_token",
"def __init__(self, access_token):\n self._access_token = access_token",
"def __init__(self, access_token_cache, account_id, credentials):\n... | [
"0.7636313",
"0.7517129",
"0.7437664",
"0.72003037",
"0.7027544",
"0.6943499",
"0.6889966",
"0.68749976",
"0.6788117",
"0.6651019",
"0.6641739",
"0.6631",
"0.66123813",
"0.6594493",
"0.65795815",
"0.6572527",
"0.6505966",
"0.65004337",
"0.64906555",
"0.64870405",
"0.64369303"... | 0.7398528 | 3 |
Creates an instance of this model from a dictionary | def from_dictionary(cls,
dictionary):
if dictionary is None:
return None
# Extract variables from the dictionary
access_token = dictionary.get('accessToken')
token_type = dictionary.get('tokenType')
error = cohesity_app_sdk.models.error.Error.from_dictionary(dictionary.get('error')) if dictionary.get('error') else None
# Return an object of this model
return cls(access_token,
token_type,
error) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n id = dictionary.get('id')\n name = dictionary.get('name')\n mtype = dictionary.get('type')\n usage_bytes = diction... | [
"0.8317533",
"0.81689686",
"0.81689686",
"0.81188685",
"0.808892",
"0.7977596",
"0.7949056",
"0.79225504",
"0.78983366",
"0.7893884",
"0.7887517",
"0.7882494",
"0.7881197",
"0.7876339",
"0.78581846",
"0.78387725",
"0.78037786",
"0.78037786",
"0.78037786",
"0.78037786",
"0.780... | 0.7370376 | 100 |
Operator for single operand | def _arithmetize1(self, operand: Any, op: str) -> Any:
op_func = getattr(operator, op)
# Data length might be changed after evaluation
# operand = recycle_value(operand, self.data.shape[0])
return op_func(operand) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def operator(self):\n return self.__operator",
"def operator(self):\n col = self.pos\n operators = [\"||\", \"&&\", \">>\", \"<<\", \"!=\", \">=\", \"<=\", \"==\", \"##\"] + \\\n [\"-\", \"+\", \"!\", \"*\", \"/\", \"|\", \"&\", \"^\", \"<\", \">\", \"?\", \":\", \"~\", \"#\", \"=... | [
"0.7114677",
"0.694391",
"0.6853135",
"0.6847471",
"0.6837405",
"0.6791744",
"0.6742106",
"0.6664682",
"0.6664682",
"0.657418",
"0.6553492",
"0.6541233",
"0.6475368",
"0.6475368",
"0.64606273",
"0.64198357",
"0.64169806",
"0.64141864",
"0.64120305",
"0.6401596",
"0.6390579",
... | 0.6933232 | 2 |
Operator for paired operands | def _arithmetize2(self, left: Any, right: Any, op: str) -> Any:
op_func = getattr(operator, op)
left, right = _recycle_left_right(left, right)
return op_func(left, right) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def and_or_operator(cls, quad):\n\t\tleft_op = cls.get_address_value(quad.left_operand)\n\t\tright_op = cls.get_address_value(quad.right_operand)\n\t\t# TODO: The next set of lines will fail at a specific case\n\t\tif quad.operator == 10 :\n\t\t\tcls.set_address_value(quad.result, (left_op and right_op))\n\t\telif... | [
"0.70254517",
"0.6778513",
"0.6722453",
"0.67095107",
"0.6646131",
"0.6616339",
"0.6596597",
"0.6542849",
"0.6527473",
"0.6483588",
"0.64554465",
"0.63938665",
"0.6341946",
"0.62985724",
"0.62963104",
"0.6284674",
"0.6228084",
"0.6228084",
"0.6227012",
"0.6224514",
"0.6223301... | 0.6676819 | 4 |
Mimic the & operator in R. This has to have Expression objects to be involved to work | def _op_and_(self, left: Any, right: Any) -> Any:
if isinstance(left, list):
# induce an intersect with Collection
return Intersect(left, right)
left, right = _recycle_left_right(left, right)
left = Series(left).fillna(False)
right = Series(right).fillna(False)
return left & right | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def AND(f, g):\n def _and(x):\n return f(x) & g(x)\n return _and",
"def and_(a, b):",
"def __and__(self, other):\n return self.fam.c_binop('and', self, other)",
"def __and__(self, obj):\n return self._boolean_operation(obj, operator.__and__)",
"def _and(cls, arg1, arg2):\n ... | [
"0.6913351",
"0.6844835",
"0.6834847",
"0.68041515",
"0.6614185",
"0.6585983",
"0.65602845",
"0.65299505",
"0.6528684",
"0.6510841",
"0.6501651",
"0.64942497",
"0.6466398",
"0.6432646",
"0.639087",
"0.6376711",
"0.6334177",
"0.6331774",
"0.63316846",
"0.6288898",
"0.62308896"... | 0.62697506 | 20 |
Mimic the & operator in R. This has to have Expression objects to be involved to work | def _op_or_(self, left: Any, right: Any) -> Any:
if isinstance(left, list):
return Collection(left, right)
left, right = _recycle_left_right(left, right)
left = Series(left).fillna(False)
right = Series(right).fillna(False)
return left | right | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def AND(f, g):\n def _and(x):\n return f(x) & g(x)\n return _and",
"def and_(a, b):",
"def __and__(self, other):\n return self.fam.c_binop('and', self, other)",
"def __and__(self, obj):\n return self._boolean_operation(obj, operator.__and__)",
"def _and(cls, arg1, arg2):\n ... | [
"0.6913351",
"0.6844835",
"0.6834847",
"0.68041515",
"0.6614185",
"0.6585983",
"0.65602845",
"0.65299505",
"0.6528684",
"0.6510841",
"0.6501651",
"0.64942497",
"0.6466398",
"0.6432646",
"0.639087",
"0.6376711",
"0.6334177",
"0.6331774",
"0.63316846",
"0.6288898",
"0.62697506"... | 0.0 | -1 |
Interpret for left != right | def _op_ne(self, left: Any, right: Any) -> BoolOrIter:
out = self._op_eq(left, right)
if isinstance(out, (numpy.ndarray, Series)):
neout = ~out
# neout[pandas.isna(out)] = numpy.nan
return neout
# out is always a numpy.ndarray
return not out # pragma: no cover | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __ne__(left, right):\n return (not (left == right))",
"def ne (x,y):\n\n return not (le(x,y) and le(y,x))",
"def nexact(cls, lhs, rhs):\n return lhs != rhs",
"def ne (self, other):\n return not (self == other) # opposite of eq",
"def _isLeft(P0, P1, P2):\n return... | [
"0.8098229",
"0.70341194",
"0.6655749",
"0.64999557",
"0.64726496",
"0.6470631",
"0.64697796",
"0.6455494",
"0.6385901",
"0.63324577",
"0.6331694",
"0.6274154",
"0.6211507",
"0.6198755",
"0.61944705",
"0.6193615",
"0.6182596",
"0.6180644",
"0.6173583",
"0.6173583",
"0.6162615... | 0.72011685 | 1 |
Recycle left right operands to each other | def _recycle_left_right(left: Any, right: Any) -> Tuple:
try:
left = recycle_value(left, length_of(right))
except DataUnrecyclable:
right = recycle_value(right, length_of(left))
return left, right | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _arithmetize2(self, left: Any, right: Any, op: str) -> Any:\n op_func = getattr(operator, op)\n left, right = _recycle_left_right(left, right)\n return op_func(left, right)",
"def RewriteOR(self, left, right):\n return None",
"def __call__(self):\n return self._left() + self.... | [
"0.68653905",
"0.6566106",
"0.6530686",
"0.6372209",
"0.6346159",
"0.62722206",
"0.6268917",
"0.6268676",
"0.6260108",
"0.6258728",
"0.6246955",
"0.6224608",
"0.62071043",
"0.61998665",
"0.6179604",
"0.6081393",
"0.6077263",
"0.6012032",
"0.5989172",
"0.5984579",
"0.59795463"... | 0.6620655 | 1 |
returns the l2 penalty on (trainable) network parameters combined as sum | def get_l2_penalty(nnet, include_bias=False, pow=2):
l2_penalty = 0
# do not include OC-SVM layer in regularization
if Cfg.ocsvm_loss:
if include_bias:
for layer in nnet.trainable_layers:
if not layer.issvm:
if layer.b is not None:
l2_penalty = (l2_penalty + T.sum(abs(layer.W) ** pow)
+ T.sum(abs(layer.b) ** pow))
else:
l2_penalty = l2_penalty + T.sum(abs(layer.W) ** pow)
else:
for layer in nnet.trainable_layers:
if not layer.issvm:
l2_penalty = l2_penalty + T.sum(abs(layer.W) ** pow)
else:
if include_bias:
for layer in nnet.trainable_layers:
if layer.b is not None:
l2_penalty = (l2_penalty + T.sum(abs(layer.W) ** pow)
+ T.sum(abs(layer.b) ** pow))
else:
l2_penalty = l2_penalty + T.sum(abs(layer.W) ** pow)
else:
for layer in nnet.trainable_layers:
l2_penalty = l2_penalty + T.sum(abs(layer.W) ** pow)
return T.cast(l2_penalty, dtype='floatX') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_l2_reg(self) -> torch.Tensor:\n loss = 0\n for param in self.model.parameters():\n loss += (param ** 2).sum()\n return loss",
"def l2_regularization_penalty(self):\n return self.l2 * (np.linalg.norm(self.weights)**2)",
"def l2_training_penalty(batched_out: base.O... | [
"0.7453849",
"0.7264303",
"0.7145872",
"0.70822954",
"0.68864816",
"0.68526465",
"0.6803547",
"0.6774062",
"0.6762818",
"0.67296004",
"0.64906466",
"0.647366",
"0.64639264",
"0.64553",
"0.64553",
"0.64553",
"0.6427316",
"0.64204615",
"0.64127034",
"0.6400128",
"0.6380519",
... | 0.7189708 | 2 |
returns the sparsity penalty on network activations combined as a sum | def get_sparsity_penalty(nnet, inputs, sparsity, mode="mean",
deterministic=False):
assert mode in ("mean", "l1")
rho = sparsity
penalty = 0
eps = 0.0001 # for numerical stability
for layer in nnet.all_layers:
if layer.isactivation:
activation = lasagne.layers.get_output(layer, inputs=inputs,
deterministic=deterministic)
if mode == "mean":
if layer.isrelu:
avg_activation = T.mean(T.gt(activation,
T.zeros_like(activation)),
axis=0, dtype='floatX')
if layer.issigmoid:
avg_activation = T.mean(activation, axis=0, dtype='floatX')
KL_div = T.sum((rho+eps) *
(T.log(rho+eps) - T.log(avg_activation+eps)) +
(1-rho+eps) *
(T.log(1-rho+eps) - T.log(1-avg_activation+eps)),
dtype='floatX')
penalty = penalty + KL_div
if mode == "l1":
penalty = penalty + T.sum(abs(activation), dtype='floatX')
return T.cast(penalty, dtype='floatX') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def s_penalty(self, triples, nodes):\n\n s_index, p_index, o_index = split_spo(triples)\n\n s, p, o = nodes[s_index, :], self.relations[p_index, :], nodes[o_index, :]\n\n return s.pow(2).mean() + p.pow(2).mean() + o.pow(2).mean()",
"def penalty(self):\n assert len(self.weights) == len... | [
"0.67767024",
"0.62359196",
"0.6125899",
"0.60773647",
"0.5991481",
"0.596333",
"0.5899081",
"0.58852255",
"0.5814007",
"0.57617986",
"0.5758206",
"0.57509667",
"0.57433456",
"0.57304865",
"0.56787086",
"0.56762224",
"0.5659587",
"0.5657149",
"0.56555104",
"0.5648981",
"0.564... | 0.6444512 | 1 |
returns the sum of squared spectral norms of network parameters (i.e. the sum of the largest Eigenvalues of dot(W, W.T)) | def get_spectral_penalty(nnet, include_bias=False):
penalty = 0
for layer in nnet.trainable_layers:
if not layer.issvm:
eigenvalues, eigvec = T.nlinalg.eigh(T.dot(layer.W, layer.W.T))
eig_max = T.max(eigenvalues)
penalty = penalty + eig_max
if include_bias:
for layer in nnet.trainable_layers:
if (not layer.issvm) and (layer.b is not None):
penalty = penalty + T.sum(abs(layer.b) ** 2)
return T.cast(penalty, dtype='floatX') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normsq(self):\n return sum(x**2 for x in self.data)",
"def sumsquares(self):\n return np.dot((self.demeaned ** 2).T, self.weights)",
"def normsq(self):\n return abs(sum(self._ar * self._ar))",
"def spectral_norm_parallel(self):\n weights = {}\n for l in self.all_conv_la... | [
"0.7140227",
"0.6941976",
"0.67742",
"0.65775263",
"0.64593214",
"0.6404113",
"0.63714224",
"0.63577896",
"0.63157535",
"0.62651175",
"0.623166",
"0.6196198",
"0.61877424",
"0.6176353",
"0.6174241",
"0.61738396",
"0.61442685",
"0.6121031",
"0.60918915",
"0.6082494",
"0.607733... | 0.5524715 | 93 |
returns the l2 penalty on (trainable) network parameters combined as tensor product. | def get_prod_penalty(nnet):
assert Cfg.ocsvm_loss is True
penalty = 0
layers = nnet.trainable_layers
num_layers = len(layers) - 1 # do not regularize parameters of oc-svm layer
assert num_layers > 0
W_norm_prod = 1.0
if layers[num_layers-1].b is not None:
penalty += T.sum(layers[num_layers-1].b ** 2)
for i in range(num_layers-1):
W_norm_prod *= T.sum(layers[num_layers-1-i].W ** 2)
if layers[num_layers-2-i].b is not None:
penalty += W_norm_prod * T.sum(layers[num_layers-2-i].b ** 2)
W_norm_prod *= T.sum(layers[0].W ** 2)
penalty += W_norm_prod
penalty *= T.sum(nnet.ocsvm_layer.W ** 2)
return penalty | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_l2_reg(self) -> torch.Tensor:\n loss = 0\n for param in self.model.parameters():\n loss += (param ** 2).sum()\n return loss",
"def l2_regularization_penalty(self):\n return self.l2 * (np.linalg.norm(self.weights)**2)",
"def l2_training_penalty(batched_out: base.O... | [
"0.7459851",
"0.73080754",
"0.71070445",
"0.7071918",
"0.6722846",
"0.6637411",
"0.66100603",
"0.6606142",
"0.65346557",
"0.64298236",
"0.64298236",
"0.64298236",
"0.64195216",
"0.6411184",
"0.6407858",
"0.6394501",
"0.63773257",
"0.634488",
"0.63392335",
"0.6293014",
"0.6180... | 0.66554886 | 5 |
returns the offset to balance the polynomial parameters possible by the bias terms of the network. | def get_bias_offset(nnet):
offset = 0
L = len(nnet.trainable_layers)
for l in range(L-1):
layer = nnet.trainable_layers[l]
if layer.b is not None:
W_prod = T.eye(int(layer.b.shape.eval()[0]))
for k in range(1, L-1):
W_prod = T.dot(nnet.trainable_layers[k].W.T, W_prod)
offset = offset + T.dot(W_prod, layer.b)
offset = T.dot(nnet.ocsvm_layer.W.T, offset)
return T.sum(offset) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_bias(self) -> JTensor:\n p = self.params\n b = self.local_theta().b\n if p.forget_gate_bias != 0.0:\n b = b + self.get_adjustment()\n\n return b",
"def get_bias(self):",
"def bias(self):\n return self.mbmod.bias",
"def bias(self):\n return self._bias",
"def get_bias(... | [
"0.6315012",
"0.6108197",
"0.58673644",
"0.5829149",
"0.5699308",
"0.5665857",
"0.56237257",
"0.56060565",
"0.5575922",
"0.55285054",
"0.55088294",
"0.54091525",
"0.5405784",
"0.5395721",
"0.5392568",
"0.53660536",
"0.53445673",
"0.5333317",
"0.52875805",
"0.52750427",
"0.527... | 0.70303106 | 0 |
create update for network given in argument | def create_update(nnet):
if nnet.data._X_val.ndim == 2:
inputs = T.matrix('inputs')
elif nnet.data._X_val.ndim == 4:
inputs = T.tensor4('inputs')
targets = T.ivector('targets')
# compile theano functions
if Cfg.softmax_loss:
compile_update_softmax(nnet, inputs, targets)
elif Cfg.ocsvm_loss:
if Cfg.rho_fixed:
compile_update_ocsvm_rho_fixed(nnet, inputs, targets)
else:
compile_update_ocsvm(nnet, inputs, targets)
elif Cfg.svdd_loss:
compile_update_svdd(nnet, inputs, targets)
elif Cfg.reconstruction_loss:
create_autoencoder(nnet)
else:
compile_update_default(nnet, inputs, targets) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self, network_update_args, network_create_args=None):\n network = self.neutron.create_network(**(network_create_args or {}))\n self.neutron.update_network(network[\"id\"], **network_update_args)",
"def update_target_network(self):\n\n\t\tprint \"Updating Target DQN...\"\n\t\t\n\t\tself.upda... | [
"0.7085726",
"0.6553442",
"0.6488986",
"0.62651724",
"0.6232808",
"0.6232666",
"0.61859524",
"0.61575675",
"0.61455834",
"0.6119935",
"0.6094648",
"0.6091395",
"0.6076523",
"0.6069876",
"0.60480976",
"0.60480976",
"0.60449016",
"0.6043163",
"0.60051495",
"0.5985916",
"0.59771... | 0.6348753 | 3 |
create a SVM loss for network given in argument | def compile_update_default(nnet, inputs, targets):
floatX = Cfg.floatX
C = Cfg.C
if len(nnet.all_layers) > 1:
feature_layer = nnet.all_layers[-2]
else:
feature_layer = nnet.input_layer
final_layer = nnet.svm_layer
trainable_params = lasagne.layers.get_all_params(final_layer,
trainable=True)
# Regularization
if Cfg.weight_decay:
l2_penalty = (floatX(0.5) / C) * get_l2_penalty(nnet, Cfg.include_bias)
else:
l2_penalty = T.cast(0, dtype='floatX')
# Backpropagation
prediction = lasagne.layers.get_output(final_layer, inputs=inputs,
deterministic=False)
objective, train_acc = final_layer.objective(prediction, targets)
train_loss = T.cast((objective) / targets.shape[0], dtype='floatX')
train_acc = T.cast(train_acc * 1. / targets.shape[0], dtype='floatX')
train_obj = l2_penalty + train_loss
updates = get_updates(nnet, train_obj, trainable_params, solver=nnet.solver)
nnet.backprop = theano.function([inputs, targets],
[train_obj, train_acc],
updates=updates)
# Hinge loss
nnet.hinge_loss = theano.function([inputs, targets],
[train_loss, train_acc])
# Forwardpropagation
test_prediction = lasagne.layers.get_output(final_layer, inputs=inputs,
deterministic=True)
if nnet.data.n_classes == 2:
scores = test_prediction[:, 1] - test_prediction[:, 0]
else:
scores = T.zeros_like(targets)
objective, test_acc = final_layer.objective(test_prediction, targets)
test_loss = T.cast(objective / targets.shape[0], dtype='floatX')
test_acc = T.cast(test_acc * 1. / targets.shape[0], dtype='floatX')
test_obj = l2_penalty + test_loss
# get network feature representation
test_rep = lasagne.layers.get_output(feature_layer, inputs=inputs,
deterministic=True)
test_rep_norm = test_rep.norm(L=2, axis=1)
nnet.forward = theano.function([inputs, targets],
[test_obj, test_acc, scores, l2_penalty,
test_rep_norm, test_loss]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def svm_loss(W, X, y, classes, reg):\n # compute the loss and the gradient\n # num_classes = W.shape[1]\n num_train = X.shape[0]\n loss = 0.0\n dW = np.zeros(W.shape) # initialize the gradient as zero\n\n #############################################################################\n # Implementation of a S... | [
"0.6997603",
"0.69757587",
"0.6954347",
"0.69388586",
"0.6791079",
"0.6756301",
"0.6728832",
"0.67196614",
"0.66558504",
"0.6613795",
"0.6579743",
"0.6554059",
"0.6525655",
"0.65236473",
"0.64979446",
"0.6477414",
"0.6435054",
"0.64005077",
"0.6381835",
"0.63708454",
"0.63617... | 0.0 | -1 |
create a softmax loss for network given in argument | def compile_update_softmax(nnet, inputs, targets):
floatX = Cfg.floatX
C = Cfg.C
final_layer = nnet.all_layers[-1]
trainable_params = lasagne.layers.get_all_params(final_layer,
trainable=True)
# Regularization
if Cfg.weight_decay:
l2_penalty = (floatX(0.5) / C) * get_l2_penalty(nnet, Cfg.include_bias)
else:
l2_penalty = T.cast(0, dtype='floatX')
# Backpropagation
prediction = lasagne.layers.get_output(final_layer, inputs=inputs,
deterministic=False)
if Cfg.ad_experiment:
train_loss = T.mean(l_objectives.binary_crossentropy(
prediction.flatten(), targets),
dtype='floatX')
train_acc = T.mean(l_objectives.binary_accuracy(prediction.flatten(),
targets),
dtype='floatX')
else:
train_loss = T.mean(l_objectives.categorical_crossentropy(prediction,
targets),
dtype='floatX')
train_acc = T.mean(T.eq(T.argmax(prediction, axis=1), targets),
dtype='floatX')
train_obj = T.cast(train_loss + l2_penalty, dtype='floatX')
updates = get_updates(nnet, train_obj, trainable_params, solver=nnet.solver)
nnet.backprop = theano.function([inputs, targets],
[train_obj, train_acc],
updates=updates)
# Forwardpropagation
test_prediction = lasagne.layers.get_output(final_layer, inputs=inputs,
deterministic=True)
if Cfg.ad_experiment:
test_loss = T.mean(l_objectives.binary_crossentropy(
test_prediction.flatten(), targets), dtype='floatX')
test_acc = T.mean(l_objectives.binary_accuracy(
test_prediction.flatten(), targets), dtype='floatX')
else:
test_loss = T.mean(l_objectives.categorical_crossentropy(
test_prediction, targets), dtype='floatX')
test_acc = T.mean(T.eq(T.argmax(test_prediction, axis=1), targets),
dtype='floatX')
test_obj = T.cast(test_loss + l2_penalty, dtype='floatX')
nnet.forward = theano.function([inputs, targets],
[test_obj, test_acc, test_prediction,
l2_penalty, test_loss]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_loss(self, xs, y):\n \"*** YOUR CODE HERE question 4 ***\"\n return nn.SoftmaxLoss(self.run(xs), y)",
"def get_loss(self, xs, y):\n \"*** YOUR CODE HERE ***\"\n y_pred = self.run(xs)\n return nn.SoftmaxLoss(y_pred,y)",
"def softmax_loss_naive(W, X, y, reg):\n # Initi... | [
"0.74243444",
"0.7283457",
"0.72514814",
"0.7247183",
"0.71797806",
"0.71731097",
"0.7170593",
"0.70910347",
"0.7069629",
"0.7036034",
"0.70345086",
"0.7027396",
"0.70033365",
"0.7002239",
"0.700087",
"0.69909036",
"0.69491434",
"0.69352823",
"0.69285876",
"0.6924547",
"0.688... | 0.6411446 | 63 |
create a OCSVM loss for network given in argument | def compile_update_ocsvm(nnet, inputs, targets):
floatX = Cfg.floatX
C = Cfg.C
A = Cfg.A
nu = Cfg.nu
if len(nnet.all_layers) > 1:
feature_layer = nnet.all_layers[-2]
else:
feature_layer = nnet.input_layer
final_layer = nnet.ocsvm_layer
trainable_params = lasagne.layers.get_all_params(final_layer,
trainable=True)
# Regularization (up to feature map)
if Cfg.weight_decay:
if Cfg.prod_penalty:
l2_penalty = (1/C) * get_prod_penalty(nnet)
elif Cfg.spec_penalty:
l2_penalty = (1/C) * get_spectral_penalty(nnet, Cfg.include_bias)
else:
l2_penalty = ((1/C) * get_l2_penalty(nnet,
include_bias=Cfg.include_bias,
pow=Cfg.pow))
else:
l2_penalty = T.cast(0, dtype='floatX')
# Bias offset
if Cfg.bias_offset:
bias_offset = get_bias_offset(nnet)
else:
bias_offset = T.cast(0, dtype='floatX')
# Backpropagation
prediction = lasagne.layers.get_output(final_layer, inputs=inputs,
deterministic=False)
objective, train_acc = final_layer.objective(prediction, targets)
# Normalization
rep = lasagne.layers.get_output(feature_layer, inputs=inputs,
deterministic=False)
rep_norm = rep.norm(L=2, axis=1).dimshuffle((0, 'x'))
if Cfg.ball_penalty:
ball_penalty, _ = final_layer.objective(
T.ones_like(rep_norm) - (rep_norm ** 2), targets)
else:
ball_penalty = T.cast(0, dtype='floatX')
ball_penalty = (1/A) * T.cast(ball_penalty / targets.shape[0],
dtype='floatX')
# Output regularization
if Cfg.output_penalty:
l2_output = (1/C) * (T.sum(abs(final_layer.W) ** Cfg.pow)
* T.sum(abs(rep) ** 2))
else:
l2_output = T.cast(0, dtype='floatX')
l2_output = T.cast(l2_output / targets.shape[0], dtype='floatX')
# SVM parameter regularization
if Cfg.Wsvm_penalty:
Wsvm_penalty = T.sum(abs(final_layer.W) ** Cfg.pow)
else:
Wsvm_penalty = T.cast(0, dtype='floatX')
# OC SVM loss has nu parameter and adds margin from origin to objective
train_loss = T.cast(objective / (targets.shape[0] * nu), dtype='floatX')
train_acc = T.cast(train_acc * 1. / targets.shape[0], dtype='floatX')
train_obj = T.cast(floatX(0.5) * l2_penalty
+ floatX(0.5) * ball_penalty
+ floatX(0.5) * l2_output
+ floatX(0.5) * Wsvm_penalty
+ train_loss
+ T.sum(final_layer.b)
+ bias_offset, dtype='floatX')
updates = get_updates(nnet, train_obj, trainable_params, solver=nnet.solver)
nnet.backprop = theano.function([inputs, targets],
[train_obj, train_acc],
updates=updates)
# Forwardpropagation
test_prediction = lasagne.layers.get_output(final_layer, inputs=inputs,
deterministic=True)
# get network feature representation
test_rep = lasagne.layers.get_output(feature_layer, inputs=inputs,
deterministic=True)
test_rep_norm = test_rep.norm(L=2, axis=1)
if Cfg.ball_penalty:
test_ball_penalty, _ = final_layer.objective(
T.ones_like(test_rep_norm.dimshuffle((0, 'x')))
- (test_rep_norm.dimshuffle((0, 'x')) ** 2), targets)
else:
test_ball_penalty = T.cast(0, dtype='floatX')
test_ball_penalty = ((1/A) * T.cast(
test_ball_penalty / targets.shape[0], dtype='floatX'))
# Output regularization
if Cfg.output_penalty:
test_l2_output = (1/C) * (T.sum(abs(final_layer.W) ** Cfg.pow)
* T.sum(abs(test_rep) ** 2))
else:
test_l2_output = T.cast(0, dtype='floatX')
test_l2_output = T.cast(test_l2_output / targets.shape[0], dtype='floatX')
objective, test_acc = final_layer.objective(test_prediction, targets)
test_loss = T.cast(objective / (targets.shape[0] * nu), dtype='floatX')
test_acc = T.cast(test_acc * 1. / targets.shape[0], dtype='floatX')
test_obj = T.cast(floatX(0.5) * l2_penalty
+ floatX(0.5) * test_ball_penalty
+ floatX(0.5) * test_l2_output
+ floatX(0.5) * Wsvm_penalty
+ test_loss
+ T.sum(final_layer.b), dtype='floatX')
nnet.forward = theano.function([inputs, targets],
[test_obj, test_acc, test_prediction,
floatX(0.5) * l2_penalty,
floatX(0.5) * test_l2_output, test_rep,
test_rep_norm, test_loss,
floatX(0.5) * test_ball_penalty]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loss_fn(self, targets, outputs, model):",
"def loss(self, **kwargs):\n pass",
"def compute_loss(self, obs, returns):",
"def compute_loss(self):",
"def _create_loss(self):\n\n with tf.name_scope(\"loss\"):\n \n # gini=(tf.nn.l2_loss( self.score))/100000\n ... | [
"0.70169455",
"0.6844153",
"0.6804448",
"0.6769743",
"0.66364557",
"0.6544467",
"0.6499708",
"0.64170283",
"0.6415858",
"0.64099944",
"0.6390037",
"0.63685757",
"0.6367827",
"0.6360576",
"0.6336654",
"0.6305561",
"0.6284038",
"0.6282407",
"0.6270986",
"0.62703526",
"0.6265863... | 0.0 | -1 |
create a OCSVM loss for network given in argument with rho=1 fixed | def compile_update_ocsvm_rho_fixed(nnet, inputs, targets):
floatX = Cfg.floatX
C = Cfg.C
nu = Cfg.nu
if len(nnet.all_layers) > 1:
feature_layer = nnet.all_layers[-2]
else:
feature_layer = nnet.input_layer
final_layer = nnet.ocsvm_layer
trainable_params = lasagne.layers.get_all_params(final_layer,
trainable=True)
# Regularization
Wsvm_penalty = T.sum(abs(final_layer.W) ** Cfg.pow)
l2_penalty = get_l2_penalty(nnet,
include_bias=Cfg.include_bias,
pow=Cfg.pow)
l2_penalty += Wsvm_penalty
l2_penalty *= (1/C)
# Backpropagation
prediction = lasagne.layers.get_output(final_layer, inputs=inputs,
deterministic=False)
scores = T.ones_like(prediction) - prediction
objective, train_acc = final_layer.objective(-scores, targets)
# OC-SVM loss
train_loss = T.cast(objective / (targets.shape[0] * nu), dtype='floatX')
train_acc = T.cast(train_acc * 1. / targets.shape[0], dtype='floatX')
train_obj = T.cast(floatX(0.5) * l2_penalty + train_loss, dtype='floatX')
updates = get_updates(nnet, train_obj, trainable_params, solver=nnet.solver)
nnet.backprop = theano.function([inputs, targets],
[train_obj, train_acc],
updates=updates)
# Forwardpropagation
test_prediction = lasagne.layers.get_output(final_layer, inputs=inputs,
deterministic=True)
test_scores = T.ones_like(prediction) - test_prediction
objective, test_acc = final_layer.objective(-test_scores, targets)
# Get network feature representation
test_rep = lasagne.layers.get_output(feature_layer, inputs=inputs,
deterministic=True)
test_rep_norm = test_rep.norm(L=2, axis=1)
test_ball_penalty = T.cast(0, dtype='floatX')
test_l2_output = T.cast(0, dtype='floatX')
# OC-SVM test loss
test_loss = T.cast(objective / (targets.shape[0] * nu), dtype='floatX')
test_acc = T.cast(test_acc * 1. / targets.shape[0], dtype='floatX')
test_obj = T.cast(floatX(0.5) * l2_penalty + test_loss, dtype='floatX')
nnet.forward = theano.function([inputs, targets],
[test_obj, test_acc, -test_scores,
floatX(0.5) * l2_penalty,
floatX(0.5) * test_l2_output, test_rep,
test_rep_norm, test_loss,
floatX(0.5) * test_ball_penalty]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_loss(self):\n\n with tf.name_scope(\"loss\"):\n \n # gini=(tf.nn.l2_loss( self.score))/100000\n gini = tf.losses.softmax_cross_entropy(self.score, 0*self.score)\n \n promo_prob=tf.reduce_sum(tf.multiply(self.score, self.cohort_weight),\n ... | [
"0.6449017",
"0.6109472",
"0.605694",
"0.5996417",
"0.593703",
"0.589075",
"0.5883496",
"0.58318764",
"0.5773389",
"0.5742824",
"0.5693317",
"0.569238",
"0.56884587",
"0.5637557",
"0.56182146",
"0.5615014",
"0.55934024",
"0.55804175",
"0.55716777",
"0.5567387",
"0.5556932",
... | 0.6604869 | 0 |
create a SVDD loss for network given in argument | def compile_update_svdd(nnet, inputs, targets):
floatX = Cfg.floatX
B = Cfg.B
C = Cfg.C
nu = Cfg.nu
# initialize R
if nnet.R_init > 0:
nnet.Rvar = shared(floatX(nnet.R_init), name="R")
else:
nnet.Rvar = shared(floatX(1), name="R") # initialization with R=1
# Loss
feature_layer = nnet.all_layers[-1]
rep = lasagne.layers.get_output(feature_layer, inputs=inputs,
deterministic=False)
# initialize c (0.5 in every feature representation dimension)
rep_dim = feature_layer.num_units
# nnet.cvar = shared(floatX(np.ones(rep_dim) * (1. / (rep_dim ** 0.5))),
# name="c")
nnet.cvar = shared(floatX(np.ones(rep_dim) * 0.5), name="c")
dist = T.sum(((rep - nnet.cvar.dimshuffle('x', 0)) ** 2),
axis=1, dtype='floatX')
scores = dist - nnet.Rvar
stack = T.stack([T.zeros_like(scores), scores], axis=1)
loss = T.cast(T.sum(T.max(stack, axis=1)) / (inputs.shape[0] * nu),
dtype='floatX')
y_pred = T.argmax(stack, axis=1)
acc = T.cast((T.sum(T.eq(y_pred.flatten(), targets), dtype='int32')
* 1. / targets.shape[0]), 'floatX')
# Network weight decay
if Cfg.weight_decay:
l2_penalty = (1/C) * get_l2_penalty(nnet,
include_bias=Cfg.include_bias,
pow=Cfg.pow)
else:
l2_penalty = T.cast(0, dtype='floatX')
# Network activation sparsity regularization
if Cfg.sparsity_penalty:
sparsity_penalty = (1/B) * get_sparsity_penalty(nnet, inputs,
Cfg.sparsity,
mode=Cfg.sparsity_mode,
deterministic=False)
else:
sparsity_penalty = T.cast(0, dtype='floatX')
# Backpropagation (hard-margin: only minimizing everything to a ball
# centered at c)
trainable_params = lasagne.layers.get_all_params(feature_layer,
trainable=True)
if Cfg.gaussian_blob:
avg_dist = T.mean(1-T.exp(-dist), dtype="floatX")
else:
avg_dist = T.mean(dist, dtype="floatX")
obj_ball = T.cast(floatX(0.5) * l2_penalty + avg_dist + sparsity_penalty,
dtype='floatX')
updates_ball = get_updates(nnet, obj_ball, trainable_params,
solver=nnet.solver)
nnet.backprop_ball = theano.function([inputs, targets], [obj_ball, acc],
updates=updates_ball)
# Backpropagation (without training R)
obj = T.cast(floatX(0.5) * l2_penalty + nnet.Rvar + loss + sparsity_penalty,
dtype='floatX')
updates = get_updates(nnet, obj, trainable_params, solver=nnet.solver)
nnet.backprop_without_R = theano.function([inputs, targets], [obj, acc],
updates=updates)
# Backpropagation (with training R)
trainable_params.append(nnet.Rvar) # add radius R to trainable parameters
updates = get_updates(nnet, obj, trainable_params, solver=nnet.solver)
nnet.backprop = theano.function([inputs, targets], [obj, acc],
updates=updates)
# Forwardpropagation
test_rep = lasagne.layers.get_output(feature_layer, inputs=inputs,
deterministic=True)
test_rep_norm = test_rep.norm(L=2, axis=1)
test_dist = T.sum(((test_rep - nnet.cvar.dimshuffle('x', 0)) ** 2),
axis=1, dtype='floatX')
test_scores = test_dist - nnet.Rvar
test_stack = T.stack([T.zeros_like(test_scores), test_scores], axis=1)
test_loss = T.cast(T.sum(T.max(test_stack, axis=1)) / (inputs.shape[0]*nu),
dtype='floatX')
test_y_pred = T.argmax(test_stack, axis=1)
test_acc = T.cast((T.sum(T.eq(test_y_pred.flatten(), targets),
dtype='int32')
* 1. / targets.shape[0]), dtype='floatX')
# Network activation sparsity regularization (with determinisitc=True)
if Cfg.sparsity_penalty:
test_sparsity_penalty = ((1 / B) *
get_sparsity_penalty(nnet, inputs,
Cfg.sparsity,
mode=Cfg.sparsity_mode,
deterministic=True))
else:
test_sparsity_penalty = T.cast(0, dtype='floatX')
test_obj = T.cast(floatX(0.5) * l2_penalty + nnet.Rvar + test_loss
+ test_sparsity_penalty, dtype='floatX')
nnet.forward = theano.function([inputs, targets],
[test_obj, test_acc, test_scores,
floatX(0.5) * l2_penalty,
test_sparsity_penalty, test_rep,
test_rep_norm, test_loss, nnet.Rvar]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tv_loss(x, name='tv_loss'):\n raise NotImplementedError(\"Please use tensorflow total_variation loss.\")",
"def loss_fn(self, targets, outputs, model):",
"def tv_loss(input: th.Tensor):\n input = tf.pad(input, (0, 1, 0, 1), \"replicate\")\n x_diff = input[..., :-1, 1:] - input[..., :-1, :-1]\n ... | [
"0.63613164",
"0.6158965",
"0.6017301",
"0.5997169",
"0.590424",
"0.5783352",
"0.57639736",
"0.5728302",
"0.5715514",
"0.5708102",
"0.5672599",
"0.56407714",
"0.5635773",
"0.5630035",
"0.56168777",
"0.5610483",
"0.5603815",
"0.55986285",
"0.5573956",
"0.5568347",
"0.55591923"... | 0.6577575 | 0 |
create autoencoder Theano update for network given in argument | def create_autoencoder(nnet):
floatX = Cfg.floatX
B = Cfg.ae_B
C = Cfg.ae_C
ndim = nnet.data._X_train.ndim
if ndim == 2:
inputs = T.matrix('inputs')
elif ndim == 4:
inputs = T.tensor4('inputs')
final_layer = nnet.all_layers[-1]
# Backpropagation
trainable_params = lasagne.layers.get_all_params(final_layer,
trainable=True)
prediction = lasagne.layers.get_output(final_layer, inputs=inputs,
deterministic=False)
# use l2 or binary crossentropy loss (features are scaled to [0,1])
if Cfg.ae_loss == "l2":
loss = lasagne.objectives.squared_error(prediction, inputs)
if Cfg.ae_loss == "ce":
loss = lasagne.objectives.binary_crossentropy(prediction, inputs)
scores = T.sum(loss, axis=range(1, ndim), dtype='floatX')
loss = T.mean(scores)
# Regularization
if Cfg.ae_weight_decay:
l2_penalty = (floatX(0.5) / C) * regularize_network_params(final_layer,
l2)
else:
l2_penalty = T.cast(0, dtype='floatX')
# Network activation sparsity regularization
if Cfg.ae_sparsity_penalty:
sparsity_penalty = ((1 / B) *
get_sparsity_penalty(nnet, inputs, Cfg.ae_sparsity,
mode=Cfg.ae_sparsity_mode,
deterministic=False))
else:
sparsity_penalty = T.cast(0, dtype='floatX')
train_obj = loss + l2_penalty + sparsity_penalty
updates = get_updates(nnet, train_obj, trainable_params,
solver=nnet.ae_solver)
nnet.ae_backprop = theano.function([inputs],
[loss, l2_penalty, sparsity_penalty,
scores],
updates=updates)
# Forwardpropagation
test_prediction = lasagne.layers.get_output(final_layer, inputs=inputs,
deterministic=True)
# use l2 or binary crossentropy loss (features are scaled to [0,1])
if Cfg.ae_loss == "l2":
test_loss = lasagne.objectives.squared_error(test_prediction, inputs)
if Cfg.ae_loss == "ce":
test_loss = lasagne.objectives.binary_crossentropy(test_prediction,
inputs)
test_scores = T.sum(test_loss, axis=range(1, ndim), dtype='floatX')
test_loss = T.mean(test_scores)
# Network activation sparsity regularization (with determinisitc=True)
if Cfg.ae_sparsity_penalty:
test_sparsity_penalty = ((1 / B) *
get_sparsity_penalty(nnet, inputs,
Cfg.ae_sparsity,
mode=Cfg.ae_sparsity_mode,
deterministic=True))
else:
test_sparsity_penalty = T.cast(0, dtype='floatX')
nnet.ae_forward = theano.function([inputs],
[test_loss, l2_penalty,
test_sparsity_penalty, test_scores,
test_prediction]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_full_conv_autoencoder():\n input_img = Input(shape=(84, 84, 3))\n\n x = Convolution2D(48, 8, 8, activation='relu', border_mode='same', name='c1')(input_img)\n x = MaxPooling2D((2, 2), border_mode='same')(x)\n x = Convolution2D(32, 4, 4, activation='relu', border_mode='same', name='c2')(x)\n ... | [
"0.65535045",
"0.6422185",
"0.63456124",
"0.6290219",
"0.6285251",
"0.6273079",
"0.6235958",
"0.6228888",
"0.6139146",
"0.6119213",
"0.6110673",
"0.61030644",
"0.6072735",
"0.60715985",
"0.60660934",
"0.6034425",
"0.60192865",
"0.5931092",
"0.5930418",
"0.59202427",
"0.589814... | 0.719997 | 0 |
Helper for running guider start tests. | def _guider_start(self, nCall, nInfo, nWarn, nErr, finish=False, didFail=False):
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
result = masterThread.guider_start(self.cmd, cmdState, myGlobals.actorState, 'gotoField')
self.assertEqual(result, not didFail)
self._check_cmd(nCall, nInfo, nWarn, nErr, finish, didFail=didFail) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def startTestRun(self):",
"def __main() :\n launchTests()",
"def runTests(self):\n \n pass",
"def test_run_started(self):",
"def main():\n run_test_all()",
"def startTestHook(self):",
"def run_main(): # pragma: no cover\n RunTestsCLI.run()",
"def startTest(asset):",
"def run(con... | [
"0.78004026",
"0.7614107",
"0.7351775",
"0.7290789",
"0.7199481",
"0.71878326",
"0.70207834",
"0.6993264",
"0.6858419",
"0.6842322",
"0.6831787",
"0.6791457",
"0.6771266",
"0.6755483",
"0.670912",
"0.6685418",
"0.66745853",
"0.66695005",
"0.65984964",
"0.6530515",
"0.65222645... | 0.0 | -1 |
ffs open, 3x axis clear, guider on | def test_guider_start_ffsClosed(self):
self._guider_start(6, 20, 0, 0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear_crossfilter1(self):\n print ('Trigger clear')\n self.query_dict = {}\n self.plot_data = None\n self.create_figure_new()\n layout_doc.children[4].children[0] = self.p",
"def clear_crossfilter2(self):\n print ('Trigger clear')\n self.query_dict = {}\n ... | [
"0.61160886",
"0.6069212",
"0.5878568",
"0.5857923",
"0.5843179",
"0.58136004",
"0.57567126",
"0.57446754",
"0.5731113",
"0.57125556",
"0.5617229",
"0.55928105",
"0.55445457",
"0.5534347",
"0.5533265",
"0.55276537",
"0.5508186",
"0.549856",
"0.5490645",
"0.5472276",
"0.540083... | 0.0 | -1 |
3x axis clear, guider on | def test_guider_start_ffsOpen(self):
sopTester.updateModel('mcp', TestHelper.mcpState['boss_science'])
self._guider_start(5, 17, 0, 0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear_axes_selection(self):\n self.x_axis = ''\n self.y_axis = ''\n self.non_numeric_x_axis = False\n self.count_desired = False\n self.header_choices('x')",
"def clean_axis(ax):\n ax.get_xaxis().set_ticks([])\n ax.get_yaxis().set_ticks([])\n for sp in ax.spines.va... | [
"0.65289444",
"0.63922054",
"0.6321609",
"0.6298944",
"0.6190664",
"0.61035085",
"0.60953176",
"0.60531133",
"0.6040696",
"0.6023394",
"0.6004292",
"0.5933611",
"0.58755267",
"0.5860231",
"0.58342767",
"0.5827443",
"0.5751592",
"0.5682224",
"0.5678112",
"0.5671971",
"0.566845... | 0.0 | -1 |
ffs open, he off, hgcd off, 3x axis clear, guider on | def test_guider_start_arcsOn(self):
sopTester.updateModel('mcp', TestHelper.mcpState['arcs'])
self._guider_start(8, 20, 0, 0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cehs():\n\tcloseEHShutter()",
"def zguider():\n gzero.gxoff = camera.status.guider[0] + gzero.gxoff\n gzero.gyoff = camera.status.guider[1] + gzero.gyoff\n guider(0,0)\n f = open('/data/guidezero','w')\n cPickle.dump(gzero,f)\n f.close()",
"def reset(self):\n self.position = np.zeros(self.ndeg... | [
"0.5735864",
"0.5659085",
"0.54460454",
"0.5380752",
"0.53681165",
"0.5359119",
"0.5346913",
"0.53467923",
"0.5345186",
"0.53185624",
"0.53087205",
"0.5306554",
"0.5283048",
"0.5248694",
"0.52321434",
"0.5206659",
"0.52050847",
"0.51976866",
"0.5184278",
"0.5164785",
"0.51638... | 0.0 | -1 |
ffs open, flat off, 3x axis clear, guider on | def test_guider_start_flatsOn(self):
sopTester.updateModel('mcp', TestHelper.mcpState['flats'])
self._guider_start(7, 20, 0, 0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear(self):\n self.np.fill(OFF)\n self.np.show()\n return True",
"def cerrar(self):\n self.x0 = np.array(self.x0, dtype=float)\n self.x = np.array(self.x, dtype=float)\n self.tipos = np.array(self.tipos, dtype=int)\n self.mask_fr = self.tipos == 1\n se... | [
"0.5862193",
"0.5839169",
"0.58179474",
"0.5817385",
"0.58068",
"0.57821304",
"0.5691695",
"0.5675337",
"0.5528641",
"0.55042607",
"0.5428167",
"0.53599954",
"0.5344104",
"0.5337998",
"0.5293606",
"0.5292733",
"0.5271016",
"0.5258116",
"0.5246498",
"0.524269",
"0.5237372",
... | 0.0 | -1 |
Helper for running guider flat tests. | def _guider_flat(self, nCall, nInfo, nWarn, nErr, finish=False, didFail=False):
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
result = masterThread.guider_flat(self.cmd, cmdState, myGlobals.actorState, 'guider')
self.assertEqual(result, not didFail)
self._check_cmd(nCall, nInfo, nWarn, nErr, finish, didFail=didFail) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def runTests(self):\n \n pass",
"def main():\n run_test_all()",
"def tests():",
"def runtest(self):",
"def test_single_test_case():\n pass",
"def __main() :\n launchTests()",
"def test_basic_execution(self):",
"def test_generate_all_testing(self):\n pass",
"def spec_tests(... | [
"0.7352913",
"0.72175664",
"0.7153499",
"0.71123314",
"0.69343376",
"0.6914146",
"0.68364465",
"0.68047154",
"0.67976254",
"0.6754427",
"0.6737129",
"0.6672995",
"0.666052",
"0.662404",
"0.6613215",
"0.6601137",
"0.6594231",
"0.6594231",
"0.65821177",
"0.6561161",
"0.65609705... | 0.0 | -1 |
Helper for running guider flat tests that check the APOGEE shutter. | def _guider_flat_apogeeShutter(self, nCall, nInfo, nWarn, nErr, finish=False, didFail=False):
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
result = masterThread.guider_flat(
self.cmd, cmdState, myGlobals.actorState, 'guider', apogeeShutter=True)
self.assertEqual(result, not didFail)
self._check_cmd(nCall, nInfo, nWarn, nErr, finish, didFail=didFail) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def runTest(self):\n E = main()\n self.assertInside(E, energy, 1e-5)",
"def main():\n # run_test_go_straight_inches()\n # run_test_turn_degrees()\n # run_test_spin_degrees()\n beep_if_blob_is_bigger_than(3000)",
"def test_01_lighting(self):",
"def test_run(self):\n rig_analys... | [
"0.6602023",
"0.65421003",
"0.62224287",
"0.62081254",
"0.6206044",
"0.5991344",
"0.5950729",
"0.59440666",
"0.5933885",
"0.5919975",
"0.5912514",
"0.5885823",
"0.5882865",
"0.5820897",
"0.581793",
"0.5800086",
"0.5794324",
"0.57891035",
"0.578905",
"0.57890207",
"0.57865036"... | 0.5492133 | 91 |
decenter off Will give cmd.error and stage=failed, but won't fail command. | def test_deactivate_guider_decenter_fails(self):
sopTester.updateModel('guider', TestHelper.guiderState['guiderOnDecenter'])
self.cmd.failOn = 'guider decenter off'
self._deactivate_guider_decenter(1, 9, 0, 2, didFail=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def halt_cmd(ctx):\n pass",
"def command_failed_error(cmd):\n\n output_1 = colored(' - Error: Failed to run command ', 'red')\n output_2 = command(cmd)\n return output_1 + output_2 + '\\n'",
"def assert_cli_fails_properly(response, caplog):\n # don't exit successfully\n assert response.exit_c... | [
"0.63274103",
"0.59832925",
"0.58065456",
"0.5717935",
"0.57014954",
"0.56815827",
"0.56410784",
"0.5618887",
"0.5596389",
"0.5563665",
"0.55591875",
"0.5529268",
"0.5520761",
"0.55194193",
"0.550422",
"0.54478794",
"0.5444886",
"0.54415536",
"0.5407555",
"0.5348784",
"0.5331... | 0.57412744 | 3 |
FF on, axis status, axis init, slew, FF on, guider flat, FF off, open FFS 3xguider axes off, guider on | def test_goto_field_apogee(self):
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
self._goto_feld_apogee(13, 46, 0, 0, cmdState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup(self, flags):\n self.figure = pylab.figure(1)\n self.axes = {}\n self.stream_data = {}\n self.flags = flags",
"def update_focal_axes(self):\n #self.update_sigma()\n self.updateGL()",
"def update_flags(self):\n # view mode, filled vs wirefrom\n if self.view['wir... | [
"0.61186206",
"0.5865818",
"0.5800843",
"0.5676216",
"0.55347174",
"0.55038637",
"0.5467715",
"0.54164624",
"0.5378973",
"0.5370552",
"0.5300264",
"0.52715015",
"0.52276176",
"0.521771",
"0.5209924",
"0.5208267",
"0.520253",
"0.5198544",
"0.51961386",
"0.519605",
"0.5194642",... | 0.0 | -1 |
axis status, axis init, slew | def test_goto_field_apogee_no_guider(self):
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
cmdState.doGuider = False
self._goto_feld_apogee(3, 11, 0, 0, cmdState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, axis=-1):\n self.axis = axis",
"def __init__(self, axes=()):\n self._axes = []\n self._dimension = 0\n for axis in axes:\n self.add_axis(axis)",
"def _set_axes(self):\n self += helper.line(stroke=\"black\", x1=self.__dict__['x'], x2=self.__di... | [
"0.6245888",
"0.621319",
"0.6022292",
"0.6020143",
"0.5990214",
"0.5969029",
"0.59592175",
"0.5930569",
"0.59223",
"0.59204257",
"0.58473855",
"0.58251107",
"0.5787647",
"0.5784954",
"0.5752151",
"0.5738153",
"0.5714067",
"0.5657952",
"0.56545234",
"0.56490576",
"0.5624587",
... | 0.0 | -1 |
FF on, guider flat, FF off, open FFS 3xguider axes off, guider on | def test_goto_field_apogee_no_slew(self):
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
cmdState.doSlew = False
self._goto_feld_apogee(9, 37, 0, 0, cmdState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def f_fixed(self):\n self.fx_free = self.fy_free = self.fz_free = False\n return self",
"def _show_feature_flags(graph: nx.DiGraph, mode='sorted'):\n #plt.figure(figsize=(15, 15))\n if mode == 'sorted':\n pos = nx.multipartite_layout(graph)\n nx.draw(graph, pos, with_labels=True... | [
"0.5923838",
"0.5707589",
"0.55777276",
"0.54883665",
"0.540146",
"0.5344511",
"0.533769",
"0.5307722",
"0.5219301",
"0.52111065",
"0.52089953",
"0.52063096",
"0.52039117",
"0.5201414",
"0.5189145",
"0.5175825",
"0.5149582",
"0.51441306",
"0.51224685",
"0.50826716",
"0.507198... | 0.0 | -1 |
FF on, guider flat, FF off, open FFS guider decenter off, 3xguider axes off, guider on | def test_goto_field_apogee_no_slew_decenter_off(self):
sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])
sopTester.updateModel('guider', TestHelper.guiderState['guiderOnDecenter'])
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
cmdState.doSlew = False
self._goto_feld_apogee(9, 37, 0, 0, cmdState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def f_fixed(self):\n self.fx_free = self.fy_free = self.fz_free = False\n return self",
"def zguider():\n gzero.gxoff = camera.status.guider[0] + gzero.gxoff\n gzero.gyoff = camera.status.guider[1] + gzero.gyoff\n guider(0,0)\n f = open('/data/guidezero','w')\n cPickle.dump(gzero,f)\n f.close... | [
"0.6021151",
"0.5678602",
"0.556794",
"0.5545283",
"0.54808503",
"0.54380274",
"0.5351072",
"0.53036",
"0.5298335",
"0.529772",
"0.5294927",
"0.52931446",
"0.52901006",
"0.52764875",
"0.5263691",
"0.5190619",
"0.51681143",
"0.512835",
"0.5121012",
"0.511816",
"0.51176304",
... | 0.0 | -1 |
Testing for a potential problem on SJD 56993, with gotoField not slewing when gang bypass had been set. | def test_goto_field_apogee_bypass_gangToCart(self):
self._prep_bypass('gangToCart', clear=True)
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
self._goto_feld_apogee(13, 44, 4, 0, cmdState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_goto_field_apogee_no_guider(self):\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doGuider = False\n self._goto_feld_apogee(3, 11, 0, 0, cmdState)",
"def test_goto_field_apogee_no_slew(self):\n cmdState = self.actorState.gotoField\n... | [
"0.6839827",
"0.674124",
"0.66378564",
"0.62783855",
"0.62351984",
"0.6205175",
"0.6149223",
"0.60777533",
"0.6027441",
"0.5959538",
"0.5939859",
"0.59033215",
"0.58415735",
"0.5746709",
"0.5571056",
"0.55030173",
"0.54555553",
"0.5397869",
"0.5396254",
"0.5367164",
"0.529781... | 0.59667176 | 9 |
shutter close, FF on, guider flat, FF off, open FFS 3xguider axes off, guider on | def test_goto_field_apogee_no_slew_shutter_open(self):
sopTester.updateModel('apogee', TestHelper.apogeeState['B_open'])
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
cmdState.doSlew = False
self._goto_feld_apogee(10, 37, 0, 0, cmdState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def zguider():\n gzero.gxoff = camera.status.guider[0] + gzero.gxoff\n gzero.gyoff = camera.status.guider[1] + gzero.gyoff\n guider(0,0)\n f = open('/data/guidezero','w')\n cPickle.dump(gzero,f)\n f.close()",
"def f_fixed(self):\n self.fx_free = self.fy_free = self.fz_free = False\n return se... | [
"0.56922233",
"0.54869103",
"0.5327231",
"0.5301241",
"0.52902806",
"0.52806854",
"0.52649724",
"0.5241042",
"0.5236491",
"0.52350116",
"0.5205736",
"0.5187515",
"0.517721",
"0.5160973",
"0.5148137",
"0.5135481",
"0.51285934",
"0.51083225",
"0.5073106",
"0.5068788",
"0.505857... | 0.0 | -1 |
axis status, axis init, slew | def test_goto_field_boss_slew(self):
sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
cmdState.doGuider = False
cmdState.doHartmann = False
cmdState.doCalibs = False
cmdState.arcTime = 0
cmdState.flatTime = 0
self._goto_field_boss(3, 26, 0, 0, cmdState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, axis=-1):\n self.axis = axis",
"def __init__(self, axes=()):\n self._axes = []\n self._dimension = 0\n for axis in axes:\n self.add_axis(axis)",
"def _set_axes(self):\n self += helper.line(stroke=\"black\", x1=self.__dict__['x'], x2=self.__di... | [
"0.6247041",
"0.6213832",
"0.6022709",
"0.602028",
"0.5989789",
"0.59698653",
"0.59595746",
"0.5930603",
"0.5922851",
"0.5920339",
"0.58486426",
"0.5825133",
"0.57882136",
"0.5785074",
"0.5751861",
"0.57397544",
"0.57143",
"0.5657272",
"0.56560445",
"0.5648683",
"0.56252724",... | 0.0 | -1 |
ne on, hgcd on, ff off, doHartmann, ne off, hgcd off | def test_goto_field_boss_hartmann(self):
sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
cmdState.doSlew = False
cmdState.doCalibs = False
cmdState.arcTime = 0
cmdState.flatTime = 0
cmdState.doGuider = False
self._goto_field_boss(5, 29, 0, 0, cmdState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def genfb_py(h, n, u, v, f, dt, dx, dy, du,dv,dn, gridu,gridv,gridn, threadblock, beta=0.281105, eps=0.013, gamma=0.0880, mu=0.3, nu=0, dudt_x=dudt, dvdt_x=dvdt, dndt_x=dndt, grav=True, cori=True, advx=True, advy=True, attn=True, ): # generalized forward backward fe... | [
"0.57660997",
"0.56802636",
"0.5665918",
"0.5624264",
"0.559748",
"0.55954516",
"0.5568438",
"0.5507126",
"0.5500543",
"0.5387872",
"0.53738797",
"0.534831",
"0.5345321",
"0.53414637",
"0.5333701",
"0.5332214",
"0.53233445",
"0.53016967",
"0.5296686",
"0.5290382",
"0.5285452"... | 0.0 | -1 |
see cmd_calls/TestGotoField.txt for command list. | def test_goto_field_boss_calibs(self):
sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
cmdState.doSlew = False
cmdState.doHartmann = False
cmdState.doGuider = False
self._goto_field_boss(10, 57, 0, 0, cmdState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_goto_field_apogee(self):\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n self._goto_feld_apogee(13, 46, 0, 0, cmdState)",
"def test_goto_field_apogee_no_guider(self):\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n ... | [
"0.7691792",
"0.64816624",
"0.628449",
"0.5856036",
"0.58257854",
"0.5754098",
"0.56664455",
"0.56335163",
"0.5571063",
"0.5469148",
"0.54335827",
"0.53827053",
"0.52839625",
"0.51585394",
"0.5143092",
"0.5104858",
"0.5102512",
"0.5086537",
"0.50655967",
"0.50533384",
"0.5010... | 0.47256958 | 57 |
Start with decentered guiding on, to check that we clear it. ff on, guider flat, ff off, ffs open 3xguider axes off, decenter off, guider on | def test_goto_field_boss_guider(self):
sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])
sopTester.updateModel('guider', TestHelper.guiderState['guiderOnDecenter'])
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
cmdState.doSlew = False
cmdState.doHartmann = False
cmdState.doCalibs = False
cmdState.arcTime = 0
cmdState.flatTime = 0
self._goto_field_boss(9, 37, 0, 0, cmdState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def f_fixed(self):\n self.fx_free = self.fy_free = self.fz_free = False\n return self",
"def align(): # open EH and fast shutter\n\t#marAuxiliary.closeMarShield()\n\td2in()\n\td3in()\n\tsh('o')",
"def test_DFT_rect(centering='FFTRECT', outdir=None, outname='DFT1R_', npix=None, sampling=... | [
"0.5788689",
"0.56861943",
"0.55636656",
"0.54741186",
"0.54616976",
"0.5379296",
"0.5328459",
"0.5325154",
"0.53217375",
"0.52759594",
"0.5238227",
"0.52287537",
"0.51961917",
"0.5183579",
"0.51768106",
"0.51755387",
"0.5134452",
"0.5132298",
"0.51291597",
"0.5091773",
"0.50... | 0.0 | -1 |
Fail on ff.on, but still readout the arc. | def test_goto_field_boss_flat_on_fails(self):
sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
self.cmd.failOn = 'mcp ff.on'
self._goto_field_boss(16, 71, 0, 1, cmdState, didFail=True, finish=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def friewallOn():\n pass",
"def test_export_to_mff_no_device():\n pytest.importorskip(\"mffpy\", \"0.5.7\")\n evoked = read_evokeds_mff(egi_evoked_fname, condition=\"Category 1\")\n evoked.info[\"device_info\"] = None\n with pytest.raises(ValueError, match=\"No device type.\"):\n export_evo... | [
"0.53135496",
"0.530685",
"0.5285612",
"0.5125348",
"0.51056355",
"0.50907296",
"0.50692505",
"0.50690484",
"0.4983307",
"0.49766693",
"0.4912766",
"0.4895812",
"0.48652288",
"0.48498195",
"0.48497722",
"0.48134395",
"0.4810314",
"0.4796255",
"0.47883302",
"0.47843057",
"0.47... | 0.51799893 | 3 |
Hartmann succeeds but the blue ring move is out of tolerance. | def test_goto_field_boss_hartmann_blue_fails(self):
sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])
sopTester.updateModel('hartmann', TestHelper.hartmannState['blue_fails'])
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
self._goto_field_boss(12, 37, 0, 0, cmdState, didFail=True, finish=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_W_end(self):\t\t\n self.assertAlmostEqual(attempt.W[-1], 9.494852380803035)",
"def steadyYet(newg, oldg, newe, olde, newh, oldh, newf, oldf, tolerance):\n steady_yet = True\n if oldg == 0 or (abs(newg-oldg)/oldg > tolerance or\n abs(newe-olde)/olde > tolerance or\n ... | [
"0.6039334",
"0.5930424",
"0.5919679",
"0.5912854",
"0.58305484",
"0.5801236",
"0.57621497",
"0.5761265",
"0.57383764",
"0.57260656",
"0.5721062",
"0.5718691",
"0.57167894",
"0.5701574",
"0.5683872",
"0.56769484",
"0.56751597",
"0.56513155",
"0.56409764",
"0.5639347",
"0.5600... | 0.0 | -1 |
Fail on ffs.open, but still readout flat. | def test_goto_field_boss_ffs_open_fails(self):
sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
self.cmd.failOn = 'mcp ffs.open'
self._goto_field_boss(21, 102, 1, 1, cmdState, didFail=True, finish=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_fileobj_not_closed(self):\n\n f = open(self.data('test0.fits'), 'rb')\n data = fits.getdata(f)\n assert not f.closed\n\n f.seek(0)\n header = fits.getheader(f)\n assert not f.closed",
"def test_fileobj_not_closed(self):\n\n f = open(self.data(\"test0.fits... | [
"0.6067853",
"0.59570915",
"0.5916047",
"0.5873482",
"0.5731206",
"0.57067436",
"0.5683966",
"0.5675375",
"0.5667967",
"0.5606461",
"0.5593845",
"0.557636",
"0.556104",
"0.5553911",
"0.55134106",
"0.5493101",
"0.5419356",
"0.5418688",
"0.5415278",
"0.5410945",
"0.53708446",
... | 0.48357132 | 92 |
Tests gotoField if there is a mismatch between MCP and guider. | def test_goto_field_cartridge_mismatch(self):
sopTester.updateModel('guider', TestHelper.guiderState['bossLoaded'])
mcpState = TestHelper.mcpState['boss_science']
mcpState.update({'instrumentNum': [15]})
sopTester.updateModel('mcp', mcpState)
cmdState = self.actorState.gotoField
cmdState.reinitialize(self.cmd)
masterThread.goto_field(self.cmd, cmdState, myGlobals.actorState)
self._check_cmd(0, 14, 0, 0, finish=True, didFail=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_goto_field_apogee_no_guider(self):\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n cmdState.doGuider = False\n self._goto_feld_apogee(3, 11, 0, 0, cmdState)",
"def test_goto_field_apogee(self):\n cmdState = self.actorState.gotoField\n ... | [
"0.67638075",
"0.6552739",
"0.6286361",
"0.6170494",
"0.6125492",
"0.5995649",
"0.59449685",
"0.5715474",
"0.5527284",
"0.5455693",
"0.5430143",
"0.54134613",
"0.530795",
"0.530067",
"0.5265416",
"0.5247163",
"0.52226955",
"0.5134902",
"0.5128405",
"0.51222634",
"0.5118506",
... | 0.7532309 | 0 |
Helper for boss science tests | def _do_boss_science(self, nCall, nInfo, nWarn, nErr, nExp=1):
self._update_cart(11, 'BOSS')
cmdState = self.actorState.doBossScience
cmdState.reinitialize(self.cmd)
cmdState.nExp = nExp
masterThread.do_boss_science(self.cmd, cmdState, myGlobals.actorState)
self._check_cmd(2, nInfo, nWarn, nErr, True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testBeliefs1sk(self):",
"def test_apply_endorsements(self):",
"def test_theft_and_stealing(self):",
"def healthcare():",
"def testBeliefs2sk(self):",
"def test_T01():",
"def test_alien_data(self):",
"def test_households_in_admin_unit(self):",
"def unitary_test():",
"def test_get_waivers(leagu... | [
"0.6812872",
"0.6686834",
"0.6662029",
"0.66596895",
"0.6609597",
"0.655939",
"0.6549792",
"0.6543334",
"0.65167713",
"0.6514505",
"0.6439195",
"0.6439195",
"0.6439195",
"0.6439195",
"0.6439195",
"0.64386874",
"0.63926923",
"0.6362536",
"0.632096",
"0.6316661",
"0.6280583",
... | 0.0 | -1 |
One call per requested exposure | def test_do_boss_science(self):
sopTester.updateModel('mcp', TestHelper.mcpState['boss_science'])
nExp = 2
self._do_boss_science(nExp, 35, 0, 0, nExp=nExp) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def endexposureloop(self):\n self.max_exposures = self.current_exposure",
"def observeField(target, exposure):\n\n status = 2\n real_exposure = exposure + np.random.normal(0.0, 20.0)\n realSN2 = target['DESsn2'] + np.random.uniform(0.0, 1.0)\n\n return status, real_exposure, realSN2",
"def e... | [
"0.6202363",
"0.5730469",
"0.5720542",
"0.5674125",
"0.5648648",
"0.56126845",
"0.55802995",
"0.5563538",
"0.55593634",
"0.5544014",
"0.5505167",
"0.5467155",
"0.54338604",
"0.5406679",
"0.53846276",
"0.53846276",
"0.53756344",
"0.531871",
"0.5311451",
"0.5309933",
"0.5305943... | 0.0 | -1 |
Helper for apogee science tests | def _do_apogee_science(self, nCall, nInfo, nWarn, nErr, ditherPairs=4):
self._update_cart(1, 'APOGEE')
cmdState = self.actorState.doApogeeScience
cmdState.reinitialize(self.cmd)
cmdState.ditherPairs = ditherPairs
masterThread.do_apogee_science(self.cmd, cmdState, myGlobals.actorState)
self._check_cmd(nCall, nInfo, nWarn, nErr, True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testBeliefs1sk(self):",
"def test_alien_data(self):",
"def test_art_from_taste_space(self):",
"def test_theft_and_stealing(self):",
"def test_T01():",
"def testBeliefs2sk(self):",
"def _test(self):",
"def _test(self):",
"def _test(self):",
"def _test(self):",
"def _test(self):",
"def test... | [
"0.6974807",
"0.6933129",
"0.6889396",
"0.6887534",
"0.6827801",
"0.67861944",
"0.67435616",
"0.67435616",
"0.67435616",
"0.67435616",
"0.67435616",
"0.6690207",
"0.6631977",
"0.66018003",
"0.66018003",
"0.6595975",
"0.6593147",
"0.6593147",
"0.65639585",
"0.65451413",
"0.653... | 0.0 | -1 |
open shutter, one call per exposure/dither moves | def test_do_apogee_science_4_pair_A_closed(self):
sopTester.updateModel('mcp', TestHelper.mcpState['apogee_science'])
sopTester.updateModel('apogee', TestHelper.apogeeState['A_closed'])
self._do_apogee_science(13, 72, 0, 0, ditherPairs=4) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_line_scan_shutter_closed(self):\n scan = self.scan\n laser = self.devices[scan['laser']['name']]\n shutter = self.scan['shutter']\n ni_daq = self.devices['NI-DAQ']\n ni_daq.driver.digital_output(shutter['port'], False)\n if not isinstance(shutter['delay'], Q_):\n ... | [
"0.609327",
"0.60517883",
"0.6042764",
"0.5937301",
"0.58709234",
"0.57097524",
"0.5626163",
"0.56135774",
"0.5605713",
"0.5569856",
"0.5565318",
"0.55331594",
"0.5474416",
"0.54720265",
"0.546944",
"0.546139",
"0.5431014",
"0.5417215",
"0.5389273",
"0.5385319",
"0.53823715",... | 0.0 | -1 |
one call per exposure/dither move | def test_do_apogee_science_1_pair_B_open(self):
sopTester.updateModel('mcp', TestHelper.mcpState['apogee_science'])
sopTester.updateModel('apogee', TestHelper.apogeeState['B_open'])
self._do_apogee_science(3, 30, 0, 0, ditherPairs=1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def opd_dither(cfg):\n \n setpoint_new = pi.getINDI('PLC.UBCSettings.PLSetpoint')\n file_number = pi.getINDI('NOMIC.CamInfo.FIndex') # Get initial file number\n offsets = np.array(cfg['nomic_dither_opd_pattern']) * 5.0 * 180.0 / np.pi # input in rad at 11um, but commandet offsets in deg in K band\n pi.setI... | [
"0.60497373",
"0.5954956",
"0.588953",
"0.58547735",
"0.5736053",
"0.5712237",
"0.56600004",
"0.5645142",
"0.56387717",
"0.5601205",
"0.56006426",
"0.5587478",
"0.5586383",
"0.5524406",
"0.55159074",
"0.5505001",
"0.5496937",
"0.5476632",
"0.54593825",
"0.5451838",
"0.5449247... | 0.0 | -1 |
Tests if expTime is set to 500s after a double length exposure. | def test_do_apogee_science_500s_after_1000s_cart7(self):
sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLead1000sCart7'])
self._update_cart(7, 'APOGEE')
cmdState = self.actorState.doApogeeScience
cmdState.reinitialize(self.cmd)
self.assertEqual(cmdState.expTime, 1000)
self.assertEqual(cmdState.keywords['expTime'], 1000)
sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLeadCart7'])
self._update_cart(7, 'APOGEE')
cmdState = self.actorState.doApogeeScience
cmdState.reinitialize(self.cmd)
self.assertEqual(cmdState.expTime, 500)
self.assertEqual(cmdState.keywords['expTime'], 500) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exp(self, exposure_time):\n print(f\"exp: {exposure_time}\")\n self.device_control.exposure = exposure_time\n yield",
"def exposuretime(self) -> ErrorValue:\n return ErrorValue(self._data['ExpTime'], self._data.setdefault('ExpTimeError',0.0))",
"def exptime(et=0.02):\n if et < ... | [
"0.6508764",
"0.6255665",
"0.62178487",
"0.615677",
"0.57449126",
"0.5718129",
"0.562681",
"0.560696",
"0.5600589",
"0.5502671",
"0.54754275",
"0.54733014",
"0.5451332",
"0.5331526",
"0.529389",
"0.52561027",
"0.5224857",
"0.5195893",
"0.5194161",
"0.51847905",
"0.51787597",
... | 0.4705112 | 86 |
Tests if expTime is set to 1000s after a normal length exposure. | def test_do_apogee_science_1000s_after_500s_cart7(self):
sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLeadCart7'])
self._update_cart(7, 'APOGEE')
cmdState = self.actorState.doApogeeScience
cmdState.reinitialize(self.cmd)
self.assertEqual(cmdState.expTime, 500)
self.assertEqual(cmdState.keywords['expTime'], 500)
sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLead1000sCart7'])
self._update_cart(7, 'APOGEE')
cmdState = self.actorState.doApogeeScience
cmdState.reinitialize(self.cmd)
self.assertEqual(cmdState.expTime, 1000)
self.assertEqual(cmdState.keywords['expTime'], 1000) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exp(self, exposure_time):\n print(f\"exp: {exposure_time}\")\n self.device_control.exposure = exposure_time\n yield",
"def setExposureTime(self, cmd, expTime):\n\n pass",
"def exposuretime(self) -> ErrorValue:\n return ErrorValue(self._data['ExpTime'], self._data.setdefau... | [
"0.6262144",
"0.6255858",
"0.6163135",
"0.61418873",
"0.5915087",
"0.5863674",
"0.5856211",
"0.57416385",
"0.55517083",
"0.5540617",
"0.55379456",
"0.5453827",
"0.5453151",
"0.54436797",
"0.5430154",
"0.5369838",
"0.5325574",
"0.5313959",
"0.5313157",
"0.53118265",
"0.5288747... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.