>>>>>>>>>>>>>>>>>> RESET: waiting for the movement to complete\")\n # rospy.wait_for_message(\"/pickbot/movement_complete\", Bool)\n while not self.movement_complete.data:\n pass\n # print(\">>>>>>>>>>>>>>>>>>> RESET: Waiting complete\")\n\n start_ros_time = rospy.Time.now()\n while True:\n # Check collision:\n # invalid_collision = self.get_collisions()\n # if invalid_collision:\n # print(\">>>>>>>>>> Collision: RESET <<<<<<<<<<<<<<<\")\n # observation = self.get_obs()\n # reward = UMath.compute_reward(observation, -200, True)\n # observation = self.get_obs()\n # print(\"Test Joint: {}\".format(np.around(observation[1:7], decimals=3)))\n # return U.get_state(observation), reward, True, {}\n\n elapsed_time = rospy.Time.now() - start_ros_time\n if np.isclose(init_joint_pos, self.joints_state.position, rtol=0.0, atol=0.01).all():\n break\n elif elapsed_time > rospy.Duration(2): # time out\n break\n\n self.set_target_object(random_object=self._random_object, random_position=self._random_position)\n self._check_all_systems_ready()\n\n with open('contact_1_force.yml', 'w') as yaml_file:\n yaml.dump(0.0, yaml_file, default_flow_style=False)\n with open('contact_2_force.yml', 'w') as yaml_file:\n yaml.dump(0.0, yaml_file, default_flow_style=False)\n with open('collision.yml', 'w') as yaml_file:\n yaml.dump(False, yaml_file, default_flow_style=False)\n observation = self.get_obs()\n self.object_position = observation[9:12]\n\n # print(\"Joint (after): {}\".format(np.around(observation[1:7], decimals=3)))\n\n # get maximum distance to the object to calculate reward\n self.max_distance, _ = U.get_distance_gripper_to_object()\n self.min_distace = self.max_distance\n state = U.get_state(observation)\n self._update_episode()\n return state","def run(self, data):\n\t\treduced_data = PCA(n_components=2).fit_transform(data)\n\n\t\t# Run the algorithm\n\t\tself.estimator.fit_transform(reduced_data)\n\n\t\t# Save all relevent properties\n\t\tself.input_data = data\n\t\tself.centroids = self.estimator.cluster_centers_\n\t\tself.node_positions = reduced_data\n\t\tself.labels = self.estimator.labels_\n\n\t\t# Enable visualising when debugging\n\t\t# self.visualize(reduced_data)","def reset(self):\n self.solver = None","def reset(self):\n self.__init__() # Reset all variables\n self.stitch = self.convertNumpy2Image(np.zeros([750,850,3], dtype=\"uint8\"))\n self.capture = self.convertNumpy2Image(np.zeros([320,408, 3],dtype=\"uint8\"))","def reset(self):\n \n s = self\n s.step_counter = 0\n \n # TODO: initialize first layer activations here, and not everywhere else\n # self.model.initialize_local_vars()\n # self.model.initialize_global_vars()\n\n ops = []\n\n for var in self.model.trainable_vars:\n if self.needs_correction(var):\n A_svd = s[var].A.svd\n B2_svd = s[var].B2.svd \n ops.extend(A_svd.init_ops)\n ops.extend(B2_svd.init_ops)\n ops.append(s[var].A.cov.initializer)\n ops.append(s[var].B2.cov.initializer)\n\n # in new TensorFlow this breaks, probably because of\n # https://github.com/tensorflow/tensorflow/commit/07adc2ea910de715d31e16a019fcbcccb575e931\n # sometimes get \"need to feed\" placeholder error\n # sometimes do not get this error, but spend two minutes inside\n # _build_initializer_expr\n s.run(ops)","def auto_setup(self):\n if self.mot_type == \"xps8p\":\n return\n if self.get_par(\"err_sevr\") == 3:\n print \"Reinitializing motor {}...\".format(self.name)\n self.reinit()\n ok = self.wait_par(\"err_sevr\", 3, match_value=False, timeout=20)\n if ok:\n print \"Successfully reinitialized {}.\".format(self.name)\n time.sleep(0.5)\n else:\n print \"Reinitializing {} timed out. Aborting auto_setup.\".format(self.name)\n return\n\n for i in range(3):\n for clear, name in ((self.clear_pu, \"powerup\"),\n (self.clear_stall, \"stall flag\"),\n (self.clear_error, \"error flag\")):\n clear(check=True, wait=False)\n\n ok = []\n for bit, mask in ((RA_POWERUP, 1), (RA_STALL, 1), (RA_ERR, RA_ERR_MASK)):\n ok.append(self._wait_msta_bit(bit, 0, mask, timeout=10))\n if not all(ok):\n print \"Issues with clearing flags for {}\".format(self.name)\n\n try: # Not every environment has pmgr access\n self.pmgr.apply_config(dumb_config=self.name)\n except:\n pass","def reset(self):\n logger.info(\"resetting worker #%i\", self.myid)\n self.model.projection = self.model.projection.empty_like()\n self.finished = False","def resetDetector (self):\n self.mpr121._reset ()","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 test_do_boss_calibs_one_flat_coobserve(self):\n cmdState = CmdState.DoBossCalibsCmd()\n cmdState.nFlat = 1\n sopTester.updateModel('guider', TestHelper.guiderState['apogeemangaDitherLoaded'])\n sopTester.updateModel('mcp', TestHelper.mcpState['apogee_parked'])\n sopTester.updateModel('apogee', TestHelper.apogeeState['B_open'])\n self._do_boss_calibs(8, 38, 0, 0, cmdState)","def __init__(self, calibration_patterns, pattern_size=(9,6), retain_calibration_patterns=False):\n self.camera_matrix = None\n self.distortion_coef = None\n self.calibration_patterns_success = []\n self.calibration_patterns_error = []\n self.cal_dist_and_mtx(calibration_patterns, pattern_size, retain_calibration_patterns)","def reset(self):\n p.resetSimulation()\n p.setPhysicsEngineParameter(numSolverIterations=150)\n p.setTimeStep(self._time_step)\n p.setGravity(0, 0, -9.8)\n\n # load plane\n p.loadURDF(os.path.join(pybullet_data.getDataPath(), \"plane.urdf\"), [0, 0, 0])\n # load robot\n self._darwin = DarwinopEnv()\n\n # Let the world run for a bit\n for _ in range(20):\n p.stepSimulation()","def autoAnalyze(self):\n print(\"Perfoming full automatic analysis...\")\n t1=time.perf_counter()\n self.cleanUp()\n self.figure_rois()\n self.figure_roi_inspect_all()\n self.figure_dGoR_roi(showEach=False,saveAs=self.folderSave+\"/avg.png\")\n self.figure_dGoR_roi(showEach=True,saveAs=self.folderSave+\"/each.png\")\n self.index()\n print(\"analysis completed in %.02f sec\"%(time.perf_counter()-t1))","def initialize(self) -> None:\n # Set motors to stop, read encoder values for starting point\n self.drive.arcadeDrive(0, 0)\n self.drive.resetEncoders()","def reset_solver(self):\n self.total_iterations = 0\n self.active_constraints_index = 0\n self.active_constraints_set = False\n return","def reset(self):\n # Clear mutable data, but leave the immutables intact\n self.train_data = {}\n self.val_data = {}\n self.test_data = {}\n self.model_files = []\n self.custom_data = {}\n # Remove all the physical assets\n for item in os.scandir(self.root_path):\n os.remove(item.path)\n # Reserialize\n self.serialize()","def __clear_all(self,event):\n \n self.CoagS = \\\n self.CoagS_term = \\\n self.GR_term = \\\n self.J_time = \\\n self.J = \\\n self.J_lims = \\\n self.mmd_time = \\\n self.mmd_dp = \\\n self.mmd_time_sr = \\\n self.mmd_dp_sr = np.array([])\n \n # Initialize all np.nan variables\n self.J_peak = \\\n self.J_halfmax = \\\n self.J_median = \\\n self.gr = np.nan\n \n # Clears polygon used to outline particle mode\n self.polyx = \\\n self.polyy = \\\n self.polyx_out = \\\n self.polyy_out = np.array([])\n self.poly.set_xy(np.ones((2,2))*np.nan)\n self.poly_out.set_xy(np.ones((2,2))*np.nan)\n \n self.box_gr.set_val(\"%.2f\" % self.gr)\n self.box_J_peak.set_val(\"%.2f\" % self.J_peak)\n self.box_J_median.set_val(\"%.2f\" % self.J_median)\n self.box_J_halfmax.set_val(\"%.2f\" % self.J_halfmax)\n\n # clear average mode diameters and fit\n self.mmd_plot.set_data(np.nan,np.nan)\n self.mmd_plot_sr.set_data(np.nan,np.nan)\n self.mmd_fit_sr.set_data(np.nan,np.nan)\n self.J_plot.set_data(np.nan,np.nan)\n self.J_fit.set_data(np.nan,np.nan)\n self.J_vertical_line1.set_xdata(np.nan)\n self.J_vertical_line2.set_xdata(np.nan)\n self.gr_term_plot.set_data(np.nan,np.nan)\n self.coags_term_plot.set_data(np.nan,np.nan)\n self.dNdt_term_plot.set_data(np.nan,np.nan)\n\n plt.draw()","def on_iteration_start(self):\n\n self.Xfprv = self.Xf.copy()\n if (not self.opt['FastSolve'] or isinstance(self.backtrack,\n BacktrackRobust)):\n self.Yfprv = self.Yf.copy()\n\n if self.opt['Monotone']:\n if self.k == 0:\n self.objfn = self.eval_objfn()\n self.objfn_prev = self.objfn","def __init__(self):\n self.secs_to_ave = 2 #time to integrate gas detector\n\t\tself.initErrorCheck() #Checks for errors and trimming","def stage(self):\n\n # prepare projected land allocation data\n self.prep_projected()\n\n # prepare base land use data\n self.prep_base()\n\n # harmonize grid area between projected and base layer land allocation\n self.harmony()\n\n # apply constraints\n self.set_constraints()\n\n # create kernel density filter if not running multiple jobs\n self.kernel_filter()\n\n # set data for step zero\n self.set_step_zero()","def reset(self):\n # self state is velocity, observation is velocity\n # self._state = np.random.uniform(0, self.GOAL_VELOCITY, size=(self.num_cars,))\n # print(\"In reset function\", self.initialized)\n if self.initialized:\n traci.close()\n sumoProcess = subprocess.Popen([self.sumoBinary, \"-c\", self.cfgfn, \"--remote-port\", str(self.PORT)], stdout=sys.stdout, stderr=sys.stderr)\n traci.init(self.PORT)\n traci.simulationStep()\n if not self.initialized:\n self.vehIDs = traci.vehicle.getIDList()\n print(\"ID List in reset\", self.vehIDs)\n self.initialized = True\n self._state = np.array([traci.vehicle.getSpeed(vID) for vID in self.controllable])\n observation = np.copy(self._state)\n return observation","def reset(self):\n\n self.needReset = False\n self._reset_limits()\n self._reset_integration_grid()\n\n if self.filamentBeam and not hasattr(self, 'dimExy'):\n rMax = self.nrays\n rE = np.random.uniform(self.E_min, self.E_max, rMax)\n rTheta = np.random.uniform(self.Theta_min, self.Theta_max, rMax)\n rPsi = np.random.uniform(self.Psi_min, self.Psi_max, rMax)\n tmpEspread = self.eEspread\n self.eEspread = 0\n DistI = self.build_I_map(rE, rTheta, rPsi)[0]\n self.Imax = np.max(DistI) * 1.2\n self.nrepmax = np.floor(rMax / len(np.where(\n self.Imax * np.random.rand(rMax) < DistI)[0]))\n self.eEspread = tmpEspread\n else:\n self.Imax = 0.\n \"\"\"Preparing to calculate the total flux integral\"\"\"\n self.xzE = (self.E_max - self.E_min) *\\\n (self.Theta_max - self.Theta_min) *\\\n (self.Psi_max - self.Psi_min)\n self.fluxConst = self.Imax * self.xzE","def remove_all(self):\n self.initial = None\n self.contour = None\n self.control_points = []","def preCalibrate(self):\n self._write_enabled = False\n self.start_recording()\n\n origin = (int(self.disp.dispsize[0] / 4), int(self.disp.dispsize[1] / 4))\n size = (int(2 * self.disp.dispsize[0] / 4), int(2 * self.disp.dispsize[1] / 4))\n\n videoFile = os.path.join(c.CALIBVIDEODIR, \"--- cal_movie_1.mov\")\n\n # Initialise a PsychoPy MovieStim\n mov = visual.MovieStim3(self.video_win, videoFile, flipVert=False)\n\n print(\"------------> Pre-calibration process started.\")\n print(\"------------> When correctly positioned press \\'space\\' to start the calibration.\")\n\n while mov.status != visual.FINISHED:\n if not self.gaze:\n continue\n\n self.screen.clear()\n\n # Add the MovieStim to a PyGaze Screen instance.\n self.screen.screen.append(mov)\n\n gaze_sample = copy.copy(self.gaze[-1])\n\n validity_colour = (255, 0, 0)\n\n if gaze_sample['right_gaze_origin_validity'] and gaze_sample['left_gaze_origin_validity']:\n left_validity = 0.15 < gaze_sample['left_gaze_origin_in_trackbox_coordinate_system'][2] < 0.85\n right_validity = 0.15 < gaze_sample['right_gaze_origin_in_trackbox_coordinate_system'][2] < 0.85\n if left_validity and right_validity:\n validity_colour = (0, 255, 0)\n\n self.screen.draw_line(colour=validity_colour, spos=origin, epos=(origin[0] + size[0], origin[1]), pw=1)\n self.screen.draw_line(colour=validity_colour, spos=origin, epos=(origin[0], origin[1] + size[1]), pw=1)\n self.screen.draw_line(colour=validity_colour,\n spos=(origin[0], origin[1] + size[1]),\n epos=(origin[0] + size[0], origin[1] + size[1]),\n pw=1)\n self.screen.draw_line(colour=validity_colour,\n spos=(origin[0] + size[0], origin[1] + size[1]),\n epos=(origin[0] + size[0], origin[1]),\n pw=1)\n\n right_eye, left_eye, distance = None, None, []\n if gaze_sample['right_gaze_origin_validity']:\n distance.append(round(gaze_sample['right_gaze_origin_in_user_coordinate_system'][2] / 10, 1))\n right_pos = gaze_sample['right_gaze_origin_in_trackbox_coordinate_system']\n right_eye = ((1 - right_pos[0]) * size[0] + origin[0], right_pos[1] * size[1] + origin[1])\n self.screen.draw_circle(colour=validity_colour,\n pos=right_eye,\n r=int(self.disp.dispsize[0] / 100),\n pw=5,\n fill=True)\n\n if gaze_sample['left_gaze_origin_validity']:\n distance.append(round(gaze_sample['left_gaze_origin_in_user_coordinate_system'][2] / 10, 1))\n left_pos = gaze_sample['left_gaze_origin_in_trackbox_coordinate_system']\n left_eye = ((1 - left_pos[0]) * size[0] + origin[0], left_pos[1] * size[1] + origin[1])\n self.screen.draw_circle(colour=validity_colour,\n pos=left_eye,\n r=int(self.disp.dispsize[0] / 100),\n pw=5,\n fill=True)\n\n self.screen.draw_text(text=\"Current distance to the eye tracker: {0} cm.\".format(self._mean(distance)),\n pos=(int(self.disp.dispsize[0] / 2), int(self.disp.dispsize[1] * 0.9)),\n colour=(255, 255, 255),\n fontsize=20)\n\n self.disp.fill(self.screen)\n self.disp.show()\n\n key = self._getKeyPress()\n if key == \"space\":\n break\n\n\n\n if mov.status != visual.FINISHED:\n # pause and discard video for the audio to stop as well\n mov.pause()\n self.screen.screen.remove(mov)\n #video_win.close()\n del mov\n self.screen.clear()\n clock.pause(1000)\n return True\n else:\n return False","def steering_calibration(self):\n\n # Minimum change of rotary encoder per 100 ms to detect stall\n min_difference = 5\n # Calibration motor power in percentage (absolute)\n calibration_power = 30\n\n print('Calibration of steering axis started')\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n last_pos = 99999999 # any super big number\n # Left turn calibration\n while abs(current_pos - last_pos) > min_difference:\n last_pos = current_pos\n self.brick_pi.set_motor_power(self.motor_steer, calibration_power)\n time.sleep(0.1)\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n\n self.brick_pi.set_motor_power(self.motor_steer, 0)\n time.sleep(0.1)\n print('Reset motor encoder after left turn: 0')\n self.brick_pi.reset_motor_encoder(self.motor_steer)\n\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n last_pos = 99999999 # any super big number\n # Right turn calibration\n while abs(current_pos - last_pos) > min_difference:\n last_pos = current_pos\n self.brick_pi.set_motor_power(self.motor_steer, -calibration_power)\n time.sleep(0.1)\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n\n self.brick_pi.set_motor_power(self.motor_steer, 0)\n time.sleep(0.1)\n self.brick_pi.offset_motor_encoder(self.motor_steer, current_pos / 2)\n self.steering_limit = abs(\n self.brick_pi.get_motor_encoder(self.motor_steer))\n print('Offset motor encoder after right turn: ' +\n str(self.brick_pi.get_motor_encoder(self.motor_steer)))\n\n self.brick_pi.set_motor_position(self.motor_steer, 0)\n print('Calibration of steering axis completed')","def reset(self):\n self._proportional = 0\n self._integral = 0\n self._derivative = 0\n\n self._last_time = self._current_time()\n self._last_output = None\n self._last_input = None","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 reset(self):\n self.acc_loss = 0\n self.norm_term = 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 reset(self):\n self.__init__(self.subDomainnumMonomers, self.dim, self.b, self.subDomainNc, self.keepCL, position = self.positions)","def _deconfigure(self):\n \n # TODO: the deconfiguration should happen in reverse order of the\n # initialization:\n\n # reset scanID, frequencyBand in case they're not reset\n self._scan_ID = 0\n self._frequency_band = 0\n\n # unsubscribe from TMC events\n for event_id in list(self._events_telstate.keys()):\n self._events_telstate[event_id].unsubscribe_event(event_id)\n self._events_telstate = {}\n\n # unsubscribe from FSP state change events\n for fspID in list(self._events_state_change_fsp.keys()):\n proxy_fsp = self._proxies_fsp[fspID - 1]\n proxy_fsp.unsubscribe_event(self._events_state_change_fsp[fspID][0]) # state\n proxy_fsp.unsubscribe_event(self._events_state_change_fsp[fspID][1]) # healthState\n del self._events_state_change_fsp[fspID]\n del self._fsp_state[self._fqdn_fsp[fspID - 1]]\n del self._fsp_health_state[self._fqdn_fsp[fspID - 1]]\n\n # send assigned VCCs and FSP subarrays to IDLE state\n # TODO: check if vcc fsp is in scanning state (subarray \n # could be aborted in scanning state) - is this needed?\n self._group_vcc.command_inout(\"GoToIdle\")\n self._group_fsp_corr_subarray.command_inout(\"GoToIdle\")\n self._group_fsp_pss_subarray.command_inout(\"GoToIdle\")\n self._group_fsp_pst_subarray.command_inout(\"GoToIdle\")\n\n # change FSP subarray membership\n data = tango.DeviceData()\n data.insert(tango.DevUShort, self._subarray_id)\n # self.logger.info(data)\n self._group_fsp.command_inout(\"RemoveSubarrayMembership\", data)\n self._group_fsp.remove_all()\n\n\n # remove channel info from FSP subarrays\n # already done in GoToIdle\n self._group_fsp_corr_subarray.remove_all()\n self._group_fsp_pss_subarray.remove_all()\n self._group_fsp_pst_subarray.remove_all()\n\n # reset all private dat to their initialization values:\n self._scan_ID = 0 \n self._config_ID = \"\"\n self._last_received_delay_model = \"{}\"\n self._last_received_jones_matrix = \"{}\"\n self._last_received_beam_weights = \"{}\"\n\n # TODO: need to add 'GoToIdle' for VLBI and PST once implemented:\n # TODO: what happens if \n # # sp_corr_subarray_proxy.State() == tango.DevState.OFF ??\n # that should not happen\n for fsp_corr_subarray_proxy in self._proxies_fsp_corr_subarray:\n if fsp_corr_subarray_proxy.State() == tango.DevState.ON:\n fsp_corr_subarray_proxy.GoToIdle()\n for fsp_pss_subarray_proxy in self._proxies_fsp_pss_subarray:\n if fsp_pss_subarray_proxy.State() == tango.DevState.ON:\n fsp_pss_subarray_proxy.GoToIdle()\n for fsp_pst_subarray_proxy in self._proxies_fsp_pst_subarray:\n if fsp_pst_subarray_proxy.State() == tango.DevState.ON:\n fsp_pst_subarray_proxy.GoToIdle()","def create_calibration_path(Env):\n \n hotpixelkiller = Env.create_path('hotpixelkiller')\n hotpixelkiller.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': rawfile_air }) \n hotpixelkiller.add_processor(name=\"M26HotPixelKiller\")\n\n cluster_calibrator_mc = Env.create_path('cluster_calibrator_mc')\n cluster_calibrator_mc.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': rawfile_air }) \n cluster_calibrator_mc.add_processor(name=\"M26Clusterizer\")\n cluster_calibrator_mc.add_processor(name=\"M26CogHitMaker\")\n cluster_calibrator_mc.add_processor(name=\"M26ClusterCalibrationFromMC\")\n\n clusterizer = Env.create_path('clusterizer')\n clusterizer.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': rawfile_air }) \n clusterizer.add_processor(name=\"M26Clusterizer\")\n clusterizer.add_processor(name=\"LCIOOutput\")\n\n correlator = Env.create_path('correlator')\n correlator.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" }) \n correlator.add_processor(name=\"M26CogHitMaker\")\n correlator.add_processor(name=\"RawDQM\") \n correlator.add_processor(name=\"TelCorrelator\")\n \n kalman_aligner_1 = Env.create_path('kalman_aligner_1')\n kalman_aligner_1.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" }) \n kalman_aligner_1.add_processor(name=\"M26CogHitMaker\")\n kalman_aligner_1.add_processor(name=\"AlignTF_LC\")\n kalman_aligner_1.add_processor(name=\"PreAligner\")\n \n kalman_aligner_2 = Env.create_path('kalman_aligner_2')\n kalman_aligner_2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" }) \n kalman_aligner_2.add_processor(name=\"M26CogHitMaker\")\n kalman_aligner_2.add_processor(name=\"AlignTF_TC\")\n kalman_aligner_2.add_processor(name=\"TelAligner\")\n \n telescope_dqm = Env.create_path('telescope_dqm')\n telescope_dqm.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" }) \n telescope_dqm.add_processor(name=\"M26CogHitMaker\")\n telescope_dqm.add_processor(name=\"AlignTF_TC\")\n telescope_dqm.add_processor(name=\"TelescopeDQM\")\n \n cluster_calibration_1 = Env.create_path('cluster_calibration_1')\n cluster_calibration_1.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': \"tmp.slcio\" }) \n cluster_calibration_1.add_processor(name=\"M26CogHitMaker\") \n cluster_calibration_1.add_processor(name=\"AlignTF_TC\")\n cluster_calibration_1.add_processor(name=\"M26ClusterCalibrator\")\n \n kalman_aligner_3 = Env.create_path('kalman_aligner_3')\n kalman_aligner_3.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" }) \n kalman_aligner_3.add_processor(name=\"M26GoeHitMaker\")\n kalman_aligner_3.add_processor(name=\"AlignTF_TC\")\n kalman_aligner_3.add_processor(name=\"TelAligner\")\n \n cluster_calibration_2 = Env.create_path('cluster_calibration_2')\n cluster_calibration_2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': \"tmp.slcio\" }) \n cluster_calibration_2.add_processor(name=\"M26GoeHitMaker\") \n cluster_calibration_2.add_processor(name=\"AlignTF_TC\")\n cluster_calibration_2.add_processor(name=\"M26ClusterCalibrator\")\n\n correlator2 = Env.create_path('correlator2')\n correlator2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" })\n correlator2.add_processor(name=\"M26GoeHitMaker\") \n correlator2.add_processor(name=\"RawDQM\", params={'RootFileName': 'RawDQM2.root'})\n correlator2.add_processor(name=\"TelCorrelator\", params={'OutputRootFileName': 'XCorrelator2.root'})\n \n kalman_aligner_4 = Env.create_path('kalman_aligner_4')\n kalman_aligner_4.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" }) \n kalman_aligner_4.add_processor(name=\"M26GoeHitMaker\") \n kalman_aligner_4.add_processor(name=\"AlignTF_LC\")\n kalman_aligner_4.add_processor(name=\"PreAligner\")\n \n kalman_aligner_5 = Env.create_path('kalman_aligner_5')\n kalman_aligner_5.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" }) \n kalman_aligner_5.add_processor(name=\"M26GoeHitMaker\") \n kalman_aligner_5.add_processor(name=\"AlignTF_TC\")\n kalman_aligner_5.add_processor(name=\"TelAligner\") \n \n telescope_dqm2 = Env.create_path('telescope_dqm2')\n telescope_dqm2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': \"tmp.slcio\" }) \n telescope_dqm2.add_processor(name=\"M26GoeHitMaker\") \n telescope_dqm2.add_processor(name=\"AlignTF_TC\")\n telescope_dqm2.add_processor(name=\"TelescopeDQM\", params={'RootFileName' : 'TelescopeDQM2.root'})\n \n \n # create sequence of calibration paths \n calpath= [ hotpixelkiller , \n cluster_calibrator_mc,\n clusterizer,\n correlator, \n kalman_aligner_1, \n kalman_aligner_2, \n kalman_aligner_2, \n kalman_aligner_2, \n telescope_dqm, \n cluster_calibration_1, \n kalman_aligner_3, \n kalman_aligner_3, \n kalman_aligner_3, \n cluster_calibration_2, \n cluster_calibration_2, \n cluster_calibration_2, \n cluster_calibration_2, \n cluster_calibration_2, \n cluster_calibration_2, \n cluster_calibration_2, \n cluster_calibration_2,\n correlator2, \n kalman_aligner_4, \n kalman_aligner_5, \n kalman_aligner_5, \n kalman_aligner_5, \n telescope_dqm2, \n ]\n \n return calpath","def reset(self, evaluate=False):\n self.reset_env()\n for _ in range(20):\n self.__publish_cmd(0.0, 0.0)\n self.rate.sleep()\n self.__publish_cmd(1.0, 0.0)\n self.rate.sleep()\n self.prev_pos_index, _ = self.__find_closest_point(1088)\n self.prev_reward = 0.0\n \n \n # If this run isn't being evaluated, we need to add some randomness to the starting point or else the agents will not learn well\n # if not evaluate:\n # random_steps = np.random.randint(0, 20)\n # ref = self.ref_track\n # l = len(ref)\n # curr_pos_index, _ = self.__find_closest_point(self.prev_pos_index)\n # for _ in range(random_steps):\n # ranges = self.get_state()\n # max_range = np.max(ranges)\n # indices = np.where(ranges>=max_range)\n # target_index = np.mean(indices)\n # angle = ((2 * self.lidar_angle) / len(ranges)) * target_index - self.lidar_angle\n \n # # future_pos_index = (curr_pos_index + 20) % l\n # # goal_point = ref[future_pos_index]\n # # print(goal_point)\n # # curr_pos = copy.copy(self.pos) # [x, y, yaw, speed]\n # # dx = goal_point[0] - curr_pos[0]\n # # dy = goal_point[1] - curr_pos[1]\n # # yaw = curr_pos[2]\n # # xgv = (dx * np.cos(yaw)) + (dy * np.sin(yaw))\n # # ygv = (-dx * np.sin(yaw)) + (dy * np.cos(yaw))\n # # angle = -np.arctan2(ygv,xgv)\n # # print(angle)\n # self.step(angle)\n # curr_pos_index, _ = self.__find_closest_point(curr_pos_index)\n \n # self.prev_pos_index = copy.copy(curr_pos_index)\n\n \n # print(self.prev_pos_index)\n\n return","def teardown_simulate(self):\n self.positions = self.calibrated_positions","def calibrate(science_list_fname, master_flat_fname, master_dark_fname, hp_map_fname, bp_map_fname, mask_bad_pixels = False,\n clean_Bad_Pix=True, replace_nans=True, background_fname = None, outdir = None):\n\n #Get the list of science frames\n #science_list = np.loadtxt(science_list_fname, dtype=str)\n science_list = science_list_fname\n\n #Open the master dark\n master_dark_hdu = f.open(master_dark_fname)\n master_dark = master_dark_hdu[0].data\n dark_shape = np.shape(master_dark)\n print((\"Subtracting {} from each flat file\".format(master_dark_fname)))\n dark_exp_time = master_dark_hdu[0].header['EXPTIME']\n\n #Open the master flat\n master_flat_hdu = f.open(master_flat_fname)\n master_flat = master_flat_hdu[0].data\n print((\"Dividing each file by {}\".format(master_flat_fname)))\n dark_exp_time = master_dark_hdu[0].header['EXPTIME']\n\n #Open the bad pixel map from flat\n bp_map_hdu = f.open(bp_map_fname)\n bad_pixel_map = bp_map_hdu[0].data\n bad_pixel_map_bool = np.array(bad_pixel_map, dtype=bool)\n print((\"Using bad pixel map {}\".format(bp_map_fname)))\n\n #now if hot pixel map from dark is also given\n if hp_map_fname != None:\n hp_map_hdu = f.open(hp_map_fname)\n hot_pixel_map = hp_map_hdu[0].data\n bad_pixel_map_bool = np.logical_or(bad_pixel_map_bool, hot_pixel_map.astype(bool) )\n\n\n if background_fname != None:\n background_hdu = f.open(background_fname)\n background = background_hdu[0].data\n print(\"Subtracting background frame {} from all science files\".format(background_fname))\n\n\n for fname in science_list:\n #Open the file\n print((\"Calibrating {}\".format(fname\n )))\n hdu = f.open(fname)\n data = hdu[0].data\n science_exp_time = hdu[0].header['EXPTIME']\n\n if dark_exp_time != science_exp_time:\n warnings.warn(\"The master dark file doesn't have the same exposure time as the data. We'll scale the dark for now, but this isn't ideal\", UserWarning)\n factor = science_exp_time/dark_exp_time\n else:\n factor = 1.\n\n #Subtract the dark, divide by flat\n redux = ((data - factor*master_dark)/master_flat)\n #get rid of crazy values at bad pixel\n redux = redux*~bad_pixel_map_bool\n\n if background_fname != None:\n redux -= background\n\n if clean_Bad_Pix:\n # plt.plot(bad_pixel_map_bool)\n redux = cleanBadPix(redux, bad_pixel_map_bool)\n #redux = ccdproc.cosmicray_lacosmic(redux, sigclip=5)[0]\n\n # redux = ccdproc.cosmicray_median(redux, mbox=7, rbox=5, gbox=7)[0]\n\n #Mask the bad pixels if the flag is set\n if mask_bad_pixels:\n redux *= ~bad_pixel_map_bool\n\n if replace_nans:\n # nan_map = ~np.isfinite(redux)\n # redux = cleanBadPix(redux, nan_map)\n # plt.imshow(redux-after)\n nanmask = np.isnan(redux) #nan = True, just in case this is useful\n redux = np.nan_to_num(redux)\n\n #Put the cablibrated data back in the HDU list\n hdu[0].data = redux\n\n #Add pipeline version and history keywords\n vers = version.get_version()\n hdu[0].header.set('PL_VERS',vers,'Version of pipeline used for processing')\n hdu[0].header['HISTORY'] = \"Subtracting {} from each flat file\".format(master_dark_fname)\n hdu[0].header['HISTORY'] = \"Dividing each file by {}\".format(master_flat_fname)\n\n if background_fname != None:\n hdu[0].header['HISTORY'] = \"Subtracted background frame {}\".format(background_fname)\n\n if mask_bad_pixels:\n hdu[0].header['HISTORY'] = \"Masking all bad pixels found in {}\".format(bp_map_fname)\n\n if clean_Bad_Pix:\n hdu[0].header['HISTORY'] = \"Cleaned all bad pixels found in {} using a median filter\".format(bp_map_fname)\n\n # #Append the bad pixel list to the HDU list\n # hdu.append(f.PrimaryHDU([bad_pixel_map]))\n # hdu[1].header['HISTORY'] = \"Appending bad pixel map :{}\".format(bp_map_fname)\n # hdu[1].header['HISTORY'] = \"0 = good pixel\"\n # hdu[1].header['HISTORY'] = \"1 = bad pixel from flat fields\"\n # hdu[1].header['HISTORY'] = \"2 = hot pixel from darks\"\n\n outname = fname.split('.')[0]+\"_calib.fits\"\n\n #if an output directory is specified we can write out to that directory instead\n #making sure to take only the stuff after the last '/' to avoid directory issues from fname\n if outdir:\n outname = outdir + fname.split('/')[-1]\n\n print((\"Writing calibrated file to {}\".format(outname)))\n #Save the calibrated file\n hdu.writeto(outname, overwrite=True)\n\n # f.PrimaryHDU(redux).writeto('redux_'+i, overwrite = True)","def calibrate(self):\n if self.iCAL_required:\n logger.info(\"iCAL-sensitive registers were modified, performing calibration...\")\n return self._run_ical()\n else:\n logger.info(\"iCAL-sensitive registers were not modified, skipping calibration...\")\n return 0 # Still success","def reset(self):\n self.baseline = None\n self.cut = None\n self.manual_push = 0","def reset(self):\n\n # initialize gym env variables\n self.finish = False\n self.curr_step = -1\n self.curr_episode += 1\n\n # initialize target position\n self.target = np.random.uniform(-10.0,10.0,size=(2))\n\n # initialize sheep positions\n if self.fixed_reset:\n init_sheep_pose = np.array([75.0, 75.0])\n self.sheep_poses = (np.random.uniform(-50.0, 50.0, \n size=(self.num_sheep,2))) + init_sheep_pose[None,:]\n else:\n init_sheep_pose = np.random.uniform(-self.init_sheep_root, \n self.init_sheep_root, size=(2))\n self.sheep_poses = (np.random.uniform(-self.init_sheep_range, \n self.init_sheep_range, size=(self.num_sheep,2))) \\\n + init_sheep_pose[None,:]\n self.sheep_com = self.sheep_poses.mean(axis=0)\n\n # get the farthest sheep and radius of the sheep\n dist_to_com = np.linalg.norm((self.sheep_poses - self.sheep_com[None,:]), axis=1)\n self.farthest_sheep = self.sheep_poses[np.argmax(dist_to_com),:]\n self.radius_sheep = np.array([np.max(dist_to_com)])\n\n # update distance to target\n self.target_distance = np.linalg.norm(self.target - self.sheep_com)\n\n # initialize values for reward estimation\n self.init_radius_sheep = self.radius_sheep\n self.init_target_distance = self.target_distance\n\n # initialize dog position\n if self.fixed_reset:\n init_dog_pose = np.array([0.0,75.0])\n else:\n init_theta = np.random.uniform(-np.pi,np.pi)\n init_dog_pose = init_sheep_pose + self.init_dog_distance*np.array([np.cos(init_theta), \n np.sin(init_theta)])\n self.dog_pose = init_dog_pose\n\n # initialize inertia\n self.inertia = np.ones((self.num_sheep, 2))\n\n # initialize episode reward and length\n self.episode_reward = 0\n self.episode_length = 0\n\n # get the state, reward, finish, info\n state = self._get_state()\n \n return state","def full_reset(self):\n self.at_cmd('CFUN=1')","def analyse(self):\n self.__try_fitting()\n self.second.rotate()\n self.__try_fitting()","def clear(self):\n # K_p * e\n self.PTerm_x = 0.0\n self.PTerm_y = 0.0\n self.PTerm_z = 0.0\n self.PTerm_rot_z = 0.0\n # K_i * integral(e)\n self.ITerm_x = 0.0\n self.ITerm_y = 0.0\n self.ITerm_z = 0.0\n self.ITerm_rot_z = 0.0\n\n # K_d * derivative(e)\n self.DTerm_x = 0.0\n self.DTerm_y = 0.0\n self.DTerm_z = 0.0\n self.DTerm_rot_z = 0.0\n self.last_error_x = 0.0\n self.last_error_y = 0.0\n self.last_error_z = 0.0\n self.last_error_rot_z = 0.0\n \n # Windup Guard for integrator\n self.windup_guard = 0.5\n\n self.output_x = 0.0\n self.output_y = 0.0\n self.output_z = 0.0\n self.output_rot_z = 0.0","def reset(self):\n self.robot_path_ind = 0\n self.goal_path_ind = None\n self.global_plan = Path()","def platform_auto_calibrate(self):\n self.platform_auto_calibrate_servos()\n self.platform_auto_calibrate_imu()","def cleanup(self):\n\n self.PLC['1'].set_plc_mode(0)\n self.PLC['1'].plc_clear('all')\n super(Test200SmartSanityClear005, self).cleanup()","def resetTransformations():\n dislin.trfres()","def _reset(self):\n if self.mode not in ['auto', 'min', 'max']:\n warnings.warn('Learning Rate Plateau Reducing mode %s is unknown, '\n 'fallback to auto mode.' % (self.mode),\n RuntimeWarning)\n self.mode = 'auto'\n if (self.mode == 'min' or\n (self.mode == 'auto' and 'acc' not in self.monitor)):\n self.monitor_op = lambda a, b: np.less(a, b - self.min_delta)\n self.best = np.Inf\n else:\n self.monitor_op = lambda a, b: np.greater(a, b + self.min_delta)\n self.best = -np.Inf\n self.cooldown_counter = 0\n self.wait = 0","def reset(self):\n log.debug(\"RESET\")\n self.ref_pos_x = -1\n self.ref_pos_y = -1\n self.ref_pos_z = -1\n self.pos_x = -1\n self.pos_y = -1\n self.pos_z = -1\n self.yaw = 0\n self.throw_ongoing = False","def finalize(self):\n pass\n #fftw2py.clean_fftw_solver(self.output_field.dimension)"],"string":"[\n \"def rm_calibration(self):\\n\\n self.bin_edges_kev = None\",\n \"def _doCalibration(self):\\n self._cmdCalibration(2)\",\n \"def reset(self):\\n self.resetPos()\\n self.vx, self.vy = 0, 0\\n self.accel, self.dangle = 0, 0\\n self.crashed = False\\n self.timeDriving, self.score, self.checkpoint, self.laps = 0, 0, 0, 0\\n self.targetCheckpointPos = self.maze.checkpoints[0].getMidInt()\\n self.inputColour = [sensor_colours[0] for i in range(self.dimensions[0])]\\n self.scan = np.array([0 for i in range(self.dimensions[0])])\\n self.cost = [0 for i in range(6)]\\n #Extrapos for CTS LOS\\n self.extrapos = []\",\n \"def reconstruct(self):\\n self.print_tee(\\\"starting reconstruction\\\", self.log_file)\\n\\n # #############################################\\n # estimate SIM parameters\\n # #############################################\\n # estimate frequencies\\n tstart = time.time() # since done using joblib, process_time() is not useful...\\n\\n if self.use_fixed_frq:\\n self.frqs = self.frqs_guess\\n self.print_tee(\\\"using fixed frequencies\\\", self.log_file)\\n else:\\n if self.find_frq_first:\\n self.frqs = self.estimate_sim_frqs(self.imgs_ft, self.imgs_ft, self.frqs_guess)\\n else:\\n self.print_tee(\\\"doing phase demixing prior to frequency finding\\\", self.log_file)\\n self.separated_components_ft = separate_components(self.imgs_ft, self.phases_guess, np.ones((self.nangles, self.nphases)))\\n imgs1 = np.expand_dims(self.separated_components_ft[:, 0], axis=1)\\n imgs2 = np.expand_dims(self.separated_components_ft[:, 1], axis=1)\\n self.frqs = self.estimate_sim_frqs(imgs1, imgs2, self.frqs_guess)\\n\\n tend = time.time()\\n self.print_tee(\\\"fitting frequencies took %0.2fs\\\" % (tend - tstart), self.log_file)\\n\\n # estimate phases\\n tstart = time.process_time()\\n if self.use_fixed_phase:\\n self.phases = self.phases_guess\\n self.amps = np.ones((self.nangles, self.nphases))\\n self.print_tee(\\\"Using fixed phases\\\", self.log_file)\\n else:\\n self.phases, self.amps = self.estimate_sim_phases(self.frqs, self.phases_guess)\\n\\n tend = time.process_time()\\n self.print_tee(\\\"estimated %d phases in %0.2fs\\\" % (self.nangles * self.nphases, tend - tstart), self.log_file)\\n\\n # separate components\\n self.separated_components_ft = separate_components(self.imgs_ft, self.phases, self.amps)\\n\\n # estimate modulation depths and power spectrum fit parameters\\n tstart = time.process_time()\\n # for the moment, need to do this feet even if have fixed mod depth, because still need the\\n # power spectrum parameters\\n self.mod_depths, self.power_spectrum_params, self.pspec_masks = self.estimate_mod_depths()\\n\\n if self.use_fixed_mod_depths:\\n self.mod_depths = np.zeros((self.nangles, self.nphases))\\n self.mod_depths[:, 0] = 1\\n for jj in range(1, self.nphases):\\n self.mod_depths[:, jj] = self.mod_depths_guess\\n\\n # also correct power spectrum params\\n self.power_spectrum_params[:, jj, 2] = self.mod_depths[:, jj]\\n\\n tend = time.process_time()\\n self.print_tee('estimated %d modulation depths in %0.2fs' % (self.nangles, tend - tstart), self.log_file)\\n\\n # #############################################\\n # estimate modulation contrast to noise ratio for raw images\\n # #############################################\\n mcnr = np.zeros((self.nangles, self.nphases))\\n for ii in range(self.nangles):\\n for jj in range(self.nphases):\\n mcnr[ii, jj] = get_mcnr(self.imgs_ft[ii, jj], self.frqs[ii], self.fx, self.fy, self.fmax)\\n\\n # if mcnr is too low (typically < 1), use guess values instead\\n if self.default_to_guess_on_low_mcnr and np.min(mcnr[ii]) < self.min_mcnr and self.frqs_guess is not None:\\n self.frqs[ii] = self.frqs_guess[ii]\\n self.print_tee(\\\"Angle %d/%d, minimum mcnr = %0.2f is less than the minimum value, %0.2f,\\\"\\n \\\" so fit frequency will be replaced with guess\\\"\\n % (ii + 1, self.nangles, np.min(mcnr[ii]), self.min_mcnr), self.log_file)\\n\\n for jj in range(self.nphases):\\n mcnr[ii, jj] = get_mcnr(self.imgs_ft[ii, jj], self.frqs[ii], self.fx, self.fy, self.fmax)\\n\\n self.mcnr = mcnr\\n # for convenience, also save periods and angles\\n self.periods = 1 / np.sqrt(self.frqs[:, 0] ** 2 + self.frqs[:, 1] ** 2)\\n self.angles = np.angle(self.frqs[:, 0] + 1j * self.frqs[:, 1])\\n\\n # #############################################\\n # estimate noise in component images\\n # #############################################\\n self.noise_power = self.power_spectrum_params[:, :, -1]\\n\\n # #############################################\\n # SIM reconstruction\\n # #############################################\\n tstart = time.process_time()\\n self.img_sr, self.img_sr_ft, self.components_deconvolved_ft, self.components_shifted_ft, \\\\\\n self.weights, self.weight_norm, self.snr, self.snr_shifted = self.combine_components()\\n # self.img_sr, self.img_sr_ft, self.components_deconvolved_ft, self.components_shifted_ft, \\\\\\n # self.weights, self.weight_norm, self.snr, self.snr_shifted = self.combine_components_fairSIM()\\n tend = time.process_time()\\n\\n self.print_tee(\\\"combining components took %0.2fs\\\" % (tend - tstart), self.log_file)\\n\\n # #############################################\\n # widefield deconvolution\\n # #############################################\\n # get signal to noise ratio\\n wf_noise = get_noise_power(self.widefield_ft, self.fx, self.fy, self.fmax)\\n fit_result, self.mask_wf = fit_power_spectrum(self.widefield_ft, self.otf, self.fx, self.fy, self.fmax, self.fbounds,\\n init_params=[None, self.power_spectrum_params[0, 0, 1], 1, wf_noise],\\n fixed_params=[False, True, True, True])\\n\\n self.pspec_params_wf = fit_result['fit_params']\\n ff = np.sqrt(self.fx[None, :]**2 + self.fy[:, None]**2)\\n sig = power_spectrum_fn([self.pspec_params_wf[0], self.pspec_params_wf[1], self.pspec_params_wf[2], 0], ff, 1)\\n wf_snr = sig / wf_noise\\n # deconvolution\\n wf_decon_ft, wfilter = wiener_deconvolution(self.widefield_ft, self.otf, wf_snr, snr_includes_otf=False)\\n\\n # upsample to make fully comparable to reconstructed image\\n self.widefield_deconvolution_ft = tools.expand_fourier_sp(wf_decon_ft, 2, 2, centered=True)\\n self.widefield_deconvolution = fft.fftshift(fft.ifft2(fft.ifftshift(self.widefield_deconvolution_ft))).real\\n\\n # #############################################\\n # print parameters\\n # #############################################\\n self.print_parameters()\\n\\n try:\\n self.log_file.close()\\n except AttributeError:\\n pass\",\n \"def reset(self):\\n\\t\\t\\n\\t\\t# The measured information, from the shape measurement on the observed image\\n\\t\\tself.mes_x = 0.0\\n\\t\\tself.mes_y = 0.0\\n\\t\\tself.mes_a = 0.0\\n\\t\\tself.mes_b = 0.0\\n\\t\\tself.mes_theta = 0.0 # Sextractor : from -90 to 90 deg\\n\\t\\tself.mes_fwhm = 0.0\\n\\t\\tself.mes_flux = 0.0\\n\\t\\tself.mes_fluxerr = 0.0\\n\\t\\tself.mes_flux_max = 0.0\\n\\n\\t\\tself.mes_sky = 0.0\\n\\t\\tself.mes_sig = 0.0\",\n \"def reset_to_initial_condition(self,check=True):\\n\\t\\t\\tself.dict_csr_rand_and_targetted_dropout_matrices={} #These will start as copies of dict_csr_rand_dropout_matrices, but then certain features will be deleted in a targeted manner\\n\\t\\t\\tself.train_labels___0_unlab__neg1_exclud=self.train_orig_labels.copy()\\n\\t\\t\\tself.set_labels=set(self.train_orig_labels)-{0}\\n\\n\\t\\t\\tself.bool_train_labelled=self.bool_train_orig_labelled.copy()\\n\\t\\t\\tself.bool_train_unlabelled=(self.train_labels___0_unlab__neg1_exclud==0)\\n\\t\\t\\tself.bool_train_excluded=(self.train_labels___0_unlab__neg1_exclud<0)\\n\\t\\t\\t\\n\\t\\t\\tself.num_train=self.csr_train_feats.shape[0]\\n\\t\\t\\tself.num_train_labelled=sum(self.bool_train_labelled)\\n\\t\\t\\tself.num_train_unlabelled=sum(self.bool_train_unlabelled)\\n\\t\\t\\tself.num_train_excluded=sum(self.bool_train_excluded)\\n\\t\\t\\tself.num_train_labelled_initially=sum(self.bool_train_orig_labelled)\\n\\n\\t\\t\\tself.bool_feat_included=(np.ones(self.csr_train_feats.shape[1])>0) #Should be all True now\\n\\t\\t\\tself.bool_feat_excluded=~self.bool_feat_included #Should be all False now\\n\\t\\t\\tself.feat_time_left=np.ones(self.csr_train_feats.shape[1], int)*-1 #Time left until removed\\n\\n\\t\\t\\tif check:\\n\\t\\t\\t\\tself.check_init()\",\n \"def __clear_context(self):\\n self.source_cloud = \\\"\\\"\\n self.target_cloud = \\\"\\\"\\n self.source_cloud_size = 0\\n self.target_cloud_size = 0\\n self.rotation = np.eye(3)\\n self.translation = np.zeros(3)\\n self.scale = 1\\n self.path_to_correspondences = \\\"smooth_net_correspondences.txt\\\"\",\n \"def reset(self):\\n look = [0.4, 0.1, 0.54] \\n distance = 1.5\\n pitch = -90\\n yaw = -90\\n roll = 180\\n pos_range = [0.45, 0.5, 0.0, 0.1]\\n\\n self._view_matrix = p.computeViewMatrixFromYawPitchRoll(look, distance, yaw, pitch, roll, 2)\\n fov = 20. + self._cameraRandom * np.random.uniform(-2, 2)\\n aspect = self._width / self._height\\n near = 0.01\\n far = 10\\n self._proj_matrix = p.computeProjectionMatrixFOV(fov, aspect, near, far)\\n\\n self._attempted_grasp = False\\n self._env_step = 0\\n self.terminated = 0\\n\\n p.resetSimulation()\\n p.setPhysicsEngineParameter(numSolverIterations=150)\\n p.setTimeStep(self._timeStep)\\n p.loadURDF(os.path.join(self._urdfRoot, \\\"plane.urdf\\\"), [0, 0, -1])\\n\\n self.tableUid = p.loadURDF(os.path.join(self._urdfRoot, \\\"table/table.urdf\\\"), 0.5000000, 0.00000, -.640000,\\n 0.000000, 0.000000, 0.0, 1.0)\\n\\n p.setGravity(0, 0, -10)\\n self._envStepCounter = 0\\n p.stepSimulation()\\n\\n # place objs\\n if RESUME_NUM is not None:\\n self.model_paths = self.model_paths[RESUME_NUM*3:]\\n self.img_save_cnt = RESUME_NUM\\n self.N_DATA_TO_GENERATE -= RESUME_NUM\\n for _ in tqdm(range(self.N_DATA_TO_GENERATE)):\\n urdfList = []\\n chosen_classes = random.sample(CLASS_NAME, k=3)\\n for _c in chosen_classes:\\n urdfList.append([self.model_paths[_c].pop(), _c])\\n self._objectUids, self._objectClasses = self._randomly_place_objects(urdfList, pos_range)\\n self._observation = self._get_observation()\\n self.img_save_cnt += 1\\n for uid in self._objectUids:\\n p.removeBody(uid)\\n\\n # close-up view\\n for idx, obj_path in enumerate(urdfList):\\n self._objectUids, self._objectClasses = self._place_single_object([obj_path])\\n observation = self._get_closeup(idx)\\n for uid in self._objectUids:\\n p.removeBody(uid)\\n\\n\\n # terminate\\n sys.exit('finish')\\n\\n return np.array(self._observation)\",\n \"def calibrate(): \\n \\n # Calibrate of the run using beam data. Creates a folder cal-files/caltag \\n # containing all calibration data. \\n CalObj = Calibration(steerfiles=steerfiles, name=localcaltag + '-cal') \\n\\n # Set Beam energy\\n CalObj.set_beam_momentum(beamenergy)\\n\\n # Get gearfile and set air as DUT material\\n localgearfile = CalObj.get_filename('gear.xml')\\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='thickness', value=0.0001)\\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='radLength', value=304000.0)\\n \\n # Create list of calibration steps \\n calpath = create_calibration_path(CalObj)\\n \\n # Run the calibration steps \\n CalObj.calibrate(path=calpath,ifile=rawfile_air,caltag=localcaltag)\",\n \"def sweep(self) -> None:\\n self._resource.clear()\\n was_continuous = self.is_continuous\\n self.is_continuous = False\\n self.write(\\\"INIT\\\")\\n self.is_continuous = was_continuous\",\n \"def recalibrate_start(self):\\n self.epoch += 1\\n self.initialize()\\n self.recalibration_i = 0\\n\\n if self.vr_from_epoch is not None and self.epoch >= self.vr_from_epoch:\\n for group in self.param_groups:\\n for p in group['params']:\\n param_state = self.state[p]\\n param_state['gavg'].zero_()\\n param_state['m2'].zero_()\\n\\n # xk is changed to the running_x\\n p.data.zero_().add_(param_state['running_x'])\\n param_state['tilde_x'] = p.data.clone()\",\n \"def reset(self, fullreset=True):\\n self.controlpoints = []\\n self.contour = []\\n self.ext_energies = []\\n self.update()\\n if fullreset:\\n self.optimized = False\",\n \"def start(self):\\n ### input check ### ? or done automaticly, how optional?\\n self.ctx.last_calc2 = None\\n self.ctx.loop_count2 = 0\\n self.ctx.calcs = []\\n self.ctx.successful2 = False\\n\\n # set values, or defaults, default: always converge charge density, crit < 0.00002, max 4 fleur runs\\n self.ctx.max_number_runs = self.inputs.wf_parameters.get_dict().get('relax_runmax', 4)\\n self.ctx.max_force_cycle = self.inputs.wf_parameters.get_dict().get('max_force_cycle', 4)\\n print 'start'\",\n \"def reset(self):\\n\\n self.scaler = None\\n self.isFitted = False\\n self.__create_scaler()\",\n \"def reset(self) -> None:\\n self._successful = False\\n self._measurement_covariance = None\\n self._measurements = None\\n self._base_frame_directions = None\\n self._temperatures = None\\n self._postfit_covariance = None\\n self._postfit_residuals = None\\n self._jacobian = None\\n self._a_priori_state_covariance = None\",\n \"def reset (self):\\n log.debug(\\\"RESET\\\")\\n self.ref_pos_x = -1\\n self.ref_pos_y = -1\\n self.ref_pos_z = -1\\n self.pos_x = -1\\n self.pos_y = -1\\n self.pos_z = -1\\n self.yaw = 0\\n self.tracking = False\\n self.distance_mode = False\\n self.keep_distance = None\\n self.hand_ctrl = False\\n self.timestamp_hand_ctrl = None\\n self.head_hand_x_ref = None\\n self.head_hand_x_dist = None\\n self.palm_landing = False\\n self.palm_landing_approach = False\\n self.yaw_to_consume = 0\\n self.timestamp_keep_distance = time.time()\\n self.wait_before_tracking = None\\n self.timestamp_take_picture = None\\n self.throw_ongoing = False\\n self.scheduled_takeoff = None\\n\\n # When in trackin mode, but no body is detected in current frame,\\n # we make the drone rotate in the hope to find some body\\n # The rotation is done in the same direction as the last rotation done\\n self.body_in_prev_frame = False\\n self.timestamp_no_body = time.time()\\n self.last_rotation_is_cw = True\",\n \"def reset(self):\\n self._coco_gt = COCO()\\n # Create an empty detection array with 7 columns:\\n # (image_id, xmin, ymin, width, height, score, class)\\n self._detections = np.empty(shape=(0, 7))\\n self._images = set()\",\n \"def reset(self) -> None:\\n self.is_run = False\\n self.env_step = 0\\n if self.resume_from_log:\\n self.start_epoch, self.env_step, self.gradient_step = \\\\\\n self.logger.restore_data()\\n\\n self.last_rew, self.last_len = 0.0, 0\\n self.start_time = time.time()\\n if self.train_collector is not None:\\n self.train_collector.reset_stat()\\n\\n if self.train_collector.policy != self.policy:\\n self.test_in_train = False\\n elif self.test_collector is None:\\n self.test_in_train = False\\n\\n if self.test_collector is not None:\\n assert self.episode_per_test is not None\\n assert not isinstance(self.test_collector, AsyncCollector) # Issue 700\\n self.test_collector.reset_stat()\\n test_result = test_episode(\\n self.policy, self.test_collector, self.test_fn, self.start_epoch,\\n self.episode_per_test, self.logger, self.env_step, self.reward_metric\\n )\\n self.best_epoch = self.start_epoch\\n self.best_reward, self.best_reward_std = \\\\\\n test_result[\\\"rew\\\"], test_result[\\\"rew_std\\\"]\\n if self.save_best_fn:\\n self.save_best_fn(self.policy)\\n\\n self.epoch = self.start_epoch\\n self.stop_fn_flag = False\\n self.iter_num = 0\",\n \"def reset(self):\\n super(MorseSmaleComplex, self).reset()\\n\\n self.base_partitions = {}\\n self.merge_sequence = {}\\n\\n self.persistences = []\\n self.min_indices = []\\n self.max_indices = []\\n\\n # State properties\\n self.persistence = 0.0\",\n \"def clean(self):\\n self.decay()\\n self.hit_count = 0.0\\n self.out_layer.cost = 0.0\\n self.batch_loss = 0.0\",\n \"def soft_reset(self) -> None:\\n data = self.build_current_file(\\n self.experiment_file_dict[\\\"simulated\\\"],\\n self.experiment_file_dict[\\\"kafka_topic\\\"],\\n self.experiment_file_dict[\\\"scan_db\\\"],\\n )\\n self.write_to_disc(\\n data, fetch_motors=False, is_global=self.parsed_args_dict[\\\"global\\\"]\\n )\",\n \"def _reset(self): # We are using a virtual function defined in the gym infrastructure.\\n self.gazebo.unpauseSim()\\n \\\"\\\"\\\"\\n why we need to unpauseSim because resetting controllers and for checking the sensors, we need the simulation\\n to be running because otherwise we don't have any sensory data and we don't have access to the controller reset\\n functions services they won't work and tell you to hit play. => it is very important.\\n \\\"\\\"\\\"\\n self.controllers_object.reset_controllers()\\n self.check_all_sensors_ready()\\n self.set_init_pose()\\n #initialized robot\\n self.gazebo.pauseSim()\\n self.gazebo.resetSim()\\n self.gazebo.unpauseSim()\\n self.controllers_object.reset_controllers()\\n self.check_all_sensors_ready()\\n self.gazebo.pauseSim()\\n self.init_env_variables()\\n obs = self._get_obs()\\n simplified_obs = self.convert_obs_to_state(obs)\\n\\n return simplified_obs\",\n \"def manual_reset(self):\\n\\n status = self.read()\\n if status != CurtainsStatus.STOPPED and status != CurtainsStatus.DANGER:\\n return\\n self.__remove_event_detect__()\\n\\n distance_to_min_step = abs(self.steps() - self.__min_step__)\\n distance_to_max_step = abs(self.__max_step__ - self.steps())\\n\\n if distance_to_min_step <= distance_to_max_step:\\n if self.steps() > self.__min_step__:\\n self.__close__()\\n else:\\n self.__open__()\\n self.curtain_closed.wait_for_active()\\n self.__stop__()\\n self.rotary_encoder.steps = self.__min_step__\\n else:\\n if self.steps() > self.__max_step__:\\n self.__close__()\\n else:\\n self.__open__()\\n self.curtain_open.wait_for_active()\\n self.__stop__()\\n self.rotary_encoder.steps = self.__max_step__\\n\\n self.__event_detect__()\",\n \"def clear_precalc(self):\\n self.Dmat_obs = None\\n self.Dmat_obs_b = None\\n self.dSdqb_mat1 = None\\n self.Mmat = None\\n self.Mmat_mix = None\\n self.mll = None\",\n \"def clear(self):\\n self.sum_hit_at_one = 0.0\\n self.sum_perr = 0.0\\n self.sum_loss = 0.0\\n self.map_calculator.clear()\\n self.global_ap_calculator.clear()\\n self.num_examples = 0\",\n \"def calibrate(self):\\n\\t\\t\\n\\t\\t# CALIBRATION\\n\\t\\t# determine the calibration points\\n\\t\\tcalibpoints = []\\n\\t\\tfor x in [0.1,0.5,0.9]:\\n\\t\\t\\tfor y in [0.1,0.5,0.9]:\\n\\t\\t\\t\\tcalibpoints.append((int(x*self.dispsize[0]),int(y*self.dispsize[1])))\\n\\t\\trandom.shuffle(calibpoints)\\n\\t\\t\\n\\t\\t# show a message\\n\\t\\tself.screen.clear()\\n\\t\\tself.screen.draw_text(\\n\\t\\t\\ttext=\\\"Press Space to calibrate, S to skip, and Q to quit\\\",\\n\\t\\t\\tfontsize=20)\\n\\t\\tself.disp.fill(self.screen)\\n\\t\\tself.disp.show()\\n\\t\\t\\n\\t\\t# wait for keyboard input\\n\\t\\tkey, keytime = self.kb.get_key(keylist=['q', 's', 'space'],\\n\\t\\t\\ttimeout=None, flush=True)\\n\\t\\tif key == 's':\\n\\t\\t\\treturn True\\n\\t\\tif key == 'q':\\n\\t\\t\\tquited = True\\n\\t\\telse:\\n\\t\\t\\tquited = False\\n\\t\\t\\n\\t\\t# Pause the processing of samples during the calibration.\\n#\\t\\tself.eyetribe._pause_sample_processing()\\n\\t\\t# run until the user is statisfied, or quits\\n\\t\\tcalibrated = False\\n\\t\\tcalibresult = None\\n\\t\\twhile not quited and not calibrated:\\n\\n\\t\\t\\t# Clear the existing calibration.\\n\\t\\t\\tif self.eyetribe._tracker.get_iscalibrated():\\n\\t\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\t\\tself.eyetribe.calibration.clear()\\n\\t\\t\\t\\tself.eyetribe._lock.release()\\n\\t\\t\\t\\n\\t\\t\\t# Wait for a bit.\\n\\t\\t\\tclock.pause(1500)\\n\\n\\t\\t\\t# start a new calibration\\n\\t\\t\\tif not self.eyetribe._tracker.get_iscalibrating():\\n\\t\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\t\\tself.eyetribe.calibration.start(pointcount=len(calibpoints))\\n\\t\\t\\t\\tself.eyetribe._lock.release()\\n\\t\\t\\t\\n\\t\\t\\t# loop through calibration points\\n\\t\\t\\tfor cpos in calibpoints:\\n\\t\\t\\t\\t# Check whether the calibration is already done.\\n\\t\\t\\t\\t# (Not sure how or why, but for some reason some data\\n\\t\\t\\t\\t# can persist between calbrations, and the tracker will\\n\\t\\t\\t\\t# simply stop allowing further pointstart requests.)\\n\\t\\t\\t\\tif self.eyetribe._tracker.get_iscalibrated():\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# Draw a calibration target.\\n\\t\\t\\t\\tself.draw_calibration_target(cpos[0], cpos[1])\\n\\t\\t\\t\\t# wait for a bit to allow participant to start looking at\\n\\t\\t\\t\\t# the calibration point (#TODO: space press?)\\n\\t\\t\\t\\tclock.pause(settings.EYETRIBEPRECALIBDUR)\\n\\t\\t\\t\\t# start calibration of point\\n\\t\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\t\\tself.eyetribe.calibration.pointstart(cpos[0],cpos[1])\\n\\t\\t\\t\\tself.eyetribe._lock.release()\\n\\t\\t\\t\\t# wait for a second\\n\\t\\t\\t\\tclock.pause(settings.EYETRIBECALIBDUR)\\n\\t\\t\\t\\t# stop calibration of this point\\n\\t\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\t\\tself.eyetribe.calibration.pointend()\\n\\t\\t\\t\\tself.eyetribe._lock.release()\\n\\t\\t\\t\\t# check if the Q key has been pressed\\n\\t\\t\\t\\tif self.kb.get_key(keylist=['q'],timeout=10,flush=False)[0] == 'q':\\n\\t\\t\\t\\t\\t# abort calibration\\n\\t\\t\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\t\\t\\tself.eyetribe.calibration.abort()\\n\\t\\t\\t\\t\\tself.eyetribe._lock.release()\\n\\t\\t\\t\\t\\t# set quited variable and break this for loop\\n\\t\\t\\t\\t\\tquited = True\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\n\\t\\t\\t# retry option if the calibration was aborted\\t\\t\\t\\n\\t\\t\\tif quited:\\n\\t\\t\\t\\t# show retry message\\n\\t\\t\\t\\tself.screen.clear()\\n\\t\\t\\t\\tself.screen.draw_text(\\n\\t\\t\\t\\t\\t\\\"Calibration aborted. Press Space to restart or 'Q' to quit\\\",\\n\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\t\\tself.disp.fill(self.screen)\\n\\t\\t\\t\\tself.disp.show()\\n\\t\\t\\t\\t# get input\\n\\t\\t\\t\\tkey, keytime = self.kb.get_key(keylist=['q','space'], timeout=None, flush=True)\\n\\t\\t\\t\\tif key == 'space':\\n\\t\\t\\t\\t\\t# unset quited Boolean\\n\\t\\t\\t\\t\\tquited = False\\n\\t\\t\\t\\t# skip further processing\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t# empty display\\n\\t\\t\\tself.disp.fill()\\n\\t\\t\\tself.disp.show()\\n\\t\\t\\t# allow for a bit of calculation time\\n\\t\\t\\t# (this is waaaaaay too much)\\n\\t\\t\\tclock.pause(1000)\\n\\t\\t\\t# get the calibration result\\n\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\tcalibresult = self.eyetribe._tracker.get_calibresult()\\n\\t\\t\\tself.eyetribe._lock.release()\\n\\n\\t\\t\\t# results\\n\\t\\t\\t# clear the screen\\n\\t\\t\\tself.screen.clear()\\n\\t\\t\\t# draw results for each point\\n\\t\\t\\tif type(calibresult) == dict:\\n\\t\\t\\t\\tfor p in calibresult['calibpoints']:\\n\\t\\t\\t\\t\\t# only draw the point if data was obtained\\n\\t\\t\\t\\t\\tif p['state'] > 0:\\n\\t\\t\\t\\t\\t\\t# draw the mean error\\n\\t\\t\\t\\t\\t\\t# self.screen.draw_circle(colour=(252,233,79),\\n\\t\\t\\t\\t\\t\\t# \\tpos=(p['cpx'],p['cpy']), r=p['mepix'], pw=0,\\n\\t\\t\\t\\t\\t\\t# \\tfill=True)\\n\\t\\t\\t\\t\\t\\tself.screen.draw_line(spos=(p['cpx'],p['cpy']),\\n\\t\\t\\t\\t\\t\\t\\tepos=(p['mecpx'],p['mecpy']), pw=2)\\n\\t\\t\\t\\t\\t\\t# draw the point\\n\\t\\t\\t\\t\\t\\tself.screen.draw_fixation(fixtype='dot',\\n\\t\\t\\t\\t\\t\\t\\tcolour=(115,210,22), pos=(p['cpx'],p['cpy']))\\n\\t\\t\\t\\t\\t\\t# draw the estimated point\\n\\t\\t\\t\\t\\t\\tself.screen.draw_fixation(fixtype='dot',\\n\\t\\t\\t\\t\\t\\t\\tcolour=(32,74,135), pos=(p['mecpx'],p['mecpy']))\\n\\t\\t\\t\\t\\t\\t# annotate accuracy\\n\\t\\t\\t\\t\\t\\tself.screen.draw_text(text='%.2f' % p['acd'],\\n\\t\\t\\t\\t\\t\\t\\tpos=(p['cpx']+10,p['cpy']+10), fontsize=20)\\n\\t\\t\\t\\t\\t# if no data was obtained, draw the point in red\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tself.screen.draw_fixation(fixtype='dot',\\n\\t\\t\\t\\t\\t\\t\\tcolour=(204,0,0), pos=(p['cpx'],p['cpy']))\\n\\t\\t\\t\\t# draw box for averages\\n\\t\\t\\t\\t# self.screen.draw_rect(colour=(238,238,236), x=int(self.dispsize[0]*0.15), y=int(self.dispsize[1]*0.2), w=400, h=200, pw=0, fill=True)\\n\\t\\t\\t\\t# draw result\\n\\t\\t\\t\\tif calibresult['result']:\\n\\t\\t\\t\\t\\tself.screen.draw_text(text=\\\"Calibration successful\\\",\\n\\t\\t\\t\\t\\t\\tcolour='green',\\n\\t\\t\\t\\t\\t\\tpos=(int(self.dispsize[0]*0.5), int(self.dispsize[1]*0.25)), \\n\\t\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tself.screen.draw_text(text=\\\"Calibration failed\\\",\\n\\t\\t\\t\\t\\t\\tcolour='red',\\n\\t\\t\\t\\t\\t\\tpos=(int(self.dispsize[0]*0.5),int(self.dispsize[1]*0.25)),\\n\\t\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\t\\t# draw average accuracy\\n\\t\\t\\t\\tself.screen.draw_text(\\n\\t\\t\\t\\t\\ttext=\\\"Average error = %.2f degrees\\\" % (calibresult['deg']),\\n\\t\\t\\t\\t\\tpos=(int(self.dispsize[0]*0.5),int(self.dispsize[1]*0.25+30)),\\n\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\t\\t# draw input options\\n\\t\\t\\t\\tself.screen.draw_text(\\n\\t\\t\\t\\t\\ttext=\\\"Press Space to continue or 'R' to restart\\\",\\n\\t\\t\\t\\t\\tpos=(int(self.dispsize[0]*0.5),int(self.dispsize[1]*0.25+60)),\\n\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.screen.draw_text(\\n\\t\\t\\t\\t\\ttext=\\\"Calibration failed. Press 'R' to try again.\\\",\\n\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\t# show the results\\n\\t\\t\\tself.disp.fill(self.screen)\\n\\t\\t\\tself.disp.show()\\n\\t\\t\\t# wait for input\\n\\t\\t\\tkey, keytime = self.kb.get_key(keylist=['space','r'], timeout=None,\\n\\t\\t\\t\\tflush=True)\\n\\t\\t\\t# process input\\n\\t\\t\\tif key == 'space':\\n\\t\\t\\t\\tcalibrated = True\\n\\n\\t\\t# Continue the processing of samples after the calibration.\\n#\\t\\tself.eyetribe._unpause_sample_processing()\\n\\n\\t\\t# calibration failed if the user quited\\n\\t\\tif quited:\\n\\t\\t\\treturn False\\n\\n\\t\\t# NOISE CALIBRATION\\n\\t\\t# get all error estimates (pixels)\\n\\t\\tvar = []\\n\\t\\tfor p in calibresult['calibpoints']:\\n\\t\\t\\t# only draw the point if data was obtained\\n\\t\\t\\tif p['state'] > 0:\\n\\t\\t\\t\\tvar.append(p['mepix'])\\n\\t\\tnoise = sum(var) / float(len(var))\\n\\t\\tself.pxdsttresh = (noise, noise)\\n\\t\\t\\t\\t\\n\\t\\t# AFTERMATH\\n\\t\\t# store some variables\\n\\t\\tpixpercm = (self.dispsize[0]/float(self.screensize[0]) + self.dispsize[1]/float(self.screensize[1])) / 2\\n\\t\\tscreendist = settings.SCREENDIST\\n\\t\\t# calculate thresholds based on tracker settings\\n\\t\\tself.accuracy = ((calibresult['Ldeg'],calibresult['Ldeg']), (calibresult['Rdeg'],calibresult['Rdeg'])) \\n\\t\\tself.pxerrdist = deg2pix(screendist, self.errdist, pixpercm)\\n\\t\\tself.pxfixtresh = deg2pix(screendist, self.fixtresh, pixpercm)\\n\\t\\tself.pxaccuracy = ((deg2pix(screendist, self.accuracy[0][0], pixpercm),deg2pix(screendist, self.accuracy[0][1], pixpercm)), (deg2pix(screendist, self.accuracy[1][0], pixpercm),deg2pix(screendist, self.accuracy[1][1], pixpercm)))\\n\\t\\tself.pxspdtresh = deg2pix(screendist, self.spdtresh/1000.0, pixpercm) # in pixels per millisecond\\n\\t\\tself.pxacctresh = deg2pix(screendist, self.accthresh/1000.0, pixpercm) # in pixels per millisecond**2\\n\\n\\t\\t# calibration report\\n\\t\\tself.log(\\\"pygaze calibration report start\\\")\\n\\t\\tself.log(\\\"accuracy (degrees): LX=%s, LY=%s, RX=%s, RY=%s\\\" % (self.accuracy[0][0],self.accuracy[0][1],self.accuracy[1][0],self.accuracy[1][1]))\\n\\t\\tself.log(\\\"accuracy (in pixels): LX=%s, LY=%s, RX=%s, RY=%s\\\" % (self.pxaccuracy[0][0],self.pxaccuracy[0][1],self.pxaccuracy[1][0],self.pxaccuracy[1][1]))\\n\\t\\tself.log(\\\"precision (RMS noise in pixels): X=%s, Y=%s\\\" % (self.pxdsttresh[0],self.pxdsttresh[1]))\\n\\t\\tself.log(\\\"distance between participant and display: %s cm\\\" % screendist)\\n\\t\\tself.log(\\\"fixation threshold: %s pixels\\\" % self.pxfixtresh)\\n\\t\\tself.log(\\\"speed threshold: %s pixels/ms\\\" % self.pxspdtresh)\\n\\t\\tself.log(\\\"acceleration threshold: %s pixels/ms**2\\\" % self.pxacctresh)\\n\\t\\tself.log(\\\"pygaze calibration report end\\\")\\n\\n\\t\\treturn True\",\n \"def clean(self):\\n warnings.warn('No cleaning routines available for CHAIN GPS')\\n\\n return\",\n \"def clear(self):\\n self._baseline = 0\\n self._sensitivity_im = 0\\n self._is_update = False\",\n \"def reset(self):\\n self.reset_image_estimate()\\n self.init_m_aux()\\n self.reset_hessian_and_bias()\\n self.reset_adadelta_variables()\",\n \"def reset(self):\\n self.satisfiability = Satisfiability.UNTESTED\\n self.model = None\\n self.unsatCore = []\",\n \"def _screener_init(self):\\n subject = 0\\n self.model.uu.remove(subject) # selects from untested and performs e\\n self.model.tt.append(subject)\\n self.model.b -= (self.cz + self.cy) # update budget\\n self.model.z[subject] = self.z[subject] # update model\\n self.model.y[subject] = self.y[subject]\",\n \"def __init__(self, useCalibration=True):\\n self.client_id = pb.connect(pb.DIRECT)\\n pb.setAdditionalSearchPath(pybullet_data.getDataPath()) # optionally\\n pb.resetDebugVisualizerCamera(cameraDistance=0.5, cameraYaw=0, cameraPitch=0, cameraTargetPosition=[0, 0, 0.25])\\n pb.setGravity(0, 0, -9.81)\\n self.soccerbot = SoccerbotRos(Transformation(), useFixedBase=False, useCalibration=useCalibration)\\n pb.disconnect(self.client_id)\\n\\n self.position_subscriber = rospy.Subscriber(\\\"goal\\\", PoseStamped, self.goal_callback)\\n self.completed_walk_publisher = rospy.Publisher(\\\"action_complete\\\", Empty, queue_size=1)\\n self.goal = PoseStamped()\\n self.robot_pose: PoseStamped = None\\n self.new_goal = self.goal\\n self.terminated = None\\n\\n self.prepare_walk_time = rospy.get_param(\\\"prepare_walk_time\\\", 2)\\n\\n self.tf_listener = tf.TransformListener()\\n\\n self.t = 0\",\n \"def reset(self):\\n self.view.running = False\\n if not self.validInput:\\n self.view.defaultTextCoordinates()\\n self.validInput = False\\n self.view.clearCanvas()\\n self.view.stopView()\\n self.model.coordinates.clear()\\n self.bestPath.clear()\\n self.bestDistance = float(\\\"inf\\\")\\n self.refresh_time = REFRESH_TIME_MS\\n self.iterationCounter = 0\\n self.view.updateLabels(0, float(\\\"inf\\\"))\",\n \"def computation(*args):\\n contour, initial = segment_one_image(\\n nodes=self.control_points,\\n image=self.image_data,\\n degree=degree,\\n resolution=resolution,\\n sigma=sigma,\\n )\\n self.initial = initial\\n self.contour = contour\\n Clock.schedule_once(reenable, 0)\",\n \"def go_calib():\\n\\n ####################\\n #\\n # Calibration files:\\n # everything created under calib/\\n #\\n ####################\\n # Darks - created in subdir darks/\\n # - darks needed to make bad pixel mask\\n # - store the resulting dark in the file name that indicates the\\n # integration time (2.8s) and the coadds (10ca).\\n # -- If you use the OSIRIS image, you must include the full filename in the list. \\n darkFiles = ['i200822_s003{0:03d}_flip'.format(ii) for ii in range(23, 27+1)]\\n calib.makedark(darkFiles, 'dark_39.832s_1ca_6rd.fits', instrument=osiris)\\n\\n darkFiles = ['i200822_s003{0:03d}_flip'.format(ii) for ii in range(28, 32+1)]\\n calib.makedark(darkFiles, 'dark_5.901s_1ca_4rd.fits', instrument=osiris)\\n\\n darkFiles = ['i200822_s020{0:03d}_flip'.format(ii) for ii in range(2, 10+1)]\\n calib.makedark(darkFiles, 'dark_11.802s_4ca_4rd.fits', instrument=osiris)\\n\\n darkFiles = ['i200822_s021{0:03d}_flip'.format(ii) for ii in range(2, 10+1)]\\n calib.makedark(darkFiles, 'dark_5.901s_8ca_1rd.fits', instrument=osiris)\\n\\n # Flats - created in subdir flats/\\n offFiles = ['i200822_s003{0:03d}_flip'.format(ii) for ii in range(3, 21+1, 2)]\\n onFiles = ['i200822_s003{0:03d}_flip'.format(ii) for ii in range(4, 22+1, 2)]\\n calib.makeflat(onFiles, offFiles, 'flat_kp_tdOpen.fits', instrument=osiris)\\n\\n # Masks (assumes files were created under calib/darks/ and calib/flats/)\\n calib.makemask('dark_39.832s_1ca_6rd.fits', 'flat_kp_tdOpen.fits',\\n 'supermask.fits', instrument=osiris)\",\n \"def run_calib(projector=OPTOMA_HD33()):\\n w, h = (0.2160, 0.2794)\\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\\n [-w/2, 0, 0], [w/2, 0, 0],\\n [-w/2, 0, h/2], [w/2, 0, h/2]])\\n\\n global img_points, going\\n img_points = []\\n\\n try:\\n window = Window()\\n window.MoveXY(1600,0)\\n window.ShowFullScreen(True)\\n going = True\\n\\n @window.eventx\\n def EVT_MOUSE_EVENTS(evt):\\n global going, img_points\\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\\n img_points.append(evt.Position)\\n print('Picked point %d of 6' % (len(img_points)))\\n if len(img_points) == len(obj_points):\\n print \\\"Done\\\"\\n going = False\\n\\n print(\\\"\\\"\\\"[Extrinsic Calibration] \\n\\nThere should be 6 points marked on the table and backdrop. \\nMoving the mouse over the projected display, click each of the points\\nin order:\\n (left top, on the backdrop),\\n (right top, on the backdrop),\\n (left center, on the crease),\\n (right center, on the crease),\\n (left bottom, on the table),\\n (right bottom, on the table)\\n\\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\\n\\nClick the six points:\\n\\\"\\\"\\\")\\n\\n while going: cv.WaitKey(10)\\n\\n finally:\\n window.Close()\\n\\n img_points = np.array(img_points, 'f')\\n projector.calibrate_extrinsic(img_points, obj_points)\\n\\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\\n print('OK')\",\n \"def __init__(self, dev, **kw):\\n AutomaticCalibrationRoutine.__init__(\\n self,\\n dev=dev,\\n **kw,\\n )\\n\\n self.final_init(**kw)\",\n \"def reset(self):\\n self.performed_transformations = False\",\n \"def reset(self):\\n # self.compile_time = 0.\\n self.fct_call_time = 0.0\\n self.fct_callcount = 0\\n self.vm_call_time = 0.0\\n self.apply_time = {}\\n self.apply_callcount = {}\\n # self.apply_cimpl = None\\n # self.message = None\",\n \"def reset(self):\\n\\n # person of interest\\n self.person = None\\n\\n #coordinates of the person edwin's interacting with\\n self.coordx = 0\\n self.coordy = 0\\n self.coordz = 0\\n\\n #edwin's own coordinates\\n self.edwinx = 0\\n self.edwiny = 0\\n self.edwinz = 0\\n\\n #looping\\n self.running = True\\n\\n #found or naw\\n self.detected = False\\n\\n #tracking the user's information\\n self.head = None\\n self.torso = None\\n self.Rhand = None\\n self.Lhand = None\\n\\n # status\\n self.status = None\",\n \"def clean(self):\\n self.iiter = 0\\n print(colored('Finished patch %s' % self.image_name, 'yellow'))\\n torch.cuda.empty_cache()\\n self.loss_min = None\\n self.history = u.History(self.args.epochs)\",\n \"def autonomousInit(self):\\n '''\\n self.cumulativeTime=0\\n self.totalTime=0\\n self.dataSet=[[-0.5,0,1,-1.0],[0.3,0.4,1,1.0],[-0.5,0,1,-1.0]]\\n for i in self.dataSet:\\n self.totalTime+=i[2]\\n self.intervals = 0\\n self.currentTime = 0\\n for i in range(0,len(self.dataSet)):\\n self.dataSet[i].append([self.currentTime,self.currentTime+self.dataSet[i][2]])\\n self.currentTime+=self.dataSet[i][2]\\n for i in self.dataSet:\\n if i[3]==1.0:\\n i.append(\\\"Forward\\\")\\n if i[3]==-1.0:\\n i.append(\\\"Backward\\\")\\n \\n self.timer.reset()\\n self.timer.start()\\n '''\\n self.timer.reset()\\n self.timer.start()\\n\\n #self.auto = self.chooser.getSelected()\\n self.auto = 6\\n self.autoState = 0\\n #self.auto = 1\\n\\n self.EC1.reset()\\n \\n\\n #self.auto = self.chooser.getSelected()\",\n \"def _reset_(self):\\n print(\\\"Resetting\\\")\\n\\n self._q_target_, x_target = self._pick_random_angles_()\\n np.copyto(self._x_target_, x_target)\\n if self._target_type == 'position':\\n self._target_ = self._x_target_[self._end_effector_indices]\\n elif self._target_type == 'angle':\\n self._target_ = self._q_target_\\n self._action_ = self._rand_obj_.uniform(self._action_low, self._action_high)\\n self._cmd_prev_ = np.zeros(len(self._action_low)) # to be used with derivative control of velocity\\n if self._reset_type != 'none':\\n if self._reset_type == 'random':\\n reset_angles, _ = self._pick_random_angles_()\\n elif self._reset_type == 'zero':\\n reset_angles = self._q_ref[self._joint_indices]\\n self._reset_arm(reset_angles)\\n\\n rand_state_array_type, rand_state_array_size, rand_state_array = utils.get_random_state_array(\\n self._rand_obj_.get_state()\\n )\\n np.copyto(self._shared_rstate_array_, np.frombuffer(rand_state_array, dtype=rand_state_array_type))\\n\\n print(\\\"Reset done\\\")\",\n \"def reset(self):\\n if self._key:\\n self._lib.StObjectReset(self._key)\\n os.chdir(self._cwd)\\n self._layers.clear() # layer: index\\n self._substrate = None\\n self._experiments.clear() # analyzed experiments\\n self._tmpstandards.clear()\",\n \"def _hard_reset(self):\\n self._reset_specific_envs(np.ones_like(self.episodes_done))\\n self._update_other_info()\",\n \"def reInitAndRun(self):\\n self.playlists = self.readPlaylistData()\\n self.audioDF = self.readAudioData(shouldProcess=True)\\n self.clusterLabels = []\\n self.models = Clusterers(k=len(self.playlists))\\n self.processAndCluster()\\n self.analyzeResults()\",\n \"def start(self):\\n self.model.stateVector = self.model.initialStateVector\\n self.transformPriorErrorCovariance()\\n self.transformMeasurementError()\",\n \"def reset(self):\\n self.control_counter = 0\\n self.last_position_error = np.zeros(3)\\n self.integral_position_error = np.zeros(3)\\n self.last_attitude_error = np.zeros(3)\\n self.integral_attitude_error = np.zeros(3)\",\n \"def _reset(self):\\n if self.filename is None and not hasattr(self, 'coco_gt'):\\n self.coco_gt = MaskCOCO()\",\n \"def _reset(self):\\n self._set(\\\"_n_init_features\\\", None)\\n self._set(\\\"_n_output_features\\\", None)\\n self._set(\\\"_n_intervals\\\", None)\\n self._set(\\\"_mapper\\\", {})\\n self._set(\\\"_cpp_preprocessor\\\", None)\\n self._set(\\\"_fitted\\\", False)\",\n \"def cleanUp(self):\\n self.isConnected=False\\n self.spawnProc=None\",\n \"def reset_energizer_flag(self): \\r\\n self.energizer_flag = False\",\n \"def reset(self):\\n # print(\\\"Joint (reset): {}\\\".format(np.around(self.joints_state.position, decimals=3)))\\n init_joint_pos = [1.5, -1.2, 1.4, -1.87, -1.57, 0]\\n self.publisher_to_moveit_object.set_joints(init_joint_pos)\\n\\n # print(\\\">>>>>>>>>>>>>>>>>>> RESET: waiting for the movement to complete\\\")\\n # rospy.wait_for_message(\\\"/pickbot/movement_complete\\\", Bool)\\n while not self.movement_complete.data:\\n pass\\n # print(\\\">>>>>>>>>>>>>>>>>>> RESET: Waiting complete\\\")\\n\\n start_ros_time = rospy.Time.now()\\n while True:\\n # Check collision:\\n # invalid_collision = self.get_collisions()\\n # if invalid_collision:\\n # print(\\\">>>>>>>>>> Collision: RESET <<<<<<<<<<<<<<<\\\")\\n # observation = self.get_obs()\\n # reward = UMath.compute_reward(observation, -200, True)\\n # observation = self.get_obs()\\n # print(\\\"Test Joint: {}\\\".format(np.around(observation[1:7], decimals=3)))\\n # return U.get_state(observation), reward, True, {}\\n\\n elapsed_time = rospy.Time.now() - start_ros_time\\n if np.isclose(init_joint_pos, self.joints_state.position, rtol=0.0, atol=0.01).all():\\n break\\n elif elapsed_time > rospy.Duration(2): # time out\\n break\\n\\n self.set_target_object(random_object=self._random_object, random_position=self._random_position)\\n self._check_all_systems_ready()\\n\\n with open('contact_1_force.yml', 'w') as yaml_file:\\n yaml.dump(0.0, yaml_file, default_flow_style=False)\\n with open('contact_2_force.yml', 'w') as yaml_file:\\n yaml.dump(0.0, yaml_file, default_flow_style=False)\\n with open('collision.yml', 'w') as yaml_file:\\n yaml.dump(False, yaml_file, default_flow_style=False)\\n observation = self.get_obs()\\n self.object_position = observation[9:12]\\n\\n # print(\\\"Joint (after): {}\\\".format(np.around(observation[1:7], decimals=3)))\\n\\n # get maximum distance to the object to calculate reward\\n self.max_distance, _ = U.get_distance_gripper_to_object()\\n self.min_distace = self.max_distance\\n state = U.get_state(observation)\\n self._update_episode()\\n return state\",\n \"def run(self, data):\\n\\t\\treduced_data = PCA(n_components=2).fit_transform(data)\\n\\n\\t\\t# Run the algorithm\\n\\t\\tself.estimator.fit_transform(reduced_data)\\n\\n\\t\\t# Save all relevent properties\\n\\t\\tself.input_data = data\\n\\t\\tself.centroids = self.estimator.cluster_centers_\\n\\t\\tself.node_positions = reduced_data\\n\\t\\tself.labels = self.estimator.labels_\\n\\n\\t\\t# Enable visualising when debugging\\n\\t\\t# self.visualize(reduced_data)\",\n \"def reset(self):\\n self.solver = None\",\n \"def reset(self):\\n self.__init__() # Reset all variables\\n self.stitch = self.convertNumpy2Image(np.zeros([750,850,3], dtype=\\\"uint8\\\"))\\n self.capture = self.convertNumpy2Image(np.zeros([320,408, 3],dtype=\\\"uint8\\\"))\",\n \"def reset(self):\\n \\n s = self\\n s.step_counter = 0\\n \\n # TODO: initialize first layer activations here, and not everywhere else\\n # self.model.initialize_local_vars()\\n # self.model.initialize_global_vars()\\n\\n ops = []\\n\\n for var in self.model.trainable_vars:\\n if self.needs_correction(var):\\n A_svd = s[var].A.svd\\n B2_svd = s[var].B2.svd \\n ops.extend(A_svd.init_ops)\\n ops.extend(B2_svd.init_ops)\\n ops.append(s[var].A.cov.initializer)\\n ops.append(s[var].B2.cov.initializer)\\n\\n # in new TensorFlow this breaks, probably because of\\n # https://github.com/tensorflow/tensorflow/commit/07adc2ea910de715d31e16a019fcbcccb575e931\\n # sometimes get \\\"need to feed\\\" placeholder error\\n # sometimes do not get this error, but spend two minutes inside\\n # _build_initializer_expr\\n s.run(ops)\",\n \"def auto_setup(self):\\n if self.mot_type == \\\"xps8p\\\":\\n return\\n if self.get_par(\\\"err_sevr\\\") == 3:\\n print \\\"Reinitializing motor {}...\\\".format(self.name)\\n self.reinit()\\n ok = self.wait_par(\\\"err_sevr\\\", 3, match_value=False, timeout=20)\\n if ok:\\n print \\\"Successfully reinitialized {}.\\\".format(self.name)\\n time.sleep(0.5)\\n else:\\n print \\\"Reinitializing {} timed out. Aborting auto_setup.\\\".format(self.name)\\n return\\n\\n for i in range(3):\\n for clear, name in ((self.clear_pu, \\\"powerup\\\"),\\n (self.clear_stall, \\\"stall flag\\\"),\\n (self.clear_error, \\\"error flag\\\")):\\n clear(check=True, wait=False)\\n\\n ok = []\\n for bit, mask in ((RA_POWERUP, 1), (RA_STALL, 1), (RA_ERR, RA_ERR_MASK)):\\n ok.append(self._wait_msta_bit(bit, 0, mask, timeout=10))\\n if not all(ok):\\n print \\\"Issues with clearing flags for {}\\\".format(self.name)\\n\\n try: # Not every environment has pmgr access\\n self.pmgr.apply_config(dumb_config=self.name)\\n except:\\n pass\",\n \"def reset(self):\\n logger.info(\\\"resetting worker #%i\\\", self.myid)\\n self.model.projection = self.model.projection.empty_like()\\n self.finished = False\",\n \"def resetDetector (self):\\n self.mpr121._reset ()\",\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 test_do_boss_calibs_one_flat_coobserve(self):\\n cmdState = CmdState.DoBossCalibsCmd()\\n cmdState.nFlat = 1\\n sopTester.updateModel('guider', TestHelper.guiderState['apogeemangaDitherLoaded'])\\n sopTester.updateModel('mcp', TestHelper.mcpState['apogee_parked'])\\n sopTester.updateModel('apogee', TestHelper.apogeeState['B_open'])\\n self._do_boss_calibs(8, 38, 0, 0, cmdState)\",\n \"def __init__(self, calibration_patterns, pattern_size=(9,6), retain_calibration_patterns=False):\\n self.camera_matrix = None\\n self.distortion_coef = None\\n self.calibration_patterns_success = []\\n self.calibration_patterns_error = []\\n self.cal_dist_and_mtx(calibration_patterns, pattern_size, retain_calibration_patterns)\",\n \"def reset(self):\\n p.resetSimulation()\\n p.setPhysicsEngineParameter(numSolverIterations=150)\\n p.setTimeStep(self._time_step)\\n p.setGravity(0, 0, -9.8)\\n\\n # load plane\\n p.loadURDF(os.path.join(pybullet_data.getDataPath(), \\\"plane.urdf\\\"), [0, 0, 0])\\n # load robot\\n self._darwin = DarwinopEnv()\\n\\n # Let the world run for a bit\\n for _ in range(20):\\n p.stepSimulation()\",\n \"def autoAnalyze(self):\\n print(\\\"Perfoming full automatic analysis...\\\")\\n t1=time.perf_counter()\\n self.cleanUp()\\n self.figure_rois()\\n self.figure_roi_inspect_all()\\n self.figure_dGoR_roi(showEach=False,saveAs=self.folderSave+\\\"/avg.png\\\")\\n self.figure_dGoR_roi(showEach=True,saveAs=self.folderSave+\\\"/each.png\\\")\\n self.index()\\n print(\\\"analysis completed in %.02f sec\\\"%(time.perf_counter()-t1))\",\n \"def initialize(self) -> None:\\n # Set motors to stop, read encoder values for starting point\\n self.drive.arcadeDrive(0, 0)\\n self.drive.resetEncoders()\",\n \"def reset_solver(self):\\n self.total_iterations = 0\\n self.active_constraints_index = 0\\n self.active_constraints_set = False\\n return\",\n \"def reset(self):\\n # Clear mutable data, but leave the immutables intact\\n self.train_data = {}\\n self.val_data = {}\\n self.test_data = {}\\n self.model_files = []\\n self.custom_data = {}\\n # Remove all the physical assets\\n for item in os.scandir(self.root_path):\\n os.remove(item.path)\\n # Reserialize\\n self.serialize()\",\n \"def __clear_all(self,event):\\n \\n self.CoagS = \\\\\\n self.CoagS_term = \\\\\\n self.GR_term = \\\\\\n self.J_time = \\\\\\n self.J = \\\\\\n self.J_lims = \\\\\\n self.mmd_time = \\\\\\n self.mmd_dp = \\\\\\n self.mmd_time_sr = \\\\\\n self.mmd_dp_sr = np.array([])\\n \\n # Initialize all np.nan variables\\n self.J_peak = \\\\\\n self.J_halfmax = \\\\\\n self.J_median = \\\\\\n self.gr = np.nan\\n \\n # Clears polygon used to outline particle mode\\n self.polyx = \\\\\\n self.polyy = \\\\\\n self.polyx_out = \\\\\\n self.polyy_out = np.array([])\\n self.poly.set_xy(np.ones((2,2))*np.nan)\\n self.poly_out.set_xy(np.ones((2,2))*np.nan)\\n \\n self.box_gr.set_val(\\\"%.2f\\\" % self.gr)\\n self.box_J_peak.set_val(\\\"%.2f\\\" % self.J_peak)\\n self.box_J_median.set_val(\\\"%.2f\\\" % self.J_median)\\n self.box_J_halfmax.set_val(\\\"%.2f\\\" % self.J_halfmax)\\n\\n # clear average mode diameters and fit\\n self.mmd_plot.set_data(np.nan,np.nan)\\n self.mmd_plot_sr.set_data(np.nan,np.nan)\\n self.mmd_fit_sr.set_data(np.nan,np.nan)\\n self.J_plot.set_data(np.nan,np.nan)\\n self.J_fit.set_data(np.nan,np.nan)\\n self.J_vertical_line1.set_xdata(np.nan)\\n self.J_vertical_line2.set_xdata(np.nan)\\n self.gr_term_plot.set_data(np.nan,np.nan)\\n self.coags_term_plot.set_data(np.nan,np.nan)\\n self.dNdt_term_plot.set_data(np.nan,np.nan)\\n\\n plt.draw()\",\n \"def on_iteration_start(self):\\n\\n self.Xfprv = self.Xf.copy()\\n if (not self.opt['FastSolve'] or isinstance(self.backtrack,\\n BacktrackRobust)):\\n self.Yfprv = self.Yf.copy()\\n\\n if self.opt['Monotone']:\\n if self.k == 0:\\n self.objfn = self.eval_objfn()\\n self.objfn_prev = self.objfn\",\n \"def __init__(self):\\n self.secs_to_ave = 2 #time to integrate gas detector\\n\\t\\tself.initErrorCheck() #Checks for errors and trimming\",\n \"def stage(self):\\n\\n # prepare projected land allocation data\\n self.prep_projected()\\n\\n # prepare base land use data\\n self.prep_base()\\n\\n # harmonize grid area between projected and base layer land allocation\\n self.harmony()\\n\\n # apply constraints\\n self.set_constraints()\\n\\n # create kernel density filter if not running multiple jobs\\n self.kernel_filter()\\n\\n # set data for step zero\\n self.set_step_zero()\",\n \"def reset(self):\\n # self state is velocity, observation is velocity\\n # self._state = np.random.uniform(0, self.GOAL_VELOCITY, size=(self.num_cars,))\\n # print(\\\"In reset function\\\", self.initialized)\\n if self.initialized:\\n traci.close()\\n sumoProcess = subprocess.Popen([self.sumoBinary, \\\"-c\\\", self.cfgfn, \\\"--remote-port\\\", str(self.PORT)], stdout=sys.stdout, stderr=sys.stderr)\\n traci.init(self.PORT)\\n traci.simulationStep()\\n if not self.initialized:\\n self.vehIDs = traci.vehicle.getIDList()\\n print(\\\"ID List in reset\\\", self.vehIDs)\\n self.initialized = True\\n self._state = np.array([traci.vehicle.getSpeed(vID) for vID in self.controllable])\\n observation = np.copy(self._state)\\n return observation\",\n \"def reset(self):\\n\\n self.needReset = False\\n self._reset_limits()\\n self._reset_integration_grid()\\n\\n if self.filamentBeam and not hasattr(self, 'dimExy'):\\n rMax = self.nrays\\n rE = np.random.uniform(self.E_min, self.E_max, rMax)\\n rTheta = np.random.uniform(self.Theta_min, self.Theta_max, rMax)\\n rPsi = np.random.uniform(self.Psi_min, self.Psi_max, rMax)\\n tmpEspread = self.eEspread\\n self.eEspread = 0\\n DistI = self.build_I_map(rE, rTheta, rPsi)[0]\\n self.Imax = np.max(DistI) * 1.2\\n self.nrepmax = np.floor(rMax / len(np.where(\\n self.Imax * np.random.rand(rMax) < DistI)[0]))\\n self.eEspread = tmpEspread\\n else:\\n self.Imax = 0.\\n \\\"\\\"\\\"Preparing to calculate the total flux integral\\\"\\\"\\\"\\n self.xzE = (self.E_max - self.E_min) *\\\\\\n (self.Theta_max - self.Theta_min) *\\\\\\n (self.Psi_max - self.Psi_min)\\n self.fluxConst = self.Imax * self.xzE\",\n \"def remove_all(self):\\n self.initial = None\\n self.contour = None\\n self.control_points = []\",\n \"def preCalibrate(self):\\n self._write_enabled = False\\n self.start_recording()\\n\\n origin = (int(self.disp.dispsize[0] / 4), int(self.disp.dispsize[1] / 4))\\n size = (int(2 * self.disp.dispsize[0] / 4), int(2 * self.disp.dispsize[1] / 4))\\n\\n videoFile = os.path.join(c.CALIBVIDEODIR, \\\"--- cal_movie_1.mov\\\")\\n\\n # Initialise a PsychoPy MovieStim\\n mov = visual.MovieStim3(self.video_win, videoFile, flipVert=False)\\n\\n print(\\\"------------> Pre-calibration process started.\\\")\\n print(\\\"------------> When correctly positioned press \\\\'space\\\\' to start the calibration.\\\")\\n\\n while mov.status != visual.FINISHED:\\n if not self.gaze:\\n continue\\n\\n self.screen.clear()\\n\\n # Add the MovieStim to a PyGaze Screen instance.\\n self.screen.screen.append(mov)\\n\\n gaze_sample = copy.copy(self.gaze[-1])\\n\\n validity_colour = (255, 0, 0)\\n\\n if gaze_sample['right_gaze_origin_validity'] and gaze_sample['left_gaze_origin_validity']:\\n left_validity = 0.15 < gaze_sample['left_gaze_origin_in_trackbox_coordinate_system'][2] < 0.85\\n right_validity = 0.15 < gaze_sample['right_gaze_origin_in_trackbox_coordinate_system'][2] < 0.85\\n if left_validity and right_validity:\\n validity_colour = (0, 255, 0)\\n\\n self.screen.draw_line(colour=validity_colour, spos=origin, epos=(origin[0] + size[0], origin[1]), pw=1)\\n self.screen.draw_line(colour=validity_colour, spos=origin, epos=(origin[0], origin[1] + size[1]), pw=1)\\n self.screen.draw_line(colour=validity_colour,\\n spos=(origin[0], origin[1] + size[1]),\\n epos=(origin[0] + size[0], origin[1] + size[1]),\\n pw=1)\\n self.screen.draw_line(colour=validity_colour,\\n spos=(origin[0] + size[0], origin[1] + size[1]),\\n epos=(origin[0] + size[0], origin[1]),\\n pw=1)\\n\\n right_eye, left_eye, distance = None, None, []\\n if gaze_sample['right_gaze_origin_validity']:\\n distance.append(round(gaze_sample['right_gaze_origin_in_user_coordinate_system'][2] / 10, 1))\\n right_pos = gaze_sample['right_gaze_origin_in_trackbox_coordinate_system']\\n right_eye = ((1 - right_pos[0]) * size[0] + origin[0], right_pos[1] * size[1] + origin[1])\\n self.screen.draw_circle(colour=validity_colour,\\n pos=right_eye,\\n r=int(self.disp.dispsize[0] / 100),\\n pw=5,\\n fill=True)\\n\\n if gaze_sample['left_gaze_origin_validity']:\\n distance.append(round(gaze_sample['left_gaze_origin_in_user_coordinate_system'][2] / 10, 1))\\n left_pos = gaze_sample['left_gaze_origin_in_trackbox_coordinate_system']\\n left_eye = ((1 - left_pos[0]) * size[0] + origin[0], left_pos[1] * size[1] + origin[1])\\n self.screen.draw_circle(colour=validity_colour,\\n pos=left_eye,\\n r=int(self.disp.dispsize[0] / 100),\\n pw=5,\\n fill=True)\\n\\n self.screen.draw_text(text=\\\"Current distance to the eye tracker: {0} cm.\\\".format(self._mean(distance)),\\n pos=(int(self.disp.dispsize[0] / 2), int(self.disp.dispsize[1] * 0.9)),\\n colour=(255, 255, 255),\\n fontsize=20)\\n\\n self.disp.fill(self.screen)\\n self.disp.show()\\n\\n key = self._getKeyPress()\\n if key == \\\"space\\\":\\n break\\n\\n\\n\\n if mov.status != visual.FINISHED:\\n # pause and discard video for the audio to stop as well\\n mov.pause()\\n self.screen.screen.remove(mov)\\n #video_win.close()\\n del mov\\n self.screen.clear()\\n clock.pause(1000)\\n return True\\n else:\\n return False\",\n \"def steering_calibration(self):\\n\\n # Minimum change of rotary encoder per 100 ms to detect stall\\n min_difference = 5\\n # Calibration motor power in percentage (absolute)\\n calibration_power = 30\\n\\n print('Calibration of steering axis started')\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n last_pos = 99999999 # any super big number\\n # Left turn calibration\\n while abs(current_pos - last_pos) > min_difference:\\n last_pos = current_pos\\n self.brick_pi.set_motor_power(self.motor_steer, calibration_power)\\n time.sleep(0.1)\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n\\n self.brick_pi.set_motor_power(self.motor_steer, 0)\\n time.sleep(0.1)\\n print('Reset motor encoder after left turn: 0')\\n self.brick_pi.reset_motor_encoder(self.motor_steer)\\n\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n last_pos = 99999999 # any super big number\\n # Right turn calibration\\n while abs(current_pos - last_pos) > min_difference:\\n last_pos = current_pos\\n self.brick_pi.set_motor_power(self.motor_steer, -calibration_power)\\n time.sleep(0.1)\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n\\n self.brick_pi.set_motor_power(self.motor_steer, 0)\\n time.sleep(0.1)\\n self.brick_pi.offset_motor_encoder(self.motor_steer, current_pos / 2)\\n self.steering_limit = abs(\\n self.brick_pi.get_motor_encoder(self.motor_steer))\\n print('Offset motor encoder after right turn: ' +\\n str(self.brick_pi.get_motor_encoder(self.motor_steer)))\\n\\n self.brick_pi.set_motor_position(self.motor_steer, 0)\\n print('Calibration of steering axis completed')\",\n \"def reset(self):\\n self._proportional = 0\\n self._integral = 0\\n self._derivative = 0\\n\\n self._last_time = self._current_time()\\n self._last_output = None\\n self._last_input = None\",\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 reset(self):\\n self.acc_loss = 0\\n self.norm_term = 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 reset(self):\\n self.__init__(self.subDomainnumMonomers, self.dim, self.b, self.subDomainNc, self.keepCL, position = self.positions)\",\n \"def _deconfigure(self):\\n \\n # TODO: the deconfiguration should happen in reverse order of the\\n # initialization:\\n\\n # reset scanID, frequencyBand in case they're not reset\\n self._scan_ID = 0\\n self._frequency_band = 0\\n\\n # unsubscribe from TMC events\\n for event_id in list(self._events_telstate.keys()):\\n self._events_telstate[event_id].unsubscribe_event(event_id)\\n self._events_telstate = {}\\n\\n # unsubscribe from FSP state change events\\n for fspID in list(self._events_state_change_fsp.keys()):\\n proxy_fsp = self._proxies_fsp[fspID - 1]\\n proxy_fsp.unsubscribe_event(self._events_state_change_fsp[fspID][0]) # state\\n proxy_fsp.unsubscribe_event(self._events_state_change_fsp[fspID][1]) # healthState\\n del self._events_state_change_fsp[fspID]\\n del self._fsp_state[self._fqdn_fsp[fspID - 1]]\\n del self._fsp_health_state[self._fqdn_fsp[fspID - 1]]\\n\\n # send assigned VCCs and FSP subarrays to IDLE state\\n # TODO: check if vcc fsp is in scanning state (subarray \\n # could be aborted in scanning state) - is this needed?\\n self._group_vcc.command_inout(\\\"GoToIdle\\\")\\n self._group_fsp_corr_subarray.command_inout(\\\"GoToIdle\\\")\\n self._group_fsp_pss_subarray.command_inout(\\\"GoToIdle\\\")\\n self._group_fsp_pst_subarray.command_inout(\\\"GoToIdle\\\")\\n\\n # change FSP subarray membership\\n data = tango.DeviceData()\\n data.insert(tango.DevUShort, self._subarray_id)\\n # self.logger.info(data)\\n self._group_fsp.command_inout(\\\"RemoveSubarrayMembership\\\", data)\\n self._group_fsp.remove_all()\\n\\n\\n # remove channel info from FSP subarrays\\n # already done in GoToIdle\\n self._group_fsp_corr_subarray.remove_all()\\n self._group_fsp_pss_subarray.remove_all()\\n self._group_fsp_pst_subarray.remove_all()\\n\\n # reset all private dat to their initialization values:\\n self._scan_ID = 0 \\n self._config_ID = \\\"\\\"\\n self._last_received_delay_model = \\\"{}\\\"\\n self._last_received_jones_matrix = \\\"{}\\\"\\n self._last_received_beam_weights = \\\"{}\\\"\\n\\n # TODO: need to add 'GoToIdle' for VLBI and PST once implemented:\\n # TODO: what happens if \\n # # sp_corr_subarray_proxy.State() == tango.DevState.OFF ??\\n # that should not happen\\n for fsp_corr_subarray_proxy in self._proxies_fsp_corr_subarray:\\n if fsp_corr_subarray_proxy.State() == tango.DevState.ON:\\n fsp_corr_subarray_proxy.GoToIdle()\\n for fsp_pss_subarray_proxy in self._proxies_fsp_pss_subarray:\\n if fsp_pss_subarray_proxy.State() == tango.DevState.ON:\\n fsp_pss_subarray_proxy.GoToIdle()\\n for fsp_pst_subarray_proxy in self._proxies_fsp_pst_subarray:\\n if fsp_pst_subarray_proxy.State() == tango.DevState.ON:\\n fsp_pst_subarray_proxy.GoToIdle()\",\n \"def create_calibration_path(Env):\\n \\n hotpixelkiller = Env.create_path('hotpixelkiller')\\n hotpixelkiller.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': rawfile_air }) \\n hotpixelkiller.add_processor(name=\\\"M26HotPixelKiller\\\")\\n\\n cluster_calibrator_mc = Env.create_path('cluster_calibrator_mc')\\n cluster_calibrator_mc.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': rawfile_air }) \\n cluster_calibrator_mc.add_processor(name=\\\"M26Clusterizer\\\")\\n cluster_calibrator_mc.add_processor(name=\\\"M26CogHitMaker\\\")\\n cluster_calibrator_mc.add_processor(name=\\\"M26ClusterCalibrationFromMC\\\")\\n\\n clusterizer = Env.create_path('clusterizer')\\n clusterizer.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': rawfile_air }) \\n clusterizer.add_processor(name=\\\"M26Clusterizer\\\")\\n clusterizer.add_processor(name=\\\"LCIOOutput\\\")\\n\\n correlator = Env.create_path('correlator')\\n correlator.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n correlator.add_processor(name=\\\"M26CogHitMaker\\\")\\n correlator.add_processor(name=\\\"RawDQM\\\") \\n correlator.add_processor(name=\\\"TelCorrelator\\\")\\n \\n kalman_aligner_1 = Env.create_path('kalman_aligner_1')\\n kalman_aligner_1.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n kalman_aligner_1.add_processor(name=\\\"M26CogHitMaker\\\")\\n kalman_aligner_1.add_processor(name=\\\"AlignTF_LC\\\")\\n kalman_aligner_1.add_processor(name=\\\"PreAligner\\\")\\n \\n kalman_aligner_2 = Env.create_path('kalman_aligner_2')\\n kalman_aligner_2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n kalman_aligner_2.add_processor(name=\\\"M26CogHitMaker\\\")\\n kalman_aligner_2.add_processor(name=\\\"AlignTF_TC\\\")\\n kalman_aligner_2.add_processor(name=\\\"TelAligner\\\")\\n \\n telescope_dqm = Env.create_path('telescope_dqm')\\n telescope_dqm.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n telescope_dqm.add_processor(name=\\\"M26CogHitMaker\\\")\\n telescope_dqm.add_processor(name=\\\"AlignTF_TC\\\")\\n telescope_dqm.add_processor(name=\\\"TelescopeDQM\\\")\\n \\n cluster_calibration_1 = Env.create_path('cluster_calibration_1')\\n cluster_calibration_1.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n cluster_calibration_1.add_processor(name=\\\"M26CogHitMaker\\\") \\n cluster_calibration_1.add_processor(name=\\\"AlignTF_TC\\\")\\n cluster_calibration_1.add_processor(name=\\\"M26ClusterCalibrator\\\")\\n \\n kalman_aligner_3 = Env.create_path('kalman_aligner_3')\\n kalman_aligner_3.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n kalman_aligner_3.add_processor(name=\\\"M26GoeHitMaker\\\")\\n kalman_aligner_3.add_processor(name=\\\"AlignTF_TC\\\")\\n kalman_aligner_3.add_processor(name=\\\"TelAligner\\\")\\n \\n cluster_calibration_2 = Env.create_path('cluster_calibration_2')\\n cluster_calibration_2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n cluster_calibration_2.add_processor(name=\\\"M26GoeHitMaker\\\") \\n cluster_calibration_2.add_processor(name=\\\"AlignTF_TC\\\")\\n cluster_calibration_2.add_processor(name=\\\"M26ClusterCalibrator\\\")\\n\\n correlator2 = Env.create_path('correlator2')\\n correlator2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" })\\n correlator2.add_processor(name=\\\"M26GoeHitMaker\\\") \\n correlator2.add_processor(name=\\\"RawDQM\\\", params={'RootFileName': 'RawDQM2.root'})\\n correlator2.add_processor(name=\\\"TelCorrelator\\\", params={'OutputRootFileName': 'XCorrelator2.root'})\\n \\n kalman_aligner_4 = Env.create_path('kalman_aligner_4')\\n kalman_aligner_4.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n kalman_aligner_4.add_processor(name=\\\"M26GoeHitMaker\\\") \\n kalman_aligner_4.add_processor(name=\\\"AlignTF_LC\\\")\\n kalman_aligner_4.add_processor(name=\\\"PreAligner\\\")\\n \\n kalman_aligner_5 = Env.create_path('kalman_aligner_5')\\n kalman_aligner_5.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n kalman_aligner_5.add_processor(name=\\\"M26GoeHitMaker\\\") \\n kalman_aligner_5.add_processor(name=\\\"AlignTF_TC\\\")\\n kalman_aligner_5.add_processor(name=\\\"TelAligner\\\") \\n \\n telescope_dqm2 = Env.create_path('telescope_dqm2')\\n telescope_dqm2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n telescope_dqm2.add_processor(name=\\\"M26GoeHitMaker\\\") \\n telescope_dqm2.add_processor(name=\\\"AlignTF_TC\\\")\\n telescope_dqm2.add_processor(name=\\\"TelescopeDQM\\\", params={'RootFileName' : 'TelescopeDQM2.root'})\\n \\n \\n # create sequence of calibration paths \\n calpath= [ hotpixelkiller , \\n cluster_calibrator_mc,\\n clusterizer,\\n correlator, \\n kalman_aligner_1, \\n kalman_aligner_2, \\n kalman_aligner_2, \\n kalman_aligner_2, \\n telescope_dqm, \\n cluster_calibration_1, \\n kalman_aligner_3, \\n kalman_aligner_3, \\n kalman_aligner_3, \\n cluster_calibration_2, \\n cluster_calibration_2, \\n cluster_calibration_2, \\n cluster_calibration_2, \\n cluster_calibration_2, \\n cluster_calibration_2, \\n cluster_calibration_2, \\n cluster_calibration_2,\\n correlator2, \\n kalman_aligner_4, \\n kalman_aligner_5, \\n kalman_aligner_5, \\n kalman_aligner_5, \\n telescope_dqm2, \\n ]\\n \\n return calpath\",\n \"def reset(self, evaluate=False):\\n self.reset_env()\\n for _ in range(20):\\n self.__publish_cmd(0.0, 0.0)\\n self.rate.sleep()\\n self.__publish_cmd(1.0, 0.0)\\n self.rate.sleep()\\n self.prev_pos_index, _ = self.__find_closest_point(1088)\\n self.prev_reward = 0.0\\n \\n \\n # If this run isn't being evaluated, we need to add some randomness to the starting point or else the agents will not learn well\\n # if not evaluate:\\n # random_steps = np.random.randint(0, 20)\\n # ref = self.ref_track\\n # l = len(ref)\\n # curr_pos_index, _ = self.__find_closest_point(self.prev_pos_index)\\n # for _ in range(random_steps):\\n # ranges = self.get_state()\\n # max_range = np.max(ranges)\\n # indices = np.where(ranges>=max_range)\\n # target_index = np.mean(indices)\\n # angle = ((2 * self.lidar_angle) / len(ranges)) * target_index - self.lidar_angle\\n \\n # # future_pos_index = (curr_pos_index + 20) % l\\n # # goal_point = ref[future_pos_index]\\n # # print(goal_point)\\n # # curr_pos = copy.copy(self.pos) # [x, y, yaw, speed]\\n # # dx = goal_point[0] - curr_pos[0]\\n # # dy = goal_point[1] - curr_pos[1]\\n # # yaw = curr_pos[2]\\n # # xgv = (dx * np.cos(yaw)) + (dy * np.sin(yaw))\\n # # ygv = (-dx * np.sin(yaw)) + (dy * np.cos(yaw))\\n # # angle = -np.arctan2(ygv,xgv)\\n # # print(angle)\\n # self.step(angle)\\n # curr_pos_index, _ = self.__find_closest_point(curr_pos_index)\\n \\n # self.prev_pos_index = copy.copy(curr_pos_index)\\n\\n \\n # print(self.prev_pos_index)\\n\\n return\",\n \"def teardown_simulate(self):\\n self.positions = self.calibrated_positions\",\n \"def calibrate(science_list_fname, master_flat_fname, master_dark_fname, hp_map_fname, bp_map_fname, mask_bad_pixels = False,\\n clean_Bad_Pix=True, replace_nans=True, background_fname = None, outdir = None):\\n\\n #Get the list of science frames\\n #science_list = np.loadtxt(science_list_fname, dtype=str)\\n science_list = science_list_fname\\n\\n #Open the master dark\\n master_dark_hdu = f.open(master_dark_fname)\\n master_dark = master_dark_hdu[0].data\\n dark_shape = np.shape(master_dark)\\n print((\\\"Subtracting {} from each flat file\\\".format(master_dark_fname)))\\n dark_exp_time = master_dark_hdu[0].header['EXPTIME']\\n\\n #Open the master flat\\n master_flat_hdu = f.open(master_flat_fname)\\n master_flat = master_flat_hdu[0].data\\n print((\\\"Dividing each file by {}\\\".format(master_flat_fname)))\\n dark_exp_time = master_dark_hdu[0].header['EXPTIME']\\n\\n #Open the bad pixel map from flat\\n bp_map_hdu = f.open(bp_map_fname)\\n bad_pixel_map = bp_map_hdu[0].data\\n bad_pixel_map_bool = np.array(bad_pixel_map, dtype=bool)\\n print((\\\"Using bad pixel map {}\\\".format(bp_map_fname)))\\n\\n #now if hot pixel map from dark is also given\\n if hp_map_fname != None:\\n hp_map_hdu = f.open(hp_map_fname)\\n hot_pixel_map = hp_map_hdu[0].data\\n bad_pixel_map_bool = np.logical_or(bad_pixel_map_bool, hot_pixel_map.astype(bool) )\\n\\n\\n if background_fname != None:\\n background_hdu = f.open(background_fname)\\n background = background_hdu[0].data\\n print(\\\"Subtracting background frame {} from all science files\\\".format(background_fname))\\n\\n\\n for fname in science_list:\\n #Open the file\\n print((\\\"Calibrating {}\\\".format(fname\\n )))\\n hdu = f.open(fname)\\n data = hdu[0].data\\n science_exp_time = hdu[0].header['EXPTIME']\\n\\n if dark_exp_time != science_exp_time:\\n warnings.warn(\\\"The master dark file doesn't have the same exposure time as the data. We'll scale the dark for now, but this isn't ideal\\\", UserWarning)\\n factor = science_exp_time/dark_exp_time\\n else:\\n factor = 1.\\n\\n #Subtract the dark, divide by flat\\n redux = ((data - factor*master_dark)/master_flat)\\n #get rid of crazy values at bad pixel\\n redux = redux*~bad_pixel_map_bool\\n\\n if background_fname != None:\\n redux -= background\\n\\n if clean_Bad_Pix:\\n # plt.plot(bad_pixel_map_bool)\\n redux = cleanBadPix(redux, bad_pixel_map_bool)\\n #redux = ccdproc.cosmicray_lacosmic(redux, sigclip=5)[0]\\n\\n # redux = ccdproc.cosmicray_median(redux, mbox=7, rbox=5, gbox=7)[0]\\n\\n #Mask the bad pixels if the flag is set\\n if mask_bad_pixels:\\n redux *= ~bad_pixel_map_bool\\n\\n if replace_nans:\\n # nan_map = ~np.isfinite(redux)\\n # redux = cleanBadPix(redux, nan_map)\\n # plt.imshow(redux-after)\\n nanmask = np.isnan(redux) #nan = True, just in case this is useful\\n redux = np.nan_to_num(redux)\\n\\n #Put the cablibrated data back in the HDU list\\n hdu[0].data = redux\\n\\n #Add pipeline version and history keywords\\n vers = version.get_version()\\n hdu[0].header.set('PL_VERS',vers,'Version of pipeline used for processing')\\n hdu[0].header['HISTORY'] = \\\"Subtracting {} from each flat file\\\".format(master_dark_fname)\\n hdu[0].header['HISTORY'] = \\\"Dividing each file by {}\\\".format(master_flat_fname)\\n\\n if background_fname != None:\\n hdu[0].header['HISTORY'] = \\\"Subtracted background frame {}\\\".format(background_fname)\\n\\n if mask_bad_pixels:\\n hdu[0].header['HISTORY'] = \\\"Masking all bad pixels found in {}\\\".format(bp_map_fname)\\n\\n if clean_Bad_Pix:\\n hdu[0].header['HISTORY'] = \\\"Cleaned all bad pixels found in {} using a median filter\\\".format(bp_map_fname)\\n\\n # #Append the bad pixel list to the HDU list\\n # hdu.append(f.PrimaryHDU([bad_pixel_map]))\\n # hdu[1].header['HISTORY'] = \\\"Appending bad pixel map :{}\\\".format(bp_map_fname)\\n # hdu[1].header['HISTORY'] = \\\"0 = good pixel\\\"\\n # hdu[1].header['HISTORY'] = \\\"1 = bad pixel from flat fields\\\"\\n # hdu[1].header['HISTORY'] = \\\"2 = hot pixel from darks\\\"\\n\\n outname = fname.split('.')[0]+\\\"_calib.fits\\\"\\n\\n #if an output directory is specified we can write out to that directory instead\\n #making sure to take only the stuff after the last '/' to avoid directory issues from fname\\n if outdir:\\n outname = outdir + fname.split('/')[-1]\\n\\n print((\\\"Writing calibrated file to {}\\\".format(outname)))\\n #Save the calibrated file\\n hdu.writeto(outname, overwrite=True)\\n\\n # f.PrimaryHDU(redux).writeto('redux_'+i, overwrite = True)\",\n \"def calibrate(self):\\n if self.iCAL_required:\\n logger.info(\\\"iCAL-sensitive registers were modified, performing calibration...\\\")\\n return self._run_ical()\\n else:\\n logger.info(\\\"iCAL-sensitive registers were not modified, skipping calibration...\\\")\\n return 0 # Still success\",\n \"def reset(self):\\n self.baseline = None\\n self.cut = None\\n self.manual_push = 0\",\n \"def reset(self):\\n\\n # initialize gym env variables\\n self.finish = False\\n self.curr_step = -1\\n self.curr_episode += 1\\n\\n # initialize target position\\n self.target = np.random.uniform(-10.0,10.0,size=(2))\\n\\n # initialize sheep positions\\n if self.fixed_reset:\\n init_sheep_pose = np.array([75.0, 75.0])\\n self.sheep_poses = (np.random.uniform(-50.0, 50.0, \\n size=(self.num_sheep,2))) + init_sheep_pose[None,:]\\n else:\\n init_sheep_pose = np.random.uniform(-self.init_sheep_root, \\n self.init_sheep_root, size=(2))\\n self.sheep_poses = (np.random.uniform(-self.init_sheep_range, \\n self.init_sheep_range, size=(self.num_sheep,2))) \\\\\\n + init_sheep_pose[None,:]\\n self.sheep_com = self.sheep_poses.mean(axis=0)\\n\\n # get the farthest sheep and radius of the sheep\\n dist_to_com = np.linalg.norm((self.sheep_poses - self.sheep_com[None,:]), axis=1)\\n self.farthest_sheep = self.sheep_poses[np.argmax(dist_to_com),:]\\n self.radius_sheep = np.array([np.max(dist_to_com)])\\n\\n # update distance to target\\n self.target_distance = np.linalg.norm(self.target - self.sheep_com)\\n\\n # initialize values for reward estimation\\n self.init_radius_sheep = self.radius_sheep\\n self.init_target_distance = self.target_distance\\n\\n # initialize dog position\\n if self.fixed_reset:\\n init_dog_pose = np.array([0.0,75.0])\\n else:\\n init_theta = np.random.uniform(-np.pi,np.pi)\\n init_dog_pose = init_sheep_pose + self.init_dog_distance*np.array([np.cos(init_theta), \\n np.sin(init_theta)])\\n self.dog_pose = init_dog_pose\\n\\n # initialize inertia\\n self.inertia = np.ones((self.num_sheep, 2))\\n\\n # initialize episode reward and length\\n self.episode_reward = 0\\n self.episode_length = 0\\n\\n # get the state, reward, finish, info\\n state = self._get_state()\\n \\n return state\",\n \"def full_reset(self):\\n self.at_cmd('CFUN=1')\",\n \"def analyse(self):\\n self.__try_fitting()\\n self.second.rotate()\\n self.__try_fitting()\",\n \"def clear(self):\\n # K_p * e\\n self.PTerm_x = 0.0\\n self.PTerm_y = 0.0\\n self.PTerm_z = 0.0\\n self.PTerm_rot_z = 0.0\\n # K_i * integral(e)\\n self.ITerm_x = 0.0\\n self.ITerm_y = 0.0\\n self.ITerm_z = 0.0\\n self.ITerm_rot_z = 0.0\\n\\n # K_d * derivative(e)\\n self.DTerm_x = 0.0\\n self.DTerm_y = 0.0\\n self.DTerm_z = 0.0\\n self.DTerm_rot_z = 0.0\\n self.last_error_x = 0.0\\n self.last_error_y = 0.0\\n self.last_error_z = 0.0\\n self.last_error_rot_z = 0.0\\n \\n # Windup Guard for integrator\\n self.windup_guard = 0.5\\n\\n self.output_x = 0.0\\n self.output_y = 0.0\\n self.output_z = 0.0\\n self.output_rot_z = 0.0\",\n \"def reset(self):\\n self.robot_path_ind = 0\\n self.goal_path_ind = None\\n self.global_plan = Path()\",\n \"def platform_auto_calibrate(self):\\n self.platform_auto_calibrate_servos()\\n self.platform_auto_calibrate_imu()\",\n \"def cleanup(self):\\n\\n self.PLC['1'].set_plc_mode(0)\\n self.PLC['1'].plc_clear('all')\\n super(Test200SmartSanityClear005, self).cleanup()\",\n \"def resetTransformations():\\n dislin.trfres()\",\n \"def _reset(self):\\n if self.mode not in ['auto', 'min', 'max']:\\n warnings.warn('Learning Rate Plateau Reducing mode %s is unknown, '\\n 'fallback to auto mode.' % (self.mode),\\n RuntimeWarning)\\n self.mode = 'auto'\\n if (self.mode == 'min' or\\n (self.mode == 'auto' and 'acc' not in self.monitor)):\\n self.monitor_op = lambda a, b: np.less(a, b - self.min_delta)\\n self.best = np.Inf\\n else:\\n self.monitor_op = lambda a, b: np.greater(a, b + self.min_delta)\\n self.best = -np.Inf\\n self.cooldown_counter = 0\\n self.wait = 0\",\n \"def reset(self):\\n log.debug(\\\"RESET\\\")\\n self.ref_pos_x = -1\\n self.ref_pos_y = -1\\n self.ref_pos_z = -1\\n self.pos_x = -1\\n self.pos_y = -1\\n self.pos_z = -1\\n self.yaw = 0\\n self.throw_ongoing = False\",\n \"def finalize(self):\\n pass\\n #fftw2py.clean_fftw_solver(self.output_field.dimension)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.629341","0.60715276","0.6038059","0.5894017","0.5803302","0.5768634","0.5759604","0.5733961","0.57175505","0.57133883","0.56535786","0.56385595","0.55656916","0.555237","0.5471464","0.5434825","0.54325277","0.54210687","0.54147273","0.5398735","0.53816754","0.53800416","0.5379507","0.5344598","0.53330034","0.53329456","0.5308781","0.5308441","0.53062516","0.5295551","0.52918285","0.5285262","0.528309","0.52726036","0.5271532","0.5247901","0.5242147","0.5239113","0.52388304","0.5231379","0.5228071","0.5216345","0.52157944","0.5203886","0.5199456","0.51987666","0.5192718","0.5191608","0.51914984","0.5180391","0.5179562","0.5177811","0.51760435","0.51744395","0.5169634","0.5167161","0.516488","0.5164184","0.5163203","0.51551026","0.5147609","0.5147593","0.51455724","0.51443154","0.51418144","0.5141443","0.51354796","0.51321757","0.51285255","0.51265687","0.5125736","0.512436","0.512246","0.5117569","0.51102626","0.5109327","0.5101891","0.50983125","0.5096069","0.50942576","0.50941914","0.5093232","0.50921464","0.5091208","0.50908166","0.5088057","0.5086541","0.50837564","0.507948","0.5075466","0.507104","0.50689936","0.5068082","0.50678176","0.5062443","0.50596124","0.5059609","0.5059551","0.50577366","0.5056482"],"string":"[\n \"0.629341\",\n \"0.60715276\",\n \"0.6038059\",\n \"0.5894017\",\n \"0.5803302\",\n \"0.5768634\",\n \"0.5759604\",\n \"0.5733961\",\n \"0.57175505\",\n \"0.57133883\",\n \"0.56535786\",\n \"0.56385595\",\n \"0.55656916\",\n \"0.555237\",\n \"0.5471464\",\n \"0.5434825\",\n \"0.54325277\",\n \"0.54210687\",\n \"0.54147273\",\n \"0.5398735\",\n \"0.53816754\",\n \"0.53800416\",\n \"0.5379507\",\n \"0.5344598\",\n \"0.53330034\",\n \"0.53329456\",\n \"0.5308781\",\n \"0.5308441\",\n \"0.53062516\",\n \"0.5295551\",\n \"0.52918285\",\n \"0.5285262\",\n \"0.528309\",\n \"0.52726036\",\n \"0.5271532\",\n \"0.5247901\",\n \"0.5242147\",\n \"0.5239113\",\n \"0.52388304\",\n \"0.5231379\",\n \"0.5228071\",\n \"0.5216345\",\n \"0.52157944\",\n \"0.5203886\",\n \"0.5199456\",\n \"0.51987666\",\n \"0.5192718\",\n \"0.5191608\",\n \"0.51914984\",\n \"0.5180391\",\n \"0.5179562\",\n \"0.5177811\",\n \"0.51760435\",\n \"0.51744395\",\n \"0.5169634\",\n \"0.5167161\",\n \"0.516488\",\n \"0.5164184\",\n \"0.5163203\",\n \"0.51551026\",\n \"0.5147609\",\n \"0.5147593\",\n \"0.51455724\",\n \"0.51443154\",\n \"0.51418144\",\n \"0.5141443\",\n \"0.51354796\",\n \"0.51321757\",\n \"0.51285255\",\n \"0.51265687\",\n \"0.5125736\",\n \"0.512436\",\n \"0.512246\",\n \"0.5117569\",\n \"0.51102626\",\n \"0.5109327\",\n \"0.5101891\",\n \"0.50983125\",\n \"0.5096069\",\n \"0.50942576\",\n \"0.50941914\",\n \"0.5093232\",\n \"0.50921464\",\n \"0.5091208\",\n \"0.50908166\",\n \"0.5088057\",\n \"0.5086541\",\n \"0.50837564\",\n \"0.507948\",\n \"0.5075466\",\n \"0.507104\",\n \"0.50689936\",\n \"0.5068082\",\n \"0.50678176\",\n \"0.5062443\",\n \"0.50596124\",\n \"0.5059609\",\n \"0.5059551\",\n \"0.50577366\",\n \"0.5056482\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57821494"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":93179,"cells":{"query":{"kind":"string","value":"Self Calibration. Generate a per observation solution first."},"document":{"kind":"string","value":"def selfcal_pcal(imc, combine='spw,scan', trial='1'):\n if trial == '1':\n solint = 'inf' # Sum entire scheduling block\n elif trial == '2':\n solint = '1800s' # Half block\n else:\n raise ValueError('Invalid pcal trial: {0}'.format(trial))\n caltable = imc.path_base + '.pcal' + trial\n rmtables(caltable)\n gaincal(vis=imc.vislf,\n caltable=caltable,\n gaintype='T',\n refant=imc.refant,\n calmode='p',\n combine=combine,\n solint=solint,\n minsnr=3.0,\n minblperant=6)\n print('-- Check number of solutions lost')"},"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 _doCalibration(self):\n self._cmdCalibration(2)","def fit_once(self,random_restart=True):\n \n if random_restart:\n ## Main mode of operation\n \n # Initializations\n n_iterations = int(np.ceil(np.log2(self.K))) # log_2(K) iterations\n self.initialize_empty_solution()\n self.residual = self.sketch_reweighted\n \n # Add the starting atom\n new_theta = self.randomly_initialize_new_atom()\n new_theta = self.maximize_atom_correlation(new_theta)\n self.add_atom(new_theta)\n \n # Main loop\n for i_iteration in range(n_iterations):\n ## Step 1-2: split the currently selected atoms\n self.split_all_atoms()\n \n ## Step 3: if necessary, hard-threshold to enforce sparsity\n while self.n_atoms > self.K:\n beta = self.find_optimal_weights(normalize_atoms=True)\n index_to_remove = np.argmin(beta)\n self.remove_atom(index_to_remove)\n \n \n ## Step 4: project to find weights\n self.alpha = self.find_optimal_weights()\n \n ## Step 5: fine-tune\n self.minimize_cost_from_current_sol()\n\n # Cleanup\n self.update_Atoms() # The atoms have changed: we must re-compute their sketches matrix\n self.residual = self.sketch_reweighted - self.sketch_of_solution()\n \n # Final fine-tuning with increased optimization accuracy\n self.minimize_cost_from_current_sol(ftol=0.02*self.step5_ftol)\n \n # Normalize weights to unit sum\n self.alpha /= np.sum(self.alpha)\n \n # Package into the solution attribute\n self.current_sol = (self.alpha, self.Theta)","def start_uncorrelated_self_optimizer_strategy(wf):\n\n optimizer_method = wf.execution_strategy[\"optimizer_method\"]\n info(\"> ExecStrategy | UncorrelatedSelfOptimizer\", Fore.CYAN)\n info(\"> Optimizer | \" + optimizer_method, Fore.CYAN)\n\n knobs = wf.execution_strategy[\"knobs\"]\n wf.totalExperiments = len(knobs) * wf.execution_strategy[\"optimizer_iterations\"]\n\n total_result = dict()\n # we fill the arrays and use the index to map from gauss-optimizer-value to variable\n for key in knobs:\n optimal_knob_value = optimizeOneVariable(wf, wf.execution_strategy[\"optimizer_iterations\"], key,\n (knobs[key][0], knobs[key][1]))\n total_result[key] = optimal_knob_value\n wf.change_provider[\"instance\"].applyChange(total_result)\n info(\">\")\n info(\"> FinalResult | Best Values: \" + str(total_result))","def calibrate(self, master):\n if master.polyorder == 'linear':\n self.fitfunction = \"A0 + A1 * D\"\n self.fit_fkt = self.calc_lin\n elif master.polyorder == 'quadratic':\n self.fit_fkt = self.calc_quad\n self.fitfunction = \"A0 + A1 * D + A2 * D**2\"\n elif master.polyorder == \"cubic\":\n self.fitfunction = \"A0 + A1 * D + A2 * D**2 + A3 * D**3\"\n self.fit_fkt = self.calc_cubic\n else:\n print(\"Polynomgrad nicht definiert\")\n \n self.mw = np.asarray(self.mw)\n if master.sensortype == \"Druck\":\n self.best, self.covar = curve_fit(self.fit_fkt, self.mw, master.Referencedata.caldat)\n else:\n print(\"Sensortyp noch nicht Hinterlegt\")","def solve(self):\n # check for jacobian and set it if present and to be used\n if self.use_sparse:\n if self._use_jac and hasattr(self.problem,'sparse_jac'):\n jac = self.problem.sparse_jac\n else:\n jac = None\n else:\n if self._use_jac and hasattr(self.problem,'jac'):\n jac = self.problem.jac\n else:\n jac = None\n \n # Initialize solver and solve \n \n solved = False\n local_min = False\n\n res = N.zeros(self.x0.__len__())\n while (not solved) and self.reg_count < 2:\n try:\n if self._use_fscale:\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,self.fscale)\n else:\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,None)\n start = time.clock()\n res = self.solver.KINSOL_solve(not self._use_ls)\n stop = time.clock()\n self.exec_time += (stop - start)\n solved = True\n except KINError as error:\n if error.value == 42:\n # Try the heuristic\n if hasattr(self.problem, 'get_heuristic_x0'):\n print \"----------------------------------------------------\"\n print \" Solver stuck with zero step-length.\"\n print \"----------------------------------------------------\"\n print \"The following variables have start value zero\"\n print \"and min set to zero causing the zero step-lenght.\"\n print \"These settings are either set by default or by user.\"\n print \"\"\n\n self.x0 = self.problem.get_heuristic_x0()\n self.reg_count += 1\n \n print \"\"\n print \"This setting (start and min to zero) can often\"\n print \"cause problem when initializing the system. \"\n print \"\"\n print \"To avoid this the above variables have\"\n print \"their start attributes reset to one.\"\n print \"\"\n print \"Trying to solve the system again...\"\n else:\n raise KINSOL_Exception(\"Regularization failed due to constraints, tried getting heuristic initial guess but failed.\")\n \n\n elif (error.value == 2):\n print \"---------------------------------------------------------\"\n print \"\"\n print \" !!! WARNING !!!\"\n print \"\"\n print \" KINSOL has returned a result but the algorithm has converged\"\n print \" to a local minima, the initial values are NOT consistant!\"\n print \"\"\n print \"---------------------------------------------------------\"\n solved = True\n local_min = True\n else:\n # Other error, send onward as exception\n self.problem.check_constraints(res)\n raise KINSOL_Exception(error.msg[error.value])\n \n if not solved:\n self.solver.Free_KINSOL()\n raise KINSOL_Exception(\"Algorithm exited solution loop without finding a solution, please contact Assimulo support.\")\n\n if self.check_with_model:\n self.problem.check_constraints(res)\n if not local_min:\n print \"Problem sent to KINSOL solved.\"\n \n return res","def calc_orig(self):\n measure = self.measure\n # Calculate work for all possible matching pairs from sim and obs\n aw = np.full(shape=(len(self.q_obs), len(self.q_sim)), fill_value=np.nan)\n # iterate through all flow observations\n for i_o in range(len(self.q_obs)):\n # Check only simulations within the allowed window\n for i_s in range(max(0, i_o - self.max_lead),\n min(len(self.q_sim), i_o + self.max_lag + 1)):\n if measure in ('nse', 'square'):\n aw[i_s, i_o] = (self.q_sim[i_s] - self.q_obs[i_o]) ** 2 + self.b ** 2 * (i_s - i_o) ** 2\n elif measure in ('mae', 'abs'):\n aw[i_s, i_o] = np.abs(self.q_sim[i_s] - self.q_obs[i_o]) + self.b * np.abs(i_s - i_o)\n\n # Calculate cumulative work along possible paths\n cw = np.ones(shape=aw.shape + (2,)) * np.nan\n # Populate first column\n cw[:, 0, 0] = aw[:, 0]\n\n if self.keep_internals:\n self.aw = aw\n self.cw = cw\n\n # Populate other columns\n # Filter out warning to suppress warnings from numpy when np.nanmin\n # encounters all NaN slices\n with warnings.catch_warnings():\n warnings.simplefilter('ignore')\n for i_o in range(1, aw.shape[1]):\n for i_s in range(max(0, i_o - self.max_lead),\n min(aw.shape[1], i_o + self.max_lag + 1)):\n # e = aw[i_s, i_o]\n if measure in ('nse', 'square'):\n e = (self.q_sim[i_s] - self.q_obs[i_o]) ** 2 + self.b ** 2 * (i_s - i_o) ** 2\n elif measure in ('mae', 'abs'):\n e = np.abs(self.q_sim[i_s] - self.q_obs[i_o]) + self.b * np.abs(i_s - i_o)\n\n # Repeat the same simulation point\n cw[i_s, i_o, 1] = e + cw[i_s, i_o - 1, 0]\n\n if i_s > 0:\n m1 = np.nanmin(cw[i_s - 1, i_o - 1, :])\n if i_s > 1:\n # Skip a sim point\n m2 = np.nanmin(cw[i_s - 2, i_o - 1, :])\n else:\n m2 = np.inf\n m = min(m1, m2)\n cw[i_s, i_o, 0] = e + m\n self.opt_score = np.nanmin(cw[:, -1, :])\n self.of = 1 - self.opt_score / self.fbench\n\n if self.calc_rays:\n # self._do_calc_rays(cw[:, :, 0], cw[:, :, 1])\n s, e = 0, None\n for i_o in range(len(self.q_obs))[::-1]:\n # print('')\n # print(i_o, s, e)\n # print(cw[s:e, i_o, 0])\n m = np.nanargmin(cw[s:e, i_o, 0]) + s\n try:\n m_rep = np.nanargmin(cw[s:e, i_o, 1]) + s\n except ValueError:\n pass\n else:\n if cw[m_rep, i_o, 1] <= cw[m, i_o, 0]:\n m = m_rep\n self.tau[i_o] = i_o - m\n self.res[i_o] = self.q_obs[i_o] - self.q_sim[m]\n self.rays[i_o] = [(i_o, self.q_obs[i_o]), (m, self.q_sim[m])]\n # print(i_o, s, e, m)\n s, e = max(0, m - 2), m + 1\n\n return self.of","def solve_prep(self):\n\n par = self.par\n sol = self.sol\n\n # a. retirement\n sol.m_ret = np.zeros((par.T,par.Nm_ret))\n sol.c_ret = np.zeros((par.T,par.Nm_ret))\n sol.a_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_v_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_vm_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_vn_ret = np.zeros((par.T,par.Nm_ret))\n\n # b. working\n if par.solmethod == 'G2EGM':\n\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vn = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.ucon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.ucon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.ucon_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.dcon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.dcon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.dcon_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.acon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.acon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.acon_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.z = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wb = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n \n elif par.solmethod == 'NEGM':\n\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vn = np.zeros((0,0,0))\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wb = np.zeros((0,0,0))\n \n sol.c_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\n sol.inv_v_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))","def on_iteration_start(self):\n\n self.Xfprv = self.Xf.copy()\n if (not self.opt['FastSolve'] or isinstance(self.backtrack,\n BacktrackRobust)):\n self.Yfprv = self.Yf.copy()\n\n if self.opt['Monotone']:\n if self.k == 0:\n self.objfn = self.eval_objfn()\n self.objfn_prev = self.objfn","def _evolve(\n self,\n x0_idx: int,\n ) -> np.ndarray:\n x0 = self.starting_points[x0_idx, :]\n if type(x0) != np.ndarray:\n x0 = x0.toarray()\n x0 = x0.flatten()\n # [T, Dims, (Position, Velocity)]\n trajectory = np.zeros(\n (self.timesteps, x0.shape[0], 3), dtype=np.float32)\n \n # for each timestep, update the position of the phase point\n # based on the velocity of nearest neighbors and obey any\n # boundary constraints\n x = x0\n for t in range(self.timesteps):\n trajectory[t, :, 0] = x # match x position to dv/dx\n v = self.v_fxn(x=x.reshape(-1),)\n # add white noise if desired to better emulate a stochastic process\n noise = v[:, 1] * np.random.randn(v.shape[0]) * self.noise_scale\n x_new = x + (v[:, 0] + noise)*self.step_scale\n # constrain to a set of pre-defined boundaries\n # defaults to an identity if not set explicitly\n x_new = self.boundary_constraint(x_new)\n trajectory[t, :, 1] = v[:, 0]\n trajectory[t, :, 2] = v[:, 1]\n x = x_new\n return trajectory","def automatic_results(self):\n self.find_coefficients()\n self.calculate_numerical_solution()\n self.plot_solution()\n self.L2_norm()","def run_calib(projector=OPTOMA_HD33()):\n w, h = (0.2160, 0.2794)\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\n [-w/2, 0, 0], [w/2, 0, 0],\n [-w/2, 0, h/2], [w/2, 0, h/2]])\n\n global img_points, going\n img_points = []\n\n try:\n window = Window()\n window.MoveXY(1600,0)\n window.ShowFullScreen(True)\n going = True\n\n @window.eventx\n def EVT_MOUSE_EVENTS(evt):\n global going, img_points\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\n img_points.append(evt.Position)\n print('Picked point %d of 6' % (len(img_points)))\n if len(img_points) == len(obj_points):\n print \"Done\"\n going = False\n\n print(\"\"\"[Extrinsic Calibration] \n\nThere should be 6 points marked on the table and backdrop. \nMoving the mouse over the projected display, click each of the points\nin order:\n (left top, on the backdrop),\n (right top, on the backdrop),\n (left center, on the crease),\n (right center, on the crease),\n (left bottom, on the table),\n (right bottom, on the table)\n\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\n\nClick the six points:\n\"\"\")\n\n while going: cv.WaitKey(10)\n\n finally:\n window.Close()\n\n img_points = np.array(img_points, 'f')\n projector.calibrate_extrinsic(img_points, obj_points)\n\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\n print('OK')","def calc_dense2(self):\n # Local copies of instance attributes for faster access\n b = self.b\n qs = self.q_sim\n qo = self.q_obs\n maxlead = self.max_lead\n maxlag = self.max_lag\n measure = self.measure\n time = self.time\n n = len(self.q_obs)\n\n if self.calc_rays:\n warnings.warn('Not possible to calculate connecting rays when using HMA.calc_dense2')\n if self.keep_internals:\n warnings.warn('Not possible to keep internals when using HMA.calc_dense2')\n\n for i_o in range(n):\n # Cycle cw arrays\n if i_o > 0:\n cw0_prev = cw0_cur\n cw1_prev = cw1_cur\n cw0_cur = np.full(n, np.inf, dtype=np.float64)\n cw1_cur = np.full(n, np.inf, dtype=np.float64)\n\n iss = max(0, i_o - maxlead) # sim index start\n ise = min(n, i_o + maxlag + 1) # sim index end\n isv = np.arange(iss, ise) # sim index as vector\n if time is not None:\n dt = time[isv] - time[i_o]\n # Heavily penalize sim-obs combinations outside allowed window\n # so that they are not selected\n dt[(dt < -maxlag) | (dt > maxlead)] = np.inf\n else:\n dt = isv - i_o\n if measure in ('nse', 'square'):\n e = (qs[iss:ise] - qo[i_o]) ** 2 + b ** 2 * dt ** 2\n elif measure in ('mae', 'abs'):\n e = np.abs(qs[iss:ise] - qo[i_o]) + b * np.abs(dt)\n\n if i_o == 0:\n # Only populate first column of cw0 and move to i_o = 1\n cw0_cur[iss:ise] = e\n continue\n\n # Repeat the same simulation point\n d = cw0_prev[iss:ise]\n cw1_cur[iss:ise] = e + d\n\n # Find the 'cheapest' available preceding sim point\n points = np.full((len(isv), 4), np.inf)\n # Use the previous simulation point\n st = max(0, iss-1)\n end = min(n + 1, ise - 1)\n l = end - st\n points[-l:, 0] = cw0_prev[st:end]\n points[-l:, 1] = cw1_prev[st:end]\n # Skip a simulation point\n st = max(0, iss - 2)\n end = min(n + 1, ise - 2)\n l = end - st\n points[-l:, 2] = cw0_prev[st:end]\n points[-l:, 3] = cw1_prev[st:end]\n cw0_cur[iss:ise] = (e + np.min(points, axis=1))\n\n # Find the cheapest point in the last column, i.e. end of cheapest path, i.e. optimum score\n self.opt_score = min(np.min(cw0_cur), np.min(cw1_cur))\n self.of = 1 - self.opt_score / self.fbench\n\n return self.of","def on_iteration_start(self):\n\n self.Xprv = self.X.copy()\n if (not self.opt['FastSolve'] or isinstance(self.backtrack,\n BacktrackRobust)):\n self.Yprv = self.Y.copy()\n\n if self.opt['Monotone']:\n if self.k == 0:\n self.objfn = self.eval_objfn()\n self.objfn_prev = self.objfn","def calibration(self) -> int:","def _generate_solution(self):\n \n operation_list = []\n available = {job.get_job_id(): [operation for operation in job.get_operations() if operation.get_sequence() == 0] for job in self.jssp_instance_data.jobs} # dictionary of first unprocessed operations of each job\n \n while 0 < len(available):\n rand_job_id = random.choice(list(available.keys()))\n rand_operation = random.choice(available[rand_job_id])\n rand_machine = np.random.choice(rand_operation.get_required_machines())\n\n available[rand_job_id].remove(rand_operation)\n \n if len(available[rand_job_id]) == 0:\n # if selected operation is last operation of the job \n if rand_operation.get_sequence() == self.jssp_instance_data.get_job(rand_job_id).get_max_sequence():\n del available[rand_job_id]\n else:\n available[rand_job_id] = [t for t in self.jssp_instance_data.get_job(rand_job_id).get_operations() if\n t.get_sequence() == rand_operation.get_sequence() + 1]\n\n\n operation_list.append([rand_job_id, rand_operation.get_operation_id(), rand_operation.get_sequence(), rand_machine]) # chromosome representation \n return Solution(self.jssp_instance_data, np.array(operation_list, dtype=np.intc))","def solve_and_apply_ensemble(self, save_datapack, ant_idx, time_idx, dir_idx, freq_idx, iterations,\n interval, shift, init_solutions = None, num_threads=1,verbose=False,\n model_kwargs = {}):\n if init_solutions is not None:\n data = np.load(init_solutions)\n\n kern_ls = data['kern_ls']\n kern_var = data['kern_var']\n kern_times = data['time']\n kern_antenna_labels = data['antenna']\n\n \n datapack = self.datapack\n directions, patch_names = datapack.get_directions(dir_idx)\n times,timestamps = datapack.get_times(time_idx)\n antennas,antenna_labels = datapack.get_antennas(ant_idx)\n freqs = datapack.get_freqs(freq_idx)\n\n if ant_idx is -1:\n ant_idx = range(len(antennas))\n if time_idx is -1:\n time_idx = range(len(times))\n if freq_idx is -1:\n freq_idx = range(len(freqs))\n if dir_idx is -1:\n dir_idx = range(len(directions))\n \n\n phase = datapack.get_phase(ant_idx,time_idx,dir_idx,freq_idx)\n Na,Nt,Nd,Nf = phase.shape\n logging.warning(\"Working on shapes {}\".format(phase.shape))\n \n if interval is None:\n interval = Nt\n\n assert interval <= Nt\n\n variance = datapack.get_variance(ant_idx,time_idx,dir_idx,freq_idx)\n error = np.sqrt(variance)\n data_mask = variance < 0\n error[data_mask] = -1\n logging.warning(\"Total masked phases: {}\".format(np.sum(data_mask)))\n\n enu = ENU(obstime=times[0],location = self.datapack.radio_array.get_center())\n \n ant_enu = antennas.transform_to(enu)\n x = np.array([ant_enu.east.to(au.km).value, ant_enu.north.to(au.km).value]).T\n t = times.mjd*86400.#mjs\n d = np.array([directions.ra.deg, directions.dec.deg]).T\n f = freqs\n \n lock = Lock()\n with futures.ThreadPoolExecutor(max_workers=num_threads) as executor:\n jobs = []\n\n for j,aj in enumerate(time_idx[::shift]):\n start = j*shift\n stop = min(start+interval,Nt)\n time_slice = slice(start,stop,1)\n \n# if init_solutions is not None:\n# ###\n# # interpolate kern_params with this interval/shift\n# mean_time = np.mean(times.gps[time_slice])\n\n# model_kwargs['ls_init'] = (\n# np.interp(mean_time, kern_times, kern_ls[ant_idx,:,1].mean(0)),\n# np.interp(mean_time, kern_times, kern_ls[ant_idx,:,0].mean(0))\n# )\n #logging.warning(model_kwargs['ls_init'])\n \n # initial ls_scale (if they exist)\n\n# (phase, error, coords, lock, error_sigma_clip=4., m_type='sgp', \n# iterations=1000, pargs=None,verbose=False,model_kwargs={}):\n model_file = os.path.join(self.proj_dir,\"model_{}_{}\".format(start,stop))\n\n jobs.append(executor.submit(\n self._solve_interval_full,\n model_file,\n phase[:,time_slice,:,:],\n error[:,time_slice,:,:],\n (x, t[time_slice],d,f),\n lock,\n load_model = model_file,\n error_sigma_clip = None,\n m_type='sgp_full',\n iterations=iterations,\n pargs=\"Working on time chunk ({}) {} to ({}) {}\".format(\n start,timestamps[start],stop-1,timestamps[stop-1]),\n verbose=verbose,\n model_kwargs = model_kwargs\n )\n )\n results = futures.wait(jobs)\n if verbose:\n logging.warning(results)\n results = [j.result() for j in jobs]\n\n phase_mean = np.zeros(phase.shape)\n phase_weights = np.zeros(phase.shape)\n variance_mean = np.zeros(variance.shape)\n res_idx = 0\n for j,aj in enumerate(time_idx[::shift]):\n start = j*interval\n stop = min((j+1)*interval,Nt)\n time_slice = slice(start,stop,1)\n res = results[res_idx]\n p,v = res\n phase_mean[:,time_slice,:,:] += p/(v+1e-6)\n variance_mean[:,time_slice,:,:] += 1.\n phase_weights[:,time_slice,:,:] += 1./(v+1e-6)\n res_idx += 1\n phase_mean /= (phase_weights+1e-6)\n variance_mean /= (phase_weights+1e-6)\n datapack.set_phase(phase_mean, ant_idx=ant_idx,time_idx=time_idx,dir_idx=dir_idx,freq_idx=freq_idx)\n datapack.set_variance(variance_mean, ant_idx=ant_idx,time_idx=time_idx,dir_idx=dir_idx,freq_idx=freq_idx)\n datapack.save(save_datapack)","def _fit(self, X):\n n = len(X)\n\n # Initialise start vectors\n w = [0] * n\n for i in range(n):\n if self.randomState is None:\n w[i] = np.ones((X[i].shape[1], 1))\n else:\n w[i] = self.randomState.rand(X[i].shape[1], 1)\n w[i] = w[i] / np.linalg.norm(w[i])\n\n # Find model (Gauss-Siedel iteration)\n func_val = [self.f(X, w)]\n for it in range(self.max_iter):\n for i in range(n):\n wi = 0.0\n for j in range(n):\n if self.pred_comp[i][j] > 0:\n wi += np.dot(X[i].T, np.dot(X[j], w[j]))\n norm_wi = np.linalg.norm(wi)\n if norm_wi > consts.TOLERANCE:\n wi /= norm_wi\n w[i] = wi\n\n func_val.append(self.f(X, w))\n\n if it >= 1:\n err = func_val[-1] - func_val[-2]\n else:\n err = func_val[-1]\n\n self.num_iter = it + 1\n\n if abs(err) < consts.TOLERANCE:\n break\n\n # Find all model vectors\n t = [0] * n\n p = [0] * n\n for i in range(n):\n t[i] = np.dot(X[i], w[i])\n p[i] = np.dot(X[i].T, t[i])\n titi = np.linalg.norm(t[i])**2.0\n if titi > consts.TOLERANCE:\n p[i] = p[i] / titi\n else:\n self.warn(\"Too small joint component for matrix %d! \"\n \"Trying to continue!\" % (i,))\n\n # Normalise P? It matters whether we update with W or with P!\n # TODO: Option?\n# normp = norm(P{i});\n# P{i} = P{i} / normp;\n# T{i} = T{i} * normp;\n\n return w, t, p, func_val","def solve(self):\n \n # Check if cost is available for both estimators\n if not self.est0.cost_avail or not self.est1.cost_avail:\n self.comp_cost = False\n \n # Initial estimate from the input node\n if self.comp_cost:\n z0, zvar0, cost0 = self.est0.est_init(return_cost=True)\n else:\n z0, zvar0 = self.est0.est_init(return_cost=False)\n cost0 = 0\n self.z0 = z0\n self.zvar0 = zvar0\n self.cost0 = cost0\n \n # Initialize other variables\n self.var_cost0 = 0\n self.var_cost1 = 0\n self.cost = 0\n self.s = np.zeros(self.shape1)\n \n for it in range(self.nit):\n \n # Forward transform to est1\n t0 = time.time()\n rvar1_new = self.A.var_dot(self.zvar0)\n rvar1_rep = common.repeat_axes(rvar1_new,self.shape1,\\\n self.var_axes1,rep=False)\n z1_mult = self.A.dot(self.z0)\n r1_new = z1_mult - rvar1_rep*self.s\n \n # Damping\n if it > 0: \n self.r1 = (1-self.step)*self.r1 + self.step*r1_new\n self.rvar1 = (1-self.step)*self.rvar1 + self.step*rvar1_new\n else:\n self.r1 = r1_new\n self.rvar1 = rvar1_new\n\n # Estimator 1 \n if self.comp_cost: \n z1, zvar1, cost1 = self.est1.est(self.r1, self.rvar1, return_cost=True) \n if not self.map_est:\n cost1 -= self.cost_adjust(self.r1,z1,self.rvar1,zvar1,\\\n self.shape1,self.var_axes1)\n else:\n z1, zvar1 = self.est1.est(self.r1, self.rvar1, return_cost=False) \n cost1 = 0\n self.z1 = z1\n self.zvar1 = zvar1\n self.cost1 = cost1 \n con_new = np.mean(np.abs(z1-z1_mult)**2) \n \n # Reverse nonlinear transform to est 0\n self.s = (self.z1-self.r1)/rvar1_rep\n self.sprec = 1/self.rvar1*(1-self.zvar1/self.rvar1)\n t1 = time.time()\n self.time_est1 = t1-t0\n \n # Reverse linear transform to est 0 \n rvar0_new = 1/self.A.var_dotH(self.sprec)\n rvar0_rep = common.repeat_axes(rvar0_new,self.shape0,\\\n self.var_axes0,rep=False)\n r0_new = self.z0 + rvar0_rep*self.A.dotH(self.s)\n \n # Damping\n if it > 0:\n self.r0 = (1-self.step)*self.r0 + self.step*r0_new\n self.rvar0 = (1-self.step)*self.rvar0 + self.step*rvar0_new\n else:\n self.r0 = r0_new\n self.rvar0 = rvar0_new\n \n \n # Estimator 0\n if self.comp_cost:\n z0, zvar0, cost0 = self.est0.est(self.r0, self.rvar0, return_cost=True)\n if not self.map_est:\n cost0 -= self.cost_adjust(self.r0,z0,self.rvar0,zvar0,\\\n self.shape0,self.var_axes0)\n \n else:\n z0, zvar0 = self.est0.est(self.r0, self.rvar0, return_cost=False)\n cost0 = 0\n self.z0 = z0\n self.zvar0 = zvar0\n self.cost0 = cost0 \n\n \n # Compute total cost and constraint \n cost_new = self.cost0 + self.cost1 \n if not self.map_est:\n cost_new += self.cost_gauss()\n \n # Step size adaptation\n if (self.step_adapt) and (it > 0):\n if (con_new < self.con):\n self.step = np.minimum(1,self.step_inc*self.step)\n else:\n self.step = np.maximum(self.step_min, self.step_dec*self.step)\n self.cost=cost_new\n self.con=con_new\n \n t2 = time.time()\n self.time_est0 = t2-t1\n self.time_iter = t2-t0\n \n # Print progress\n if self.prt_period > 0:\n if (it % self.prt_period == 0):\n if self.comp_cost:\n print(\"it={0:4d} cost={1:12.4e} con={2:12.4e} step={3:12.4e}\".format(\\\n it, self.cost, self.con, self.step))\n else:\n print(\"it={0:4d} con={1:12.4e}\".format(\\\n it, self.con))\n \n # Save history\n self.save_hist()","def selfcal_apcal(imc, trial='1'):\n flagmanager(imc.vislf, mode='restore', versionname='startup')\n applycal(vis=imc.vislf,\n spwmap=np.zeros(54),\n interp='linearPDperobs',\n gaintable=[imc.path_base+'.pcal'+trial],\n calwt=False,\n flagbackup=False)","def solve(self):\n\n # Open status display\n fmtstr, nsep = self.display_start()\n\n # Start solve timer\n self.timer.start(['solve', 'solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n\n # Main optimisation iterations\n for self.k in range(self.k, self.k + self.opt['MaxMainIter']):\n\n # Update record of X and Y from previous iteration\n self.on_iteration_start()\n\n # Compute backtracking\n if self.opt['Backtrack'] is not None and self.k >= 0:\n self.timer.stop('solve_wo_btrack')\n # Compute backtracking\n self.backtrack.update(self)\n self.timer.start('solve_wo_btrack')\n else:\n # Compute just proximal step\n self.xstep()\n # Update by combining previous iterates\n self.ystep()\n\n # Compute residuals and stopping thresholds\n self.timer.stop(['solve_wo_rsdl', 'solve_wo_btrack'])\n if not self.opt['FastSolve']:\n frcxd, adapt_tol = self.compute_residuals()\n self.timer.start('solve_wo_rsdl')\n\n # Compute and record other iteration statistics and\n # display iteration stats if Verbose option enabled\n self.timer.stop(['solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n if not self.opt['FastSolve']:\n itst = self.iteration_stats(self.k, frcxd)\n self.itstat.append(itst)\n self.display_status(fmtstr, itst)\n self.timer.start(['solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n\n # Call callback function if defined\n if self.opt['Callback'] is not None:\n if self.opt['Callback'](self):\n break\n\n # Stop if residual-based stopping tolerances reached\n if not self.opt['FastSolve']:\n if frcxd < adapt_tol:\n break\n\n # Increment iteration count\n self.k += 1\n\n # Record solve time\n self.timer.stop(['solve', 'solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n\n # Print final separator string if Verbose option enabled\n self.display_end(nsep)\n\n return self.getmin()","def step(self):\n if self.Y.shape[0]<self.initial_design_numdata:\n self.suggested_sample = initial_design('random', self.space, 1)\n else:\n self.suggested_sample = self._compute_next_evaluations()\n\n self.X = np.vstack((self.X,self.suggested_sample))\n\n # --- Update current evaluation time and function evaluations\n self.num_acquisitions += 1\n\n if self.verbosity:\n print(\"num acquisition: {}\".format(self.num_acquisitions))\n\n return np.array(self.suggested_sample[0,:])","def calibrate(self, Otrain, Ftrain, Feval):\n return Otrain[0] * np.ones(len(Feval))","def objective(trial):\n # The parameters that we will calibrate the model for are shown here.\n # Optuna trial i\n BOD = trial.suggest_uniform(\"BOD\", 0, 1) #Review ranges here\n k_r = trial.suggest_uniform(\"k_r\", 0, 1) #Review Ranges here \n \n def ChLa(t):\n return 1 # Need to link to data\n\n def I(x):\n return 1 # Need to link to data\n\n K_z = 2 * 10**(-5) # p.51\n a = K_z\n k_b = 0.1 # Table 5\n th_b = 1.047 # Table 5\n k_r = 0.1 # Table 5\n YCHO2 = 0.0083 # Table 5\n th_p = 1.036 # Table 5\n th_s = 1.065 # Table 5\n th_r = 1.047 # Table 5\n\n def Temp(t):\n \"\"\"\n Function that maps time to temperature\n \"\"\"\n return 20 # Need to link to data\n\n def P_max(t):\n return 9.6 * 1.036 **(Temp(t) - 20) # Eq. 4\n\n def L_min(t):\n I = 1 # Need to link to PAR data\n K_1 = 0.687 * 1.086**(Temp(t) - 20)\n K_2 = 15\n return I * (1 + 2 * np.sqrt(K_1 / K_2)) / (I + K_1 + I**2 / K_2) # Eq. 5\n \n # f deals with sink and source terms \n def f(x, t):\n return -1 / YCHO2 * k_r * th_r**(Temp(t) - 20) * ChLa(t) + P_max(t) * L_min(t) * ChLa(t) - k_b * th_b**(Temp(t)-20) * BOD \n\n L = 200 # Length of domain\n dt = 1 / 48 # Mesh spacing in t\n F = a * dt # a * dt / dx**2\n T = 100 # Simulation time stop\n\n # Solving the PDE\n DO, x, t, _ = solver_FE_simple(I, a, f, L, dt, F, T)\n \n # Creating some bogus targets while database errors are happening\n DO_data = DO + np.random.random(len(DO))\n\n # Using mean squared error as the measure of fit, where we want\n # to minimize this number\n return ((DO - DO_data)**2).mean()","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 fit_once(self,random_restart=True,n_iterations=None):\n \n if random_restart:\n ## Main mode of operation\n \n # Initializations\n if n_iterations is None:\n n_iterations = 2*self.K # By default: CLOMP-*R* (repeat twice)\n self.initialize_empty_solution()\n self.residual = self.sketch_reweighted\n \n # Main loop\n for i_iteration in range(n_iterations):\n ## Step 1: find new atom theta most correlated with residual\n new_theta = self.randomly_initialize_new_atom()\n new_theta = self.maximize_atom_correlation(new_theta) \n \n ## Step 2: add it to the support\n self.add_atom(new_theta)\n \n ## Step 3: if necessary, hard-threshold to enforce sparsity\n if self.n_atoms > self.K:\n beta = self.find_optimal_weights(normalize_atoms=True)\n index_to_remove = np.argmin(beta)\n self.remove_atom(index_to_remove)\n # Shortcut: if the last added atom is removed, we can skip to next iter\n if index_to_remove == self.K: continue\n \n \n ## Step 4: project to find weights\n self.alpha = self.find_optimal_weights()\n \n ## Step 5: fine-tune\n self.minimize_cost_from_current_sol()\n\n # Cleanup\n self.update_Atoms() # The atoms have changed: we must re-compute their sketches matrix\n self.residual = self.sketch_reweighted - self.sketch_of_solution()\n \n # Final fine-tuning with increased optimization accuracy\n self.minimize_cost_from_current_sol(ftol=0.02*self.step5_ftol)\n \n # Normalize weights to unit sum\n self.alpha /= np.sum(self.alpha)\n \n # Package into the solution attribute\n self.current_sol = (self.alpha, self.Theta)","def calc_dense(self, calc_aw=False):\n # Local copies of instance attributes for faster access\n b = self.b\n qs = self.q_sim\n qo = self.q_obs\n maxlead = self.max_lead\n maxlag = self.max_lag\n measure = self.measure\n time = self.time\n n = len(self.q_obs)\n\n # Calculate work between obs and sim pairs, not needed anymore.\n if calc_aw:\n aw = np.full((n, n), np.nan)\n st = pd.Timestamp.now()\n print('Start aw loops')\n # iterate through all flow observations\n for i_o in range(len(qo)):\n # Check only simulations within the allowed window\n for i_s in range(max(0, i_o - self.max_lead),\n min(len(qs), i_o + maxlag + 1)):\n aw[i_s, i_o] = (qs[i_s] - qo[i_o]) ** 2 + b ** 2 * (i_s - i_o) ** 2\n print('End aw loops', (pd.Timestamp.now()-st)/pd.Timedelta('1s'))\n self.aw = aw\n\n # Old debugging code: run original implementation alongside\n # Applies to all variables appended with _orig\n # aw_orig = np.zeros(shape=(len(self.q_obs), len(self.q_sim))) * np.nan\n # # iterate through all flow observations\n # for i_o in range(len(self.q_obs)):\n # # Check only simulations within the allowed window\n # for i_s in range(max(0, i_o - self.max_lead),\n # min(len(self.q_sim), i_o + self.max_lag + 1)):\n # aw_orig[i_s, i_o] = (self.q_sim[i_s] - self.q_obs[i_o]) ** 2 + self.b ** 2 * (i_s - i_o) ** 2\n\n # Calculate cumulative work along possible paths\n cw0 = np.full((n, n), np.inf, dtype=np.float64)\n cw1 = np.full((n, n), np.inf, dtype=np.float64)\n\n # Old debugging code: run original implementation (with dense arrays) alongside\n # Applies to all variables marked _orig\n # # Calculate cumulative work along possible paths\n # cw_orig = np.ones(shape=aw_orig.shape + (2,)) * np.nan\n # # Populate first column\n # cw_orig[:, 0, 0] = aw_orig[:, 0]\n\n if self.keep_internals:\n # self.aw_orig = aw_orig\n self.cw0 = cw0\n self.cw1 = cw1\n # self.cw_orig = cw_orig\n\n # Filter out warning to suppress warnings from numpy when np.nanmin\n # encounters all NaN slices\n # with warnings.catch_warnings():\n # warnings.simplefilter('ignore')\n\n # Populate other columns\n for i_o in range(n):\n iss = max(0, i_o - maxlead) # sim index start\n ise = min(n, i_o + maxlag + 1) # sim index end\n isv = np.arange(iss, ise) # sim index as vector\n if time is not None:\n dt = time[isv] - time[i_o]\n # Heavily penalize sim-obs combinations outside allowed window\n # so that they are not selected\n dt[(dt < -maxlag) | (dt > maxlead)] = np.inf\n else:\n dt = isv - i_o\n # Vectorized version of the calculation.\n # For understanding it is best to take a look at the calc_sparse, where non-vectorized code is kept for\n # reference\n # Calculate the work for each (sim, obs_i) pair\n if measure in ('nse', 'square'):\n e = (qs[iss:ise] - qo[i_o]) ** 2 + b ** 2 * dt ** 2\n elif measure in ('mae', 'abs'):\n e = np.abs(qs[iss:ise] - qo[i_o]) + b * np.abs(dt)\n if i_o == 0:\n # Only populate first column of cw0 and move to i_o = 1\n cw0[iss:ise, 0] = e\n continue\n\n # Repeat the same simulation point\n d = cw0[iss:ise, i_o - 1]#.toarray()\n d[d == 0] = np.nan\n cw1[iss:ise, i_o] = e + d\n\n # Find the 'cheapest' available preceding sim point\n points = np.full((len(isv), 4), np.inf)\n # Use the previous simulation point, not repeated\n st = max(0, iss-1)\n end = min(n + 1, ise - 1)\n l = end - st\n points[-l:, 0] = cw0[st:end, i_o - 1]\n # Use the previous simulation point, repeated\n points[-l:, 1] = cw1[st:end, i_o - 1]\n # Skip a simulation point, not repeated\n st = max(0, iss-2)\n end = min(n + 1, ise - 2)\n l = end - st\n points[-l:, 2] = cw0[st:end, i_o - 1]\n # Skip a simulation point, repeated\n points[-l:, 3] = cw1[st:end, i_o - 1]\n # Take best preceding point\n cw0[iss:ise, i_o] = (e + np.min(points, axis=1))\n # Find the cheapest point in the last column, i.e. end of cheapest path, i.e. optimum score\n self.opt_score = min(np.min(cw0[:, -1]), np.min(cw1[:, -1]))\n self.of = 1 - self.opt_score / self.fbench\n\n if self.calc_rays:\n self._do_calc_rays(cw0, cw1)\n\n return self.of","def calibrate(): \n \n # Calibrate of the run using beam data. Creates a folder cal-files/caltag \n # containing all calibration data. \n CalObj = Calibration(steerfiles=steerfiles, name=localcaltag + '-cal') \n\n # Set Beam energy\n CalObj.set_beam_momentum(beamenergy)\n\n # Get gearfile and set air as DUT material\n localgearfile = CalObj.get_filename('gear.xml')\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='thickness', value=0.0001)\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='radLength', value=304000.0)\n \n # Create list of calibration steps \n calpath = create_calibration_path(CalObj)\n \n # Run the calibration steps \n CalObj.calibrate(path=calpath,ifile=rawfile_air,caltag=localcaltag)","def photometric_calibration():\n pass","def _compute_results(self):\n self.Y_best = best_value(self.Y)\n self.x_opt = self.X[np.argmin(self.Y),:]\n self.fx_opt = np.min(self.Y)\n self.distance = self._compute_distance_betw_consecutive_x()","def _reset_solution(self, firm_size):\n x_lower, x_upper = self.model.workers.lower, self.model.workers.upper\n y_upper = self.model.firms.upper\n initial_V = np.array([y_upper, firm_size])\n\n if self.model.assortativity == 'positive':\n self.ivp.set_initial_value(initial_V, x_upper)\n wage = self.evaluate_wage(x_upper, initial_V)\n profit = self.evaluate_profit(x_upper, initial_V)\n self._solution = np.hstack((x_upper, initial_V, wage, profit))\n else:\n self.ivp.set_initial_value(initial_V, x_lower)\n wage = self.evaluate_wage(x_lower, initial_V)\n profit = self.evaluate_profit(x_lower, initial_V)\n self._solution = np.hstack((x_lower, initial_V, wage, profit))","def calibration(self, cal: int, /) -> None:","def optimize(self, acqf: MCAcquisitionFunction) -> Tuple[Tensor, Tensor]:\n initial_conditions = self.generate_restart_points(acqf)\n # shape = num_restarts x *acqf.batch_shape x 1 x dim_X\n if self.inequality_constraints is not None:\n org_shape = initial_conditions.shape\n initial_conditions = initial_conditions.reshape(\n self.num_restarts, -1, self.dim_x\n )\n options = {\"maxiter\": int(self.maxiter / 25)}\n with settings.propagate_grads(True):\n solutions, values = gen_candidates_scipy(\n initial_conditions=initial_conditions,\n acquisition_function=acqf,\n lower_bounds=self.bounds[0],\n upper_bounds=self.bounds[1],\n options=options,\n inequality_constraints=self.inequality_constraints,\n )\n self.add_solutions(solutions.view(-1, 1, self.dim_x).detach())\n best_ind = torch.argmax(values, dim=0)\n if self.inequality_constraints is not None:\n solutions = solutions.reshape(org_shape)\n solution = solutions.gather(\n dim=0,\n index=best_ind.view(1, *best_ind.shape, 1, 1).repeat(\n *[1] * (best_ind.dim() + 2), self.dim_x\n ),\n )\n if self.inequality_constraints is not None:\n org_shape = solution.shape\n solution = solution.reshape(1, -1, self.dim_x)\n options = {\"maxiter\": self.maxiter}\n with settings.propagate_grads(True):\n solution, value = gen_candidates_scipy(\n initial_conditions=solution,\n acquisition_function=acqf,\n lower_bounds=self.bounds[0],\n upper_bounds=self.bounds[1],\n options=options,\n inequality_constraints=self.inequality_constraints,\n )\n # This is needed due to nested optimization\n value = acqf(solution)\n if self.inequality_constraints is not None:\n solution = solution.reshape(org_shape)\n return solution, value.reshape(*acqf.batch_shape)","def fit(self):\n \n self.createGraph()\n self.setOfdPlus()\n self.setOfdMoins()\n\n self.arrayStep = list()\n \n for i in range(0, self.nbIteration):\n p = self.ptD()\n for u in range(0, self.nbUser):\n # Aulieu de prendre tous les users pour la boucle ci-dessus\n # prendre seulement les successeurs, serait plus efficace.\n for v in range(0, self.nbUser):\n sumThetaPtd = 0\n sumDSets = len(self.dPlus[u,v]) + self.dMoins[u][v]\n for d in self.dPlus[u,v]:\n sumThetaPtd += self.theta[u][v]/p[d][v]\n self.theta[u][v] = sumThetaPtd/sumDSets\n \n self.arrayStep.append(self.theta.copy())\n \n self.arrayStep = np.asarray(self.arrayStep)","def step(self):\n # A = self.array\n # B = self.array2\n # ra, rb, f, k = self.params\n H = self.array\n L = self.array2\n birth_rate, death_rate, a, c = self.params\n \n # cA = correlate2d(A, self.kernel, **self.options)\n # cB = correlate2d(B, self.kernel, **self.options)\n cH = correlate2d(H, self.kernel,**self.options)\n cL = correlate2d(L, self.kernel, **self.options)\n\n # reaction = A * B**2\n\n # self.array += ra * cA - reaction + f * (1-A) \n # self.array2 += rb * cB + reaction - (f+k) * B\n self.array += birth_rate*cH - a*L*H\n self.array2 += c*cL*cH - death_rate*L","def calc_control_and_trajectory(x, dw, goal, ob):\n x_init = np.array(x)\n\n best_u = [0.0, 0.0]\n best_trajectory = None\n\n u_samples = []\n traj_samples = []\n cost_samples = []\n # evaluate all trajectory with sampled input in dynamic window\n for v in np.arange(dw[0], dw[1], Config.v_resolution):\n for y in np.arange(dw[2], dw[3], Config.yaw_rate_resolution):\n\n trajectory = predict_trajectory(x_init, v, y)\n # calc cost\n to_goal_cost = calc_to_goal_cost(trajectory, goal)\n speed_cost = (Config.max_speed - trajectory[-1, 3])\n ob_cost = calc_obstacle_cost(trajectory, ob)\n\n cost_samples.append([to_goal_cost,speed_cost,ob_cost])\n u_samples.append([v, y])\n traj_samples.append(trajectory)\n cost_samples = np.array(cost_samples)\n # normalization\n def normalize_0_1(x):\n if np.max(x)-np.min(x)>1e-4:\n return (x-np.min(x))/(np.max(x)-np.min(x))\n else:\n return np.zeros_like(x)\n\n def normalize_div_sum(x):\n if np.sum(x) > 1e-4:\n return x/np.sum(x)\n else:\n return np.zeros_like(x)\n\n # for i in range(3):\n # non_inf = cost_samples[:,i] != np.inf\n # if np.sum(non_inf) >0:\n # cost_samples[non_inf,i] = normalize_0_1(cost_samples[non_inf,i])\n \n cost_samples = Config.to_goal_cost_gain*cost_samples[:,0]+Config.speed_cost_gain*cost_samples[:,1]+Config.obstacle_cost_gain*cost_samples[:,2]\n ind = np.argmin(cost_samples)\n best_u = u_samples[ind]\n best_trajectory = traj_samples[ind]\n\n if abs(best_u[0]) < Config.robot_stuck_flag_cons \\\n and abs(x[3]) < Config.robot_stuck_flag_cons:\n # to ensure the robot do not get stuck in\n # [v,w] = [0,0], force the robot rotate\n best_u[1] = -Config.max_delta_yaw_rate\n return best_u, best_trajectory","def evolute(self, ngen, x0=None, verbose=True):\r\n self.history = {'local_fitness':[], 'global_fitness':[], 'a': [], 'A': []}\r\n self.best_fitness=float(\"inf\") \r\n self.verbose=verbose\r\n self.Positions = np.zeros((self.nwhales, self.dim))\r\n if x0:\r\n assert len(x0) == self.nwhales, '--error: the length of x0 ({}) MUST equal the number of whales in the group ({})'.format(len(x0), self.nwhales)\r\n for i in range(self.nwhales):\r\n self.Positions[i,:] = x0[i]\r\n else:\r\n #self.Positions=self.init_sample(self.bounds) #TODO, update later for mixed-integer optimisation\r\n # Initialize the positions of whales\r\n \r\n for i in range(self.dim):\r\n self.Positions[:, i] = (np.random.uniform(0, 1, self.nwhales) * (self.ub[i] - self.lb[i]) + self.lb[i])\r\n \r\n fitness0=self.eval_whales()\r\n \r\n self.best_position, self.best_fitness = self.select(self.Positions, fitness0)\r\n \r\n for k in range(0, ngen):\r\n \r\n # a is annealed from 2 to 0\r\n self.a = self.a0 - k * ((self.a0) / (ngen))\r\n # fac is annealed from -1 to -2 to estimate l\r\n self.fac = -1 + k * ((-1) / ngen)\r\n #-----------------------------\r\n # Update Whale Positions\r\n #-----------------------------\r\n self.UpdateWhales()\r\n \r\n #----------------------\r\n # Evaluate New Whales\r\n #----------------------\r\n fitness=self.eval_whales()\r\n \r\n for i, fits in enumerate(fitness):\r\n #save the best of the best!!!\r\n if fits < self.best_fitness:\r\n self.best_fitness=fits\r\n self.best_position=self.Positions[i, :].copy()\r\n \r\n #--mir\r\n if self.mode=='max':\r\n self.fitness_best_correct=-self.best_fitness\r\n self.local_fitness=-np.min(fitness)\r\n else:\r\n self.fitness_best_correct=self.best_fitness\r\n self.local_fitness=np.min(fitness)\r\n\r\n self.history['local_fitness'].append(self.local_fitness)\r\n self.history['global_fitness'].append(self.fitness_best_correct)\r\n self.history['a'].append(self.a)\r\n self.history['A'].append(self.A)\r\n \r\n # Print statistics\r\n if self.verbose and i % self.nwhales:\r\n print('^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^')\r\n print('WOA step {}/{}, nwhales={}, Ncores={}'.format((k+1)*self.nwhales, ngen*self.nwhales, self.nwhales, self.ncores))\r\n print('^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^')\r\n print('Best Whale Fitness:', np.round(self.fitness_best_correct,6))\r\n print('Best Whale Position:', np.round(self.best_position,6))\r\n print('a:', np.round(self.a,3))\r\n print('A:', np.round(self.A,3))\r\n print('^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^')\r\n\r\n if self.verbose:\r\n print('------------------------ WOA Summary --------------------------')\r\n print('Best fitness (y) found:', self.fitness_best_correct)\r\n print('Best individual (x) found:', self.best_position)\r\n print('--------------------------------------------------------------') \r\n \r\n return self.best_position, self.fitness_best_correct, self.history","def fit_once(self,random_restart=False):\n raise NotImplementedError","def _calc_corrections(self): \n searchIter= self._niter-1\n while searchIter > 0:\n trySavefilename= self._createSavefilename(searchIter)\n if os.path.exists(trySavefilename):\n trySavefile= open(trySavefilename,'rb')\n corrections= sc.array(pickle.load(trySavefile))\n trySavefile.close()\n break\n else:\n searchIter-= 1\n if searchIter == 0:\n corrections= sc.ones((self._npoints,2))\n for ii in range(searchIter,self._niter):\n if ii == 0:\n currentDF= self._dftype(surfaceSigma=self._surfaceSigmaProfile,\n beta=self._beta)\n else:\n currentDF= self._dftype(surfaceSigma=self._surfaceSigmaProfile,\n beta=self._beta,\n corrections=corrections,\n npoints=self._npoints,\n rmax=self._rmax,\n savedir=self._savedir,\n interp_k=self._interp_k)\n newcorrections= sc.zeros((self._npoints,2))\n for jj in range(self._npoints):\n thisSurface= currentDF.surfacemass(self._rs[jj],\n use_physical=False)\n newcorrections[jj,0]= currentDF.targetSurfacemass(self._rs[jj],use_physical=False)/thisSurface\n newcorrections[jj,1]= currentDF.targetSigma2(self._rs[jj],use_physical=False)*thisSurface\\\n /currentDF.sigma2surfacemass(self._rs[jj],\n use_physical=False)\n #print(jj, newcorrections[jj,:])\n corrections*= newcorrections\n #Save\n picklethis= []\n for arr in list(corrections):\n picklethis.append([float(a) for a in arr])\n save_pickles(self._savefilename,picklethis) #We pickle a list for platform-independence)\n return corrections","def solve(self, regparam):\n self.regparam = regparam\n \n #Some counters for bookkeeping\n self.stepcounter = 0\n self.flipcounter = 0\n self.nochangecounter = 0\n \n #Cached results\n self.evals = np.multiply(self.svals, self.svals)\n self.newevals = 1. / (self.evals + self.regparam)\n newevalslamtilde = np.multiply(self.evals, self.newevals)\n self.D = np.sqrt(newevalslamtilde)\n #self.D = -newevalslamtilde\n \n self.VTY = self.svecs.T * self.Y\n DVTY = np.multiply(self.D.T, self.svecs.T * self.Y)\n \n #Using lists in order to avoid unnecessary matrix slicings\n self.DVTY_list = []\n self.YTVDDVTY_list = []\n self.classFitnessList = []\n for i in range(self.labelcount):\n DVTY_i = DVTY[:,i]\n self.DVTY_list.append(DVTY_i)\n YTVDDVTY_i = DVTY_i.T * DVTY_i\n self.YTVDDVTY_list.append(YTVDDVTY_i)\n fitness_i = self.size - DVTY_i.T * DVTY_i\n self.classFitnessList.append(fitness_i)\n \n self.Dsvecs_list = []\n self.svecsDDsvecs_list = []\n for i in range(self.size):\n Dsvec = np.multiply(self.D.T, self.svecs[i].T)\n self.Dsvecs_list.append(Dsvec)\n self.svecsDDsvecs_list.append(Dsvec.T*Dsvec)\n \n self.updateA()\n \n \n converged = False\n print(self.classcounts.T)\n if self.callbackfun is not None:\n self.callbackfun.callback(self)\n while True:\n \n converged = self.roundRobin()\n print(self.classcounts.T)\n if self.callbackfun is not None:\n self.callbackfun.callback(self)\n if converged: break\n \n if self.oneclass:\n self.Y = self.Y[:, 0]\n self.A = self.A[:, 0]\n self.results['predicted_clusters_for_training_data'] = self.Y\n self.predictor = self.svdad.createModel(self)","def run_solution1(self):\n return reduce(lambda a, b: a + self.calculate_fuel(b), self.data, 0)","def solve(self):","def get_sol(self):","def _calibrate(self, Otrain, Ftrain, Feval):\n raise NotImplementedError()","def __update(self):\n\n # Make sure loads have been assigned to group\n if type(self.appliedLoad) == Load:\n self.appliedLoad = LoadSet(self.appliedLoad)\n elif type(self.appliedLoad) != LoadSet:\n raise TypeError(\"Applied load must be a Load or LoadSet\")\n\n # Begin Calculations\n _cg = self.cg # calculate the cg once to save computation time\n _appLoad = self.appliedLoad.totalForce\n _appMoment = self.appliedLoad.totalMoment\n\n coef_mat = np.zeros((len(self) * 3, len(self) * 3)) # coeff matrix\n soln_mat = np.zeros(len(self) * 3) # solution matrix\n\n cSet = [[i, i+1, i+2] for i in range(0, 3 * len(self), 3)]\n rSet = [[i+6, i+7, i+8] for i in range(0, 3 * (len(self) - 2), 3)]\n\n for i, j in enumerate(cSet):\n # i = column fastener ID\n # j = column fastener set\n # Mx = yFz - zFy\n # My = zFx - xFz\n # Mz = xFy - yFx\n\n Fx = j[0]\n Fy = j[1]\n Fz = j[2]\n\n # fill in first three rows\n coef_mat[0][Fx] = 1 # sum of Fx\n coef_mat[1][Fy] = 1 # sum of Fy\n coef_mat[2][Fz] = 1 # sum of Fz\n\n # fill in fourth row (sum of Mx at CG)\n coef_mat[3][Fy] = -(F[i].xyz[2] - _cg[2]) # -zFy\n coef_mat[3][Fz] = +(F[i].xyz[1] - _cg[1]) # +yFz\n\n # fill in fifth row (sum of My at CG)\n coef_mat[4][Fx] = +(F[i].xyz[2] - _cg[2]) # +zFx\n coef_mat[4][Fz] = -(F[i].xyz[0] - _cg[0]) # -xFz\n\n # fill in sixth row (sum of Mz at CG)\n coef_mat[5][Fx] = -(F[i].xyz[1] - _cg[1]) # -yFx\n coef_mat[5][Fy] = +(F[i].xyz[0] - _cg[0]) # +xFy\n\n for u, w in enumerate(rSet):\n # u = row fastener ID\n # w = row fastener set\n\n rX = w[0]\n rY = w[1]\n rZ = w[2]\n\n coef_mat[rX][Fy] = -(F[i].xyz[2] - F[u].xyz[2]) # -zFy\n coef_mat[rX][Fz] = +(F[i].xyz[1] - F[u].xyz[1]) # +yFz\n\n coef_mat[rY][Fx] = +(F[i].xyz[2] - F[u].xyz[2]) # +zFx\n coef_mat[rY][Fz] = -(F[i].xyz[0] - F[u].xyz[0]) # -xFz\n\n coef_mat[rZ][Fx] = -(F[i].xyz[1] - F[u].xyz[1]) # -yFx\n coef_mat[rZ][Fy] = +(F[i].xyz[0] - F[u].xyz[0]) # +xFy\n\n # fill in the solution matrix (soln_mat)\n for i in range(3):\n soln_mat[i] = -_netLoad.force[i]\n soln_mat[i+3] = -_netLoad.moment[i]\n\n # fill in the remaining rows\n for i, j in enumerate(rSet):\n # i = fastener\n # j = row\n\n rX = j[0]\n rY = j[1]\n rZ = j[2]\n\n # Mx = (y_cg - y_i)F_znet - (z_cg - z_i)F_ynet + M_xnet\n soln_mat[rX] = - ((_cg[1] - F[i].xyz[1]) * _netLoad.force[2]\n - (_cg[2] - F[i].xyz[2]) * _netLoad.force[1]\n + _netLoad.moment[0])\n\n # My = (z_cg - z_i)F_xnet - (x_cg - x_i)F_znet + M_ynet\n soln_mat[rY] = -((_cg[2] - F[i].xyz[2]) * _netLoad.force[0]\n - (_cg[0] - F[i].xyz[0]) * _netLoad.force[2]\n + _netLoad.moment[1])\n\n # Mz = (x_cg - x_i)F_ynet - (y_cg - y_i)F_xnet + M_znet\n soln_mat[rZ] = -((_cg[0] - F[i].xyz[0]) * _netLoad.force[1]\n - (_cg[1] - F[i].xyz[1]) * _netLoad.force[0]\n + _netLoad.moment[2])\n\n # Solve system of equations\n matSol = np.linalg.lstsq(coef_mat, soln_mat)[0]\n\n # Add resulting fastener loads to fastener objects\n for i, j in enumerate(cSet):\n rX = j[0]\n rY = j[1]\n rZ = j[2]\n\n F[i].force[0] = matSol[rX]\n F[i].force[1] = matSol[rY]\n F[i].force[2] = matSol[rZ]","def solve(self):\n\n # Set up display header if verbose operation enabled\n if self.opt['Verbose']:\n hdr = 'Itn DFidX PriResX DuaResX DFidG' + \\\n ' ResG '\n print(hdr)\n print('-' * len(hdr))\n\n # Main iteration loop\n for n in range(self.opt['MaxMainIter']):\n\n # At start of 2nd iteration, set the numbers of inner\n # iterations for the X and G solvers from the options\n # object for the outer solver\n if n == 1:\n self.slvX.opt['MaxMainIter'] = self.opt['XslvIter']\n self.slvG.opt['MaxMainIter'] = self.opt['GslvIter']\n\n # Run the configured number of iterations of the X (CSC)\n # solver and assign the result to X\n self.X = self.slvX.solve()\n\n # Compute the sum of the subpixel shifts of X\n Xhs = np.sum(fftconv(self.H, self.X.squeeze(), axes=(0, 1)),\n axis=-1)\n\n # Set the convolution kernel in the deconvolution solver\n # to the sum of the subpixel shifts of X\n self.slvG.setG(Xhs)\n # Run the configured number of iterations of the G\n # (deconvolution) solver and crop the result to obtain the\n # updated g\n self.g = self.slvG.solve()[0:self.gshp[0], 0:self.gshp[1]]\n\n # Construct a new dictionary for the X (CSC) solver from\n # the updated psf g\n self.D, self.dn = self.getD(self.g)\n self.slvX.setdict(self.D[..., np.newaxis, np.newaxis, :])\n\n # Display iteration statistics if verbose operation enabled\n if self.opt['Verbose']:\n itsX = self.slvX.getitstat()\n itsG = self.slvG.getitstat()\n fmt = '%3d %.3e %.3e %.3e %.3e %.3e'\n tpl = (n, itsX.DFid[-1], itsX.PrimalRsdl[-1],\n itsX.DualRsdl[-1], itsG.DFid[-1], itsG.Rsdl[-1])\n print(fmt % tpl)\n\n # Return the (normalised) psf estimate g\n return self.g / np.linalg.norm(self.g)","def compute(self):\n\n self.setd = []\n self.satc = [False for cl in self.soft] # satisfied clauses\n self.solution = None\n self.bb_assumps = [] # backbone assumptions\n self.ss_assumps = [] # satisfied soft clause assumptions\n\n if self.oracle.solve():\n # hard part is satisfiable => there is a solution\n self._filter_satisfied(update_setd=True)\n self._compute()\n\n self.solution = list(map(lambda i: i + 1, filter(lambda i: not self.satc[i], range(len(self.soft)))))\n\n return self.solution","def solve(self):\n\n constrains, bounds = self.init_constraint_list()\n result = minimize(self.objective_function,\n x0=self.init_guess,\n constraints=constrains,\n bounds=bounds,\n options={'disp': False})\n\n return result","def _solve_explicit(self, initial_conditions):\n coeff = self.a ** 2 * self.tau / self.h ** 2\n current_solution = initial_conditions\n next_solution = np.empty_like(current_solution)\n solutions = []\n\n for t in self.t_grid:\n next_solution[1:-1] = (\n current_solution[1:-1]\n + (current_solution[:-2] - 2 * current_solution[1:-1] + current_solution[2:]) * coeff\n ) + self.rhs(self.x_grid[1:-1], t) * self.tau\n\n # left bc\n if self.left_bc_type == \"DIRICHLET\":\n next_solution[0] = self.left_bc(t)\n elif self.left_bc_type == \"NEUMANN\":\n next_solution[0] = (\n 4 * next_solution[1]\n - next_solution[2]\n - 2 * self.h * self.left_bc(t)\n ) / 3.0\n\n # right bc\n if self.right_bc_type == \"DIRICHLET\":\n next_solution[-1] = self.right_bc(t)\n elif self.right_bc_type == \"NEUMANN\":\n next_solution[-1] = (\n 4 * next_solution[-2]\n - next_solution[-3]\n + 2 * self.h * self.right_bc(t)\n ) / 3.0\n if self.mode == \"VISUALIZATION\":\n solutions.append((t, next_solution.copy()))\n current_solution = next_solution\n if self.mode == \"TEST\":\n # print(\"Result: \", current_solution.tolist())\n # print(\"Right answer: \", self.anl_solution.tolist())\n self._norma(current_solution)\n elif self.mode == \"VISUALIZATION\":\n return solutions","def __solve(self) -> None:\n pyo.TransformationFactory(\"contrib.detect_fixed_vars\").apply_to(self.model) # type: ignore\n pyo.TransformationFactory(\"contrib.deactivate_trivial_constraints\").apply_to(self.model) # type: ignore\n\n # initialise the solver object\n self._logger.debug(\"[ModelSolver] Solver object initiated...\")\n solver = Config.OPTIMISATION_MODEL_CONFIG['SOLVER_TYPE']\n opt = pyo.SolverFactory(solver)\n if Config.OPTIMISATION_MODEL_CONFIG['SOLVER_OPTION'].get(solver) is not None:\n for k, v in Config.OPTIMISATION_MODEL_CONFIG['SOLVER_OPTION'].get(solver).items():\n opt.options[k] = v\n\n try:\n start_time = datetime.now()\n self._logger.debug(\"[ModelSolver] Solver starting...\")\n results = opt.solve(self.model, tee=True)\n self.results = results\n end_time = datetime.now()\n self._logger.info(f\"[ModelSolver] Solver completed in {end_time - start_time}.\")\n except Exception as e:\n raise Exception(f\"Model optimisation failed with {solver} with error message {e}.\")\n\n if (results.solver.status == SolverStatus.ok) and (results.solver.termination_condition == TerminationCondition.optimal):\n self._logger.info(\"Solution is feasible and optimal\")\n results.write()\n elif results.solver.termination_condition == TerminationCondition.infeasible:\n raise ValueError(\"Model optimisation resulted into an infeasible solution\")\n\n self.model.optimised = True","def calibrate_onc(data, path, model_name):\n \n #split test data (subsets 7-9) into new test (7-8)/train(9) sets\n calibration_train_set = data[((data.subset==7)|(data.subset==8))].copy()\n calibration_test_set = data[data.subset==9].copy()\n\n #define calibration model\n ir = IsotonicRegression(out_of_bounds=\"clip\")\n #fit the model to the probas from the training set\n ir.fit(calibration_train_set.score, calibration_train_set.y )\n \n #evaluate with the test set and save\n calibration_test_set.loc[:,'p_calibrated'] = ir.transform(calibration_test_set.score) \n \n #calibration_test_set.loc[:,'p_calibrated'] = p_calibrated\n \n #save\n with open(path + 'model_calibrated_' + model_name + '.pickle', 'wb') as picklefile: \n pickle.dump(ir,picklefile)\n \n with open(path + 'y_calibrated_' + model_name + '.pickle', 'wb') as picklefile: \n pickle.dump(calibration_test_set, picklefile)\n \n print_calibrated_results(calibration_test_set.y, calibration_test_set.score, calibration_test_set.p_calibrated)\n return calibration_test_set","def solve_environment(self):\n \n #The first problem formulation\n #K kinds of towers\n #See more details about problem formulation in the writeup \n \n #Get a full matrix of the concatenated coverage matrices for \n #each tower type. THis new matrix has dimensions:\n #(Ntowers) x (sum(potential sites)), where the sum o=is over all tower types\n coverage = np.hstack(i for i in self.coverage_matrices)\n print coverage\n print coverage.shape \n \n #Diagonal matrix of the values of each target\n #(for the scenarios where we don't care about maximizing covered value,\n #target_values is just all ones, so this is just the identity matrix)\n V = np.diag(self.target_values)\n \n #If doing scenario where we want to fortify weakest link, only makes\n #sense if all targets are equal value:\n if self.objective_type == 'min_entries':\n V = np.eye(len(self.target_values))\n\n #Get the matrix of coverage values / expected value saved:\n C = np.dot(V,coverage)\n print 'V', V\n print 'coverage', coverage\n print 'C', C\n \n \n #Since not gauranteed to reach global optimum on any particular initialization,\n #run a few times and take the best result.\n #Just define \"best result\" as the result which had the most overall \n #\"converged\" x, combined over all tower kinds. \n# for j in xrange(self.N_random_starts_max):\n \n \n a = 2. #1.\n tau = 1e-4\n N = sum(i for i in self.N_tower_sites)\n w = np.zeros(N)\n ones = np.ones(N)\n p = 1. #the exponents power when doing he exponent method:\n \n for i in xrange(self.N_reweighting_iterations_max):\n #The concatenated vector of occupancies: Concatenated over all\n #of the kinds of towers.\n x = cvx.Variable(N)\n \n #Different objective functions depending on which optimization problem.\n #These are defined in the scenarios in the main function.\n if self.objective_type == 'min_entries':\n operation = cvx.min_entries\n elif self.objective_type == 'sum_entries':\n operation = cvx.sum_entries\n else:\n raise Exception('must specify valid objective_type')\n \n #Objective function includes penalty term for non-binary x values\n if self.penalty_type == 'reweighted_L1':\n #objective = cvx.Maximize(t - x.T*w)\n objective = cvx.Maximize(operation(C*x - x.T*w))\n\n\n #Main constraints on 0<=x<=1\n constraints = [0<=x, x<=1]\n \n \n #And then for each kind of tower, append the constraint that there\n #be exactly N_i towers, or <= quota (depending on constraint type)\n if self.constraints__type == 'fixed_N_towers' or self.constraints__type == 'tower_quotas':\n for tk in xrange(self.N_tower_kinds):\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\n print before_sum\n print before_sum + self.N_tower_sites[tk]\n if self.constraints__type == 'fixed_N_towers':\n constraints.append(cvx.sum_entries(\n x[before_sum : before_sum + self.N_tower_sites[tk]]\n )==self.N_towers[tk])\n elif self.constraints__type == 'tower_quotas':\n constraints.append(cvx.sum_entries(\n x[before_sum : before_sum + self.N_tower_sites[tk]]\n )<=self.budget__tower_quotas[tk])\n print x[before_sum : before_sum + self.N_tower_sites[tk]]\n \n elif self.constraints__type == 'total_cost':\n costs = np.hstack([np.repeat(self.budget__tower_unit_costs[tk],self.N_tower_sites[tk]) for tk in xrange(self.N_tower_kinds)])\n constraints.append(cvx.sum_entries(costs * x) <= self.budget__total_cost) \n \n \n \n\n\n \n \n print 'penalty_type', self.penalty_type\n print 'objective_type', self.objective_type\n print 'constraints__type', self.constraints__type\n print 'budget__tower_quotas', self.budget__tower_quotas\n print 'operation', operation\n print 'objective', objective\n print 'constraints', constraints\n cvx.Problem(objective, constraints).solve(verbose=self.VERBOSE)\n x = np.array(x.value).flatten()\n print 'x', x\n w = a/(tau+np.abs(x))\n p += 1.\n plt.figure(figsize=(5,5))\n plt.plot(x,marker='o')\n plt.savefig('histrograms_{}.png'.format(i))\n print \n \n \n \n \n #From the solution x, get the coordinates of those tower sites where we\n #really do want to place a tower\n #use = np.isclose(x,1.)\n for tk in xrange(self.N_tower_kinds):\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\n y = x[before_sum : before_sum + self.N_tower_sites[tk]]\n inds = np.argsort(y)\n s = y[inds]\n use = np.where(s>.5)[0]\n print inds\n print s\n print use \n if self.constraints__type == 'fixed_N_towers':\n if len(use) != self.N_towers[tk]:\n print 'Solution did not converge properly. Choosing the K best towers.'\n print self.N_towers[tk], len(use)\n # use = use[-self.N_towers[tk]:]\n use = inds[-self.N_towers[tk]:]\n elif self.constraints__type == 'tower_quotas':\n pass #Just use the towers thresholded at > .5\n print use\n \n \n self.coordinates__solved_towers.append([self.coordinates__tower_sites[tk][mm] for mm in inds[use]])","def start_solving(self):\n self.mesh.output_vtk_mesh(self.model_name + \"0\", \n [self.current_pressure, \n self.mesh.get_cell_domain_all()], \n [\"pressure\", \"domain\"])\n\n self.time_step_output(0., 0)\n\n for time_step in range(1,self.number_of_time_steps+1):\n current_time = time_step*self.delta_t\n print(time_step)\n\n self.update_pressure()\n self.find_upwinding_direction()\n self.update_concentration()\n \n if time_step%self.output_frequency == 0:\n self.mesh.output_vtk_mesh(self.model_name+str(time_step), \n [self.current_pressure,\n self.current_concentration, \n self.mesh.get_cell_domain_all()],\n [\"pressure\", \"concentration\" , \"domain\"])\n\n self.time_step_output(current_time, time_step)","def determine_analytic_solution(self):\n\n self._Janalytic = np.where(self.xr <= self.xint, self.S, 0.5 * self.S)\n self._Hanalytic = np.where(self.xr <= self.xint, 0, 0.25 * self.S)\n self._Kanalytic = np.where(self.xr <= self.xint, 1./3. * self.S,\n 1./6. * self.S)","def fit_recurrent(self, x, y):\n # print('Stage 1')\n x_ = self.scaler_s1.fit_transform(x)\n\n self.basemodel.fit(x_, y)\n self.training_hit_probability = self._hitprobability(x_, y)\n\n # Learn the hit probability\n self.hitproba = HitProbability()\n self.hitproba.fit(x_, self.training_hit_probability)\n\n # Learn high confidence for all classes\n hm_y, auto_gamma = self._adjust_gamma(self.training_hit_probability)\n self.joint_class_hc = HC_LR()\n self.joint_class_hc.fit(x_, hm_y)\n\n # hm_subtypes = []\n # proba_subtypes = []\n\n # while np.mean(y_) > 0.01:\n # for label in np.unique(y):\n\n hm_1hot = []\n hm_1hot.append(self._one_hot(self.training_hit_probability, y)[0])\n y_ = y.copy()\n\n self.recurrent_base = []\n self.recurrent_hpc = []\n for ii in range(self.recurrent_modes):\n print('Stage 1 iter: ' + str(ii))\n #self.recurrent_base.append(BaseSvc())\n\n if np.sum(y_) > 2:\n self.basemodel = BaseSvc()\n hm_y, proba_tmp = self._fit_mode(x_, y_)\n hm_candidate = self._one_hot(proba_tmp, y_)[1]\n else:\n hm_candidate = np.zeros_like(y_)\n\n self.recurrent_base.append(self.basemodel)\n\n #if np.sum(hm_candidate) >= 2:\n hm_1hot.append(hm_candidate)\n\n # remove the selected subgroup from the target list\n y_[hm_1hot[-1] == 1] = 0\n\n # make the default base model the first\n self.basemodel = self.recurrent_base[0]\n\n print('Stage 2')\n # Stage 2\n # hm_1hot = hm_subtypes\n # train stage2\n self.confidencemodel.fit(x_, hm_1hot)","def recalibrate_start(self):\n self.epoch += 1\n self.initialize()\n self.recalibration_i = 0\n\n if self.vr_from_epoch is not None and self.epoch >= self.vr_from_epoch:\n for group in self.param_groups:\n for p in group['params']:\n param_state = self.state[p]\n param_state['gavg'].zero_()\n param_state['m2'].zero_()\n\n # xk is changed to the running_x\n p.data.zero_().add_(param_state['running_x'])\n param_state['tilde_x'] = p.data.clone()","def solve(self):\n measure = None\n while not self.step():\n self._nbSteps += 1\n measure = self.measure(lastMeasure=measure)","def solve_l1(y, A_fun, AT_fun, lambda_l1, reshape_img_fun, show_img_progress=False, alpha=0.2, max_iter=100, solver_tol=1e-6):\n\n\n obj_lss = np.zeros(max_iter)\n x_zs = np.zeros(max_iter)\n u_norms = np.zeros(max_iter)\n times = np.zeros(max_iter)\n\n ATy = AT_fun(y)\n x_shape = ATy.shape\n d = np.prod(x_shape)\n\n def A_cgs_fun(x):\n x = np.reshape(x, x_shape, order='F')\n y = AT_fun(A_fun(x)) + alpha * x\n return vec(y)\n A_cgs = LinearOperator((d,d), matvec=A_cgs_fun, dtype='float')\n\n def compute_p_inv_A(b, z0):\n (z,info) = sp.sparse.linalg.cgs(A_cgs, vec(b), x0=vec(z0), tol=1e-3, maxiter=100)\n if info > 0:\n print('cgs convergence to tolerance not achieved')\n elif info <0:\n print('cgs gets illegal input or breakdown')\n z = np.reshape(z, x_shape, order='F')\n return z\n\n\n def A_cgs_fun_init(x):\n x = np.reshape(x, x_shape, order='F')\n y = AT_fun(A_fun(x))\n return vec(y)\n A_cgs_init = LinearOperator((d,d), matvec=A_cgs_fun_init, dtype='float')\n\n def compute_init(b, z0):\n (z,info) = sp.sparse.linalg.cgs(A_cgs_init, vec(b), x0=vec(z0), tol=1e-2)\n if info > 0:\n print('cgs convergence to tolerance not achieved')\n elif info <0:\n print('cgs gets illegal input or breakdown')\n z = np.reshape(z, x_shape, order='F')\n return z\n\n # initialize z and u\n z = compute_init(ATy, ATy)\n u = np.zeros(x_shape)\n\n\n plot_normalozer = matplotlib.colors.Normalize(vmin=0.0, vmax=1.0, clip=True)\n\n\n start_time = timeit.default_timer()\n\n for iter in range(max_iter):\n\n # x-update\n net_input = z+u\n Wzu, wbook = wavelet_transform(net_input)\n q = soft_threshold(Wzu, lambda_l1/alpha)\n x = inverse_wavelet_transform(q, wbook, x_shape)\n x = np.reshape(x, x_shape)\n\n # z-update\n b = ATy + alpha * (x - u)\n z = compute_p_inv_A(b, z)\n\n # u-update\n u += z - x;\n\n if show_img_progress == True:\n\n fig = plt.figure('current_sol')\n plt.gcf().clear()\n fig.canvas.set_window_title('iter %d' % iter)\n plt.subplot(1,3,1)\n plt.imshow(reshape_img_fun(np.clip(x, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\n plt.title('x')\n plt.subplot(1,3,2)\n plt.imshow(reshape_img_fun(np.clip(z, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\n plt.title('z')\n plt.subplot(1,3,3)\n plt.imshow(reshape_img_fun(np.clip(net_input, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\n plt.title('netin')\n plt.pause(0.00001)\n\n\n obj_ls = 0.5 * np.sum(np.square(y - A_fun(x)))\n x_z = np.sqrt(np.mean(np.square(x-z)))\n u_norm = np.sqrt(np.mean(np.square(u)))\n\n print('iter = %d: obj_ls = %.3e |x-z| = %.3e u_norm = %.3e' % (iter, obj_ls, x_z, u_norm))\n\n\n obj_lss[iter] = obj_ls\n x_zs[iter] = x_z\n u_norms[iter] = u_norm\n times[iter] = timeit.default_timer() - start_time\n\n if x_z < solver_tol:\n break\n\n infos = {'obj_lss': obj_lss, 'x_zs': x_zs, 'u_norms': u_norms,\n 'times': times, 'alpha':alpha, 'lambda_l1':lambda_l1,\n 'max_iter':max_iter, 'solver_tol':solver_tol}\n\n\n return (x, z, u, infos)","def calibrate(self):\n\t\tLTOGRIGHT = []\n\t\tLTOGUP = []\n\t\tRTOGRIGHT = []\n\t\tRTOGUP = []\n\t\tstart = time.time()\n\t\tcalibration_time = 5.0\n\t\twhile time.time() - start < calibration_time:\n\t\t\tevents = pygame.event.get()\n\t\t\tfor event in events:\n\t\t\t\tif event.type == pygame.JOYAXISMOTION:\n\t\t\t\t\tLTOGRIGHT.append(self.joystick.get_axis(self.LTOGRIGHT))\n\t\t\t\t\tLTOGUP.append(-self.joystick.get_axis(self.LTOGUP))\n\t\t\t\t\tRTOGRIGHT.append(self.joystick.get_axis(self.RTOGRIGHT))\n\t\t\t\t\tRTOGUP.append(-self.joystick.get_axis(self.RTOGUP))\n\n\t\t# calibration sets highest value equal to 1.0\n\t\tself.calibration[0] = 1.0/max(LTOGRIGHT)\n\t\tself.calibration[1] = -1.0/min(LTOGRIGHT)\n\t\tself.calibration[2] = -1.0/min(LTOGUP)\n\t\tself.calibration[3] = 1.0/max(LTOGUP)\n\t\tself.calibration[4] = 1.0/max(RTOGRIGHT)\n\t\tself.calibration[5] = -1.0/min(RTOGRIGHT)\n\t\tself.calibration[6] = -1.0/min(RTOGUP)\n\t\tself.calibration[7] = 1.0/max(RTOGUP)","def generatelookup(num_probes = 16):\n calibration_lookup= [[0] * 3 for i in range(num_probes)]\n # print(calibration_lookup)\n day = '050119r'\n date = '050119'\n\n def _run_calib(shots, dir):\n \"\"\" Helper function \"\"\"\n for shot in shots:\n shot = day+str(shot)\n ratios = ratio_4_doc(shot, dir)\n for i in range(num_probes):\n calibration_lookup[i][dir] = calibration_lookup[i][dir] + ratios[i][dir]\n if shot == shots[-1]: #on the last shot, divide by the number of shots\n calibration_lookup[i][dir] = calibration_lookup[i][dir]/ len(shots)\n\n # shot = day+str(13)\n # ratios = ratio_4_doc(shot, 2)\n # time,eastcurrent,westcurrent = loadcurrent(shot)#u\n # plt.plot(time, eastcurrent, label = 'current')\n #\n # plt.show()\n # print(\"And the max current is %f\" %polyPeak_noPlot(time,eastcurrent))\n # #check if cm or m\n # r = get_probeLocs_calib_setup(shot)\n # print(\"r is:\", r[1])\n # print(ratios)\n #\n #\n # X - direction\n print(\"Generating X - dir\")\n shots = np.arange(17,21)\n _run_calib(shots, 0)\n\n\n # Y - direction\n print(\"Generating Y - dir\")\n shots = np.arange(21,26)\n _run_calib(shots, 1)\n\n print(\"Generating Z - dir\")\n # Z - direction\n shots = np.arange(11,16)\n _run_calib(shots, 2)\n\n\n pth = os.getcwd()\n print(\"Finished! File saved as calib-%s-4x4_lookup_5.txt in cwd\" %(date))\n savetxt(os.path.join(pth, 'calib-%s-4x4_lookup_5.txt' % (date)) , calibration_lookup)","def _redef_sp1_vars(self):\r\n\r\n if len(self.fq_list) == 0:\r\n no_rad = True\r\n lst_tmp = np.matrix(np.reshape(self.lst_tmp, \r\n (self.lst_tmp.size, 1)))\r\n else: no_rad = False\r\n # The practically constants...\r\n # Big Epsilon:\r\n if self.cond == True:\r\n self.Epsilon = self.d_T * self.thermal_conductivity\r\n else:\r\n self.Epsilon = (self.diff_scale ** 2) / \\\r\n (3.0 * self.absorb_coeffs[self.rad] ** 2)\r\n # Beta:\r\n if self.cond == True:\r\n self.Beta = (self.diff_scale * self.thermal_conductivity) / \\\r\n (self.convect_coeff)\r\n else:\r\n self.Beta = (1.0 + 3.0 * self.r2) * (2.0 * self.diff_scale) / \\\r\n ((1.0 - 2.0 * self.r1) * (\r\n 3.0 * self.absorb_coeffs[self.rad]))\r\n\r\n # The feild solutions at the last timestep.\r\n # The integral vF:\r\n if self.cond == True:\r\n # The horrifically complicated F:\r\n def F_func_cond(elem, eta):\r\n F = 0.0\r\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n F += Tn\r\n for k in range(0, len(self.fq_list)):\r\n vk = self.fq_list[k]\r\n try:\r\n vk_m = self.fq_list[k - 1]\r\n except:\r\n vk_m = self.v0_frequency\r\n absorbtion = self.absorb_coeffs[k]\r\n phi = elem.eval_elem(self.node_map, self.lst_rad[k],\r\n [eta])[0]\r\n inter1 = phi - 4.0 * sconst.pi * \\\r\n self.B_int_function(Tn, self.refr_idx_vol,\r\n vk, vk_m)\r\n inter2 = absorbtion * self.d_T / (self.diff_scale ** 2)\r\n F += inter2 * inter1\r\n return elem.funcs(eta) * F\r\n if not no_rad:\r\n # We're integrating something non-linear for SP1\r\n self.vF_vect_vol = et.elems_2_array(self.mesh,\r\n F_func_cond,\r\n self.node_map)\r\n else:\r\n # Or something easier if we're only looking at heat.\r\n self.vF_vect_vol = np.array(self.uv_vol * lst_tmp).reshape(-1)\r\n else:\r\n def F_func_radiative(elem, eta):\r\n T = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n vk = self.fq_list[self.rad]\r\n try:\r\n vk_minus = self.fq_list[self.rad - 1]\r\n except:\r\n vk_minus = self.v0_frequency\r\n n = self.refr_idx_vol\r\n F = 4.0 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\r\n return elem.funcs(eta) * F\r\n\r\n self.vF_vect_vol = et.elems_2_array(self.mesh,\r\n F_func_radiative,\r\n self.node_map)\r\n # The path integral vf:\r\n if self.cond == True:\r\n def f_func_cond(elem, eta):\r\n Tb = self.background_temperature\r\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n n = self.refr_idx_background\r\n vk = self.v0_frequency\r\n vk_minus = 0\r\n Bb0 = self.B_int_function(Tb, n, vk, vk_minus)\r\n Bn0 = self.B_int_function(Tn, n, vk, vk_minus)\r\n B_coeff = (self.alpha * sconst.pi) / self.convect_coeff\r\n f = Tb + B_coeff * (Bb0 - Bn0)\r\n return elem.funcs(eta) * f\r\n if not no_rad:\r\n self.vf_vect_bound = et.edge_2_array(self.mesh,\r\n \"Boundary\",\r\n f_func_cond,\r\n self.node_map)\r\n else:\r\n try:\r\n self.vf_vect_bound = self.cache_tb_integral_array\r\n except AttributeError:\r\n def elem_functor(elem, eta): return elem.funcs(eta)\r\n self.cache_tb_integral_array = et.edge_2_array(self.mesh,\r\n \"Boundary\",\r\n elem_functor,\r\n self.node_map)\r\n self.cache_tb_integral_array *= self.background_temperature\r\n self.vf_vect_bound = self.cache_tb_integral_array\r\n \r\n else:\r\n # Radiation f = 4*pi*B^{(k)}(T_b, n_g)\r\n def f_func_radiative(elem, eta):\r\n T = self.background_temperature\r\n vk = self.fq_list[self.rad]\r\n try:\r\n vk_minus = self.fq_list[self.rad - 1]\r\n except:\r\n vk_minus = self.v0_frequency\r\n n = self.refr_idx_vol\r\n f = 4 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\r\n return elem.funcs(eta) * f\r\n\r\n self.vf_vect_bound = et.edge_2_array(self.mesh,\r\n \"Boundary\",\r\n f_func_radiative,\r\n self.node_map)\r\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\r\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\r\n assert (self.vf_vect_bound.shape[0] == \\\r\n self.vF_vect_vol.shape[0])","def new_iteration(self):\n if (\n self.inner_solutions is not None\n and self.inner_solutions.size(0) > self.raw_samples\n ):\n indices = torch.randperm(n=self.inner_solutions.size(0))[: self.raw_samples]\n self.inner_solutions = self.inner_solutions[indices]\n self.inner_values = self.inner_values[indices]","def solve_VFI(self):\r\n dimC = self.dimA ; dimA = self.dimA ; dimW = self.dimW \r\n C = self.c_grid ; A = self.a_grid ; W = self.W_grid\r\n tol = self.tol ; Niter = self.Niter ; R = self.R\r\n beta = self.beta ; Pi = self.Pi\r\n \r\n V0 = np.zeros((dimA,dimC,dimW))\r\n V1 = np.zeros((dimA,dimC,dimW))\r\n Pol = np.zeros((dimA,dimC,dimW))\r\n U = np.zeros((dimA,dimC,dimW))\r\n \r\n t0 = time()\r\n diff = 1 ; niter = 0\r\n \r\n while diff > tol:\r\n niter += 1\r\n # Value update step\r\n for ia in range(dimA):\r\n for ic in range(dimC):\r\n for iw in range(dimW):\r\n c = W[iw] + R*A[ia] - A\r\n x = C[ic]\r\n \r\n c[c < 0] = np.nan \r\n if x < 0:\r\n x = np.nan\r\n \r\n u = self.u(c,x) \r\n U[:,ic,iw] = u \r\n \r\n Objective = U + beta * V0 @ Pi.T\r\n V1[ia,:,:] = np.nanmax(Objective, axis = 0)\r\n Pol[ia,:,:] = np.nanargmax(Objective, axis = 0)\r\n \r\n # Evaluate distance between the value functions\r\n diff = np.max(np.max(np.abs(V1 - V0))) \r\n V0[:] = V1\r\n \r\n # Break the while loop if too many iterations\r\n #print(\"The current error is \"+str(diff))\r\n if niter > Niter:\r\n print('Ops, no convergence')\r\n break\r\n \r\n t1 = time()\r\n #print('VFI algorithm took {0:0d} iterations and {1:.2f} seconds.'.format(niter, t1 - t0))\r\n \r\n self.V1 = V1 ; self.Pol = Pol","def solve(self):\n max_iter = 1000\n iter_count = 0\n yhat = self.predict()\n loss = self.cross_entropy(yhat)\n gradloss = self.cross_entropy_gradient(yhat)\n while la.norm(gradloss) > 1e-6 and iter_count < max_iter:\n alpha = 1.0\n slope = la.norm(gradloss)**2\n beta_new = self.beta + alpha * gradloss\n yhat = self.predict(beta=beta_new)\n loss_new = self.cross_entropy(yhat)\n while loss_new < loss + 1e-4 * alpha * slope:\n alpha = alpha / 2\n beta_new = self.beta + alpha * gradloss\n yhat = self.predict(beta=beta_new)\n loss_new = self.cross_entropy(yhat)\n self.beta = beta_new\n loss = loss_new\n gradloss = self.cross_entropy_gradient(yhat)\n iter_count += 1","def initial_guess(self):\n\n x0 = [self.material_model.isotropic_matrix.c1, self.material_model.isotropic_matrix.c2]\n\n if not self.material_model.is_isotropic:\n # c5 is scaled in the optimisation function\n x0.append(self.material_model.fibres.c5 / c5_factor)\n\n if self.include_lm:\n x0.append(self.material_model.fibres.lm)\n\n return np.asarray(x0)","def GenerateInitialSolution():\n c = random.random()*C\n count = 0\n while np.count_nonzero(alpha) < gamma:\n rand = random.randint(0, len(x_train)-1)\n if y_train[rand] == 1:\n alpha[rand] = c\n L[rand, 1] = c\n # L[count, 0] = rand\n # L[count, 1] = alpha[rand]\n SVs[count] = rand\n count += 1\n while np.count_nonzero(alpha) < 2*gamma:\n rand = random.randint(0, len(x_train)-1)\n if y_train[rand] == -1:\n alpha[rand] = c\n L[rand, 1] = c\n # L[count, 0] = rand\n # L[count, 1] = alpha[rand]\n SVs[count] = rand\n count += 1\n return alpha","def _solve(self) -> CasADiArrayType:\n solver_input = {\"x0\": self.x0, \"p\": self.p}\n if self.opt_type in CONSTRAINED_OPT:\n solver_input[\"lbg\"] = self._lbg\n solver_input[\"ubg\"] = self._ubg\n self._solution = self._solver(**solver_input)\n self._stats = self._solver.stats()\n self._stats[\"solution\"] = self._solution\n return self._solution[\"x\"]","def run_algorithm(self):\n population_size = self.population_size\n simulator = self.simulator\n num_generations = self.num_generations\n current_dir = os.getcwd()\n urdf = current_dir + os.sep + os.path.join(\"URDF\", \"Ghost\", \"urdf\", \"Ghost.urdf\")\n simulated_robot = Robot(urdf, (0, 0, 0.4))\n simulated_robot.set_id(simulator.load_new_robot_urdf(simulated_robot))\n # make placeholders\n counter = 0\n best_genome = None\n best_fit = 0\n evals = population_size * (num_generations + 1)\n beam_fit = np.zeros(evals)\n current_population = self.make_population()\n current_population_fitness = [0] * self.population_size\n # print(\"build robots\")\n for k in range(self.population_size):\n #\tprint(\"initial robot \" , k)\n robot = current_population[k]\n simulator.load_robot_parameters(robot.parameters, 0)\n robot.set_fitness(simulator.compute_walk_fitness(1000)[0]) # evaluate the robot's fitness\n fitness = robot.get_fitness()\n current_population_fitness[k] = fitness\n \n if counter == 0:\n beam_fit[counter] = current_population_fitness[k] \n else:\n \n if beam_fit[counter - 1] < current_population_fitness[k]: # if the best overall robot thus far\n best_genome = robot.genome.copy() # update the best robot's genome\n beam_fit[counter] = current_population_fitness[k] \n else:\n beam_fit[counter] = beam_fit[counter - 1]\n best_fit = beam_fit[counter]\n\n counter +=1 \n\n\n #\tprint(\"origional robots evaluated, their fitness is \" , )\n for i in range(num_generations): # perform mutations equal to num_Climb\n #\t\t\tprint(\"start of gen , current population_fitness\" , current_population_fitness)\n population = current_population.copy()\n population_fitness = current_population_fitness.copy()\n print('gen' , i)\n for j in range(self.population_size):\n robot = population[j]\n mut_loc, old_val = robot.mutate_genome() # Mutation: Keep track of mut location and previous vals\n simulator.load_robot_parameters(robot.parameters, 0)\n robot.set_fitness(simulator.compute_walk_fitness(1000)[0]) # evaluate the robot's fitness\n fit_new = robot.get_fitness()\n population_fitness[j] = fit_new\n # BIG POINT - here we keep regardless if the change is better or not\n if fit_new > best_fit: # update learning curve\n best_fit = fit_new\n best_genome = robot.genome.copy()\n beam_fit[counter] = best_fit\n counter += 1\n #\t\t\tprint(\" ... \")\n #\t\t\tprint(\"end of gen , current population_fitness\" , current_population_fitness)\n # concat the populations and population fitnesses\n total_population = current_population + population\n total_population_fitness = current_population_fitness + population_fitness\n # print(\"before quick sort \" , total_population_fitness)\n # print(\" ... \")\n # sort the lists\n self.quick_sort(total_population_fitness, total_population, 0, len(total_population) - 1)\n # print(\" after quick sort \" , total_population_fitness)\n # print(\" ... \")\n # keep the top half\n current_population = total_population[:self.population_size]\n current_population_fitness = total_population_fitness[:self.population_size]\n # print(\"keep \", current_population_fitness)\n #\t\tprint(counter)\n\n if not os.path.exists('./data'):\n os.mkdir('./data')\n\n np.savetxt(\"beam_genome_gen_999_pop_100.csv\", best_genome, delimiter=\",\")\n np.savetxt(\"beam_learning_gen_999_pop_100.csv\", beam_fit, delimiter=\",\")","def evaltr(x_solution): \n \n large = 10.0**30\n pred = np.zeros(cfg.ntrain)\n e0 = 0.0 # mean of observed values\n y=0.0\n for i in range(cfg.ntrain): # Computation of correct piece\n e0 += cfg.a_unscaled[i][-1]\n pind = 0\n ipbest = 0\n pbest = -large # for max\n \n for j1 in range(cfg.nomax):\n ipmin=pind\n pmin=large # for min\n for _ in range(cfg.jk[j1]):\n piece=x_solution[(pind+1)*cfg.nfea-1] \n for j3 in range(cfg.nfea-1): #\n piece += x_solution[pind*cfg.nfea+j3]*cfg.a_unscaled[i][j3]\n if piece < pmin:\n ipmin = pind\n pmin = piece\n pind += 1 \n \n if pmin > pbest:\n ipbest = ipmin\n pbest = pmin\n \n pred[i] = x_solution[(ipbest+1)*cfg.nfea-1] # Computation of prediction\n for j1 in range(cfg.nfea-1):\n pred[i] += x_solution[ipbest*cfg.nfea+j1]*cfg.a_unscaled[i][j1]\n y += pred[i]\n \n y = y/cfg.ntrain \n e0 = e0/cfg.ntrain\n \n # Computation of indices\n rmse = 0.0\n mae = 0.0\n e1 = 0.0\n for i in range(cfg.ntrain):\n rmse += (pred[i]-cfg.a_unscaled[i][-1])**2\n mae += np.abs(pred[i]-cfg.a_unscaled[i][-1]) \n e1 += (cfg.a_unscaled[i][-1] - e0)**2\n ce = 1.0 - rmse/e1 \n rmse = np.sqrt(rmse/cfg.ntrain)\n mae = mae/cfg.ntrain \n\n if cfg.ntrain > 1:\n sx=0.0\n sy=0.0\n rcor=0.0\n for i in range(cfg.ntrain):\n sx += (pred[i]-y)**2\n sy += (cfg.a_unscaled[i][-1]-e0)**2 \n rcor += (pred[i]-y) * (cfg.a_unscaled[i][-1]-e0) \n\n r = rcor/np.sqrt(sx*sy)\n \n return rmse,mae,ce,r","def _ica_def(X, tol, g, fun_args, max_iter, w_init):\n\n n_components = w_init.shape[0]\n W = np.zeros((n_components, n_components), dtype=X.dtype)\n n_iter = []\n\n # j is the index of the extracted component\n for j in range(n_components):\n w = w_init[j, :].copy()\n w /= np.sqrt((w**2).sum())\n\n for i in range(max_iter):\n gwtx, g_wtx = g(np.dot(w.T, X), fun_args)\n\n w1 = (X * gwtx).mean(axis=1) - g_wtx.mean() * w\n\n _gs_decorrelation(w1, W, j)\n\n w1 /= np.sqrt((w1**2).sum())\n\n lim = np.abs(np.abs((w1 * w).sum()) - 1)\n w = w1\n if lim < tol:\n break\n\n n_iter.append(i + 1)\n W[j, :] = w\n\n return W, max(n_iter)","def solve_model(self): \n \n t0 = time.time() #start the clock\n \n # a. benchmark case\n \n #i. joint pdf of productivity state and tau \n self.make_joint_pdf(1)\n \n #ii. set policy. in RR08 the benchmark economy has no taxes nor subsidies\n self.tau_benchmark = np.array([0, 0, 0]) #subsidy rate, excempt rate, tax rate \n self.set_tax_system(self.tau_benchmark) #set tax system\n \n #iii. benchmark equilibrium\n self.Yss_b, self.Kss_b, self.TFPss_b, self.average_firm_size_b, self.E_star_b, _, \\\n _, self.N_ss_b, self.w_ss_b, self.cdf_stationary_b, self.cdf_emp_b = self.solve_stationary_equilibrium()\n \n print(\"\\n-----------------------------------------\")\n print(\"Benchmark Stationary Equilibrium\")\n print(\"-----------------------------------------\")\n print(f\"ss output = {self.Yss_b:.2f}\")\n print(f\"ss capital = {self.Kss_b:.2f}\")\n print(f\"ss tfp = {self.TFPss_b:.2f}\")\n print(f\"ss wage = {self.w_ss_b:.2f}\")\n print(f\"entry mass = {self.E_star_b:.3f}\")\n print(f\"avg. firm size = {self.average_firm_size_b:.2f}\")\n \n #b. plot (note that the distributions plotted here are unaffected by the distortionary policies)\n \n if self.plott:\n #i. initialize\n employed = [4.99, 49.99]\n firm_size_by_employee = np.zeros(len(employed)+1)\n share_employment = np.zeros(len(employed)+1)\n \n \n #i. percentage of firms that employ employed\n \n for i_e in range(len(employed)):\n summ = np.sum(firm_size_by_employee)\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_stationary_b, employed[i_e])[0] #labor_demand_rel is labor demand with the lowest value normalized to 1\n firm_size_by_employee[i_e] = interpolate - summ\n firm_size_by_employee[-1] = 1 - np.sum(firm_size_by_employee)\n \n plt.pie(firm_size_by_employee, labels=['<5','5<50','50 =<'], autopct=\"%.1f%%\")\n plt.title('Size of Firms by Firm Size (Number of Employees)')\n plt.savefig('firm_size_rr08.pdf')\n plt.show()\n \n \n #ii. employment percentage by firm size\n for i_e in range(len(employed)):\n summ = np.sum(share_employment)\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_emp_b , employed[i_e])[0]\n share_employment[i_e] = interpolate - summ\n share_employment[-1] = 1 - np.sum(share_employment)\n \n plt.pie(share_employment, labels=['<5','5<50','50 =<'], autopct=\"%.1f%%\")\n plt.title('Employment Share by Firm Size (Number of Employees)')\n plt.savefig('employment_by_firm_size_rr08.pdf')\n plt.show()\n \n #iii. productivity cdf and employment cdf\n plt.plot(self.grid_s, self.cdf_stationary_b)\n plt.plot(self.grid_s, self.cdf_emp_b)\n plt.title('Stationary CDF' )\n plt.xlabel('Productivity level')\n plt.ylabel('Cumulative Sum')\n plt.legend(['Firms by Productivity Level','Share of Employment'])\n plt.savefig('cdf_rr08.pdf')\n plt.show()\n \n \n \n #c. distortion case\n \n #i. joint pdf of productivity state and tau \n self.make_joint_pdf(0)\n \n #ii. compute stationary economy for each tau\n \n for idx, tau in enumerate(self.tau_vector):\n \n #iii. find the subsidy rate that generates the same capital stock as in benchmark economy\n self.tau_s[idx] = self.find_subsidy_rate(tau)\n \n # set tax system with newly found tau_s and given tau\n tauv = np.array([-self.tau_s[idx], self.excempt_frac, tau]) #subsidy rate, excempt rate, tax rate \n self.set_tax_system(tauv) #set tax system\n \n #v. distorted stationary equilibrium\n self.Yss_d[idx], self.Kss_d[idx], self.TFPss_d[idx], self.average_firm_size_d[idx], self.E_star_d[idx], \\\n self.Y_set_d[idx,:], self.subsidy_size_d[idx], self.N_ss_d[idx], self.w_ss_d[idx],\\\n _, _ = self.solve_stationary_equilibrium()\n \n print(\"\\n-----------------------------------------\")\n print(\"Distorted Stationary Equilibrium\")\n print(\"-----------------------------------------\\n\")\n if self.distortion_case == 1:\n print(\"Tax/Subidy Uncorrelated with Firm Level Producitivity\\n\")\n elif self.distortion_case == 2:\n print(\"Tax/Subidy Negatively Correlated with Firm Level Producitivity\")\n print(\"(low productivity firms recieve subsidy, high productivity taxed)\\n\")\n elif self.distortion_case == 2:\n print(\"Tax/Subidy Positively Correlated with Firm Level Producitivity\")\n print(\"(high productivity firms recieve subsidy, low productivity taxed)\\n\")\n if self.policy_type == 1 :\n print(\"Tax Type: Tax on output\\n\")\n elif self.policy_type == 2 :\n print(\"Tax Type: Tax on capital\\n\")\n elif self.policy_type == 3 :\n print(\"Tax Type: Tax on labor\\n\")\n print(f\"fraction of firms recieving subsidy = {self.subsidy_frac:.2f}\")\n print(f\"fraction of firms taxed = {1-self.subsidy_frac-self.excempt_frac:.2f}\")\n print(f\"fraction of firms excempt = {self.excempt_frac:.2f}\")\n print(\"-----------------------------------------\\n\")\n \n print(tabulate([['relative Yss', round(self.Yss_d[0]/self.Yss_b, 2), round(self.Yss_d[1]/self.Yss_b, 2), round(self.Yss_d[2]/self.Yss_b, 2), round(self.Yss_d[3]/self.Yss_b, 2)],\n ['relative TFPss', round(self.TFPss_d[0]/self.TFPss_b, 2), round(self.TFPss_d[1]/self.TFPss_b, 2), round(self.TFPss_d[2]/self.TFPss_b, 2), round(self.TFPss_d[3]/self.TFPss_b, 2)], \n ['relative entry mass', round(self.E_star_d[0]/self.E_star_b, 2), round(self.E_star_d[1]/self.E_star_b, 2), round(self.E_star_d[2]/self.E_star_b, 2), round(self.E_star_d[3]/self.E_star_b, 2)],\n ['share of subsidized output', round(self.Y_set_d[0,0], 2), round(self.Y_set_d[1,0], 2), round(self.Y_set_d[2,0], 2), round(self.Y_set_d[3,0], 2)],\n ['total subsidy paid of output', round(self.subsidy_size_d[0], 2), round(self.subsidy_size_d[1], 2), round(self.subsidy_size_d[2], 2), round(self.subsidy_size_d[3], 2)],\n ['subsidy rate (tau_s)', round(self.tau_s[0], 2), round(self.tau_s[1], 2), round(self.tau_s[2], 2), round(self.tau_s[3], 2)],\n [], \n ['relative Kss', round(self.Kss_d[0]/self.Kss_b, 2), round(self.Kss_d[1]/self.Kss_b, 2), round(self.Kss_d[2]/self.Kss_b, 2), round(self.Kss_d[3]/self.Kss_b, 2)], \n ['relative wss', round(self.w_ss_d[0]/self.w_ss_b, 2), round(self.w_ss_d[1]/self.w_ss_b, 2), round(self.w_ss_d[2]/self.w_ss_b, 2), round(self.w_ss_d[3]/self.w_ss_b, 2)], \n ['relative Nss', round(self.N_ss_d[0]/self.N_ss_b, 2), round(self.N_ss_d[1]/self.N_ss_b, 2), round(self.N_ss_d[2]/self.N_ss_b, 2), round(self.N_ss_d[3]/self.N_ss_b, 2)], \n ['relative avg. firm size', round(self.average_firm_size_d[0]/self.average_firm_size_b, 2), round(self.average_firm_size_d[1]/self.average_firm_size_b, 2), round(self.average_firm_size_d[2]/self.average_firm_size_b, 2), round(self.average_firm_size_d[3]/self.average_firm_size_b, 2)]],\n headers=['Variable', 'Tax = '+str(self.tau_vector[0]), \"Tax = \"+str(self.tau_vector[1]), 'Tax = '+str(self.tau_vector[2]), 'Tax = '+str(self.tau_vector[3])]))\n \n\n t1 = time.time()\n print(f'\\nTotal Run Time: {t1-t0:.2f} seconds')","def _RunCalibration(self, graph_key, gdef, input_data, config):\n return self._RunGraph(graph_key, gdef, input_data, config, 30)","def get_Objective(self):\r\n \r\n ans = 0\r\n for i in range(len(self.X.shape)):\r\n ans += self.parameter['phi'][i] * self.parameter['lambda1'] *norm(tl.unfold(self.Wlist[i], i), 'nuc') + (1 / self.parameter['m']) * norm(tl.unfold(self.X - self.Wlist[i] - self.V, i))\r\n\r\n # Augmented part is calculated seperately. \r\n augment_part1 = 0.5 * self.parameter['rho1'] * norm(self.V - self.T + self.F1)\r\n augment_part2 = 0.5 * self.parameter['rho2'] * norm(tl.fold(np.dot(self.Dmatrix, tl.unfold(self.T, 0)), 0, self.T.shape) - self.S + self.F2)\r\n\r\n # Combine the result for final objective function\r\n ans += self.parameter['beta1'] * norm(self.V.reshape(self.totaldim), 1) + self.parameter['beta2'] * norm(self.S.reshape(self.totaldim), 1) + augment_part1 + augment_part2 \r\n return ans","def IterateValues(self):\n agrid = self.agrid\n self.w = self.setwage(self.K, self.N)\n self.r = self.setrate(self.K, self.N)\n self.b = self.benefit(self.N)\n\n for l in range(self.Na): \n self.c[-1][l] = agrid[l]*(1+self.r) + self.b\n self.v[-1][l] = self.util(self.c[-1][l],0)\n self.vtilde[-1] = interp1d(agrid,self.v[-1], kind='cubic')\n\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\n m0 = 0 \n for l in range(self.Na):\n # Find a bracket within which optimal a' lies\n m = max(0, m0-1)\n m0, a, b, c = self.GetBracket(y, l, m, agrid)\n # Define objective function for optimal a'\n def objfn(a1):\n v = self.value(y, agrid[l], a1)\n return -v\n # Find optimal a' using Golden Section Search\n if a == b:\n self.a[y][l] = 0\n elif b == c:\n self.a[y][l] = agrid[-1]\n else:\n result = minimize_scalar(objfn, bracket=(a,b,c), method='Golden')\n #‘Brent’,‘Bounded’,‘Golden’\n self.a[y][l] = result.x\n # Computing consumption and labor\n if y >= -self.R:\n self.c[y][l], self.n[y][l] = (1+self.r)*agrid[l] + self.b - self.a[y][l], 0\n else:\n self.c[y][l], self.n[y][l] = self.solve(agrid[l], self.a[y][l])\n self.v[y][l] = self.util(self.c[y][l],self.n[y][l]) + self.beta*self.vtilde[y+1](self.a[y][l])\n self.vtilde[y] = interp1d(agrid, self.v[y], kind='cubic')","def determine_analytic_solution(self):\n\n solver = analytic_solution_homogeneous_sphere(S=self.S,\n chi=self.chi_base,\n R=self.xint)\n\n r = 0.5 * (self.xl + self.xr)\n\n Janalytic = []\n Hanalytic = []\n Kanalytic = []\n\n for ri in r:\n Janalytic.append(solver.J(ri))\n Hanalytic.append(solver.H(ri))\n Kanalytic.append(solver.K(ri))\n\n self._Janalytic = np.array(Janalytic)\n self._Hanalytic = np.array(Hanalytic)\n self._Kanalytic = np.array(Kanalytic)","def get_solution(self):\n return self._generate_solution()","def prob_calibration_function(truthvec, scorevec, reg_param_vec='default', knots='sample',\n method='logistic', force_prob=True, eps=1e-15, max_knots=200,\n transform_fn='none', random_state=942, verbose=False, cv_folds=5,\n unity_prior_weight=1, unity_prior_gridsize=20):\n from sklearn import linear_model\n from sklearn.metrics import log_loss, make_scorer\n\n if (unity_prior_weight>0):\n scorevec_coda, truthvec_coda = create_yeqx_bias_vectors(unity_prior_gridsize)\n coda_wt = unity_prior_weight/unity_prior_gridsize\n weightvec = np.concatenate((np.ones(len(scorevec)), coda_wt * np.ones(len(scorevec_coda))))\n scorevec = np.concatenate((scorevec, scorevec_coda))\n truthvec = np.concatenate((truthvec, truthvec_coda))\n\n if transform_fn != 'none':\n scorevec = transform_fn(scorevec)\n\n knot_vec = np.unique(scorevec)\n if (knots == 'sample'):\n num_unique = len(knot_vec)\n if (num_unique > max_knots):\n smallest_knot, biggest_knot = knot_vec[0], knot_vec[-1]\n inter_knot_vec = knot_vec[1:-1]\n random.seed(random_state)\n random.shuffle(inter_knot_vec)\n reduced_knot_vec = inter_knot_vec[:(max_knots-2)]\n reduced_knot_vec = np.concatenate((reduced_knot_vec, [smallest_knot, biggest_knot]))\n reduced_knot_vec = np.concatenate((reduced_knot_vec, np.linspace(0, 1, 21)))\n if (unity_prior_weight>0):\n reduced_knot_vec = np.concatenate((reduced_knot_vec, scorevec_coda))\n knot_vec = np.unique(reduced_knot_vec)\n if verbose:\n print(\"Originally there were {} knots. Reducing to {} while preserving first and last knot.\".format(num_unique, len(knot_vec)))\n X_mat = _natural_cubic_spline_basis_expansion(scorevec, knot_vec)\n\n if (method == 'logistic'):\n if ((type(reg_param_vec) == str) and (reg_param_vec == 'default')):\n reg_param_vec = 10**np.linspace(-7, 5, 61)\n if verbose:\n print(\"Trying {} values of C between {} and {}\".format(len(reg_param_vec), np.min(reg_param_vec), np.max(reg_param_vec)))\n reg = linear_model.LogisticRegressionCV(Cs=reg_param_vec, cv=StratifiedKFold(cv_folds, shuffle=True),\n scoring=make_scorer(log_loss, needs_proba=True, greater_is_better=False))\n if (unity_prior_weight>0):\n reg.fit(X_mat, truthvec, weightvec)\n else:\n reg.fit(X_mat, truthvec)\n if verbose:\n print(\"Best value found C = {}\".format(reg.C_))\n\n if (method == 'ridge'):\n if ((type(reg_param_vec) == str) and (reg_param_vec == 'default')):\n reg_param_vec = 10**np.linspace(-7, 7, 71)\n if verbose:\n print(\"Trying {} values of alpha between {} and {}\".format(len(reg_param_vec), np.min(reg_param_vec),np.max(reg_param_vec)))\n reg = linear_model.RidgeCV(alphas=reg_param_vec, cv=KFold(cv_folds, shuffle=True), scoring=make_scorer(mean_squared_error_trunc,needs_proba=False, greater_is_better=False))\n reg.fit(X_mat, truthvec)\n if verbose:\n print(\"Best value found alpha = {}\".format(reg.alpha_))\n\n def calibrate_scores(new_scores):\n new_scores = np.maximum(new_scores,knot_vec[0]*np.ones(len(new_scores)))\n new_scores = np.minimum(new_scores,knot_vec[-1]*np.ones(len(new_scores)))\n if transform_fn != 'none':\n new_scores = transform_fn(new_scores)\n basis_exp = _natural_cubic_spline_basis_expansion(new_scores,knot_vec)\n if (method == 'logistic'):\n outvec = reg.predict_proba(basis_exp)[:,1]\n if (method == 'ridge'):\n outvec = reg.predict(basis_exp)\n if force_prob:\n outvec = np.where(outvec < eps, eps, outvec)\n outvec = np.where(outvec > 1-eps, 1-eps, outvec)\n return outvec\n\n return calibrate_scores","def solve(self):\n ...","def reconstruct_solution(spikes,sol,uval,twin,ics,tau,variable,**kwargs):\n\n # Model parameters\n pars = {'dt' : 1e-3}\n pars = gu.varargin(pars,**kwargs)\n\n # Generate time vector\n time = np.arange(twin[0],twin[-1],pars['dt'])\n time = np.sort(np.r_[time,spikes])\n # Generate spike vector\n tspk = np.copy(time)\n for i in range(1,len(spikes)):\n tspk[np.where(np.logical_and(time>=spikes[i-1],time<spikes[i]))[0]] = spikes[i-1]\n tspk[np.where(time >= spikes[len(spikes)-1])[0]] = spikes[len(spikes)-1]\n tspk[np.where(time < spikes[0])[0]] = 0\n # Generate general solution vector\n vsol = np.ones(time.size)\n if (variable=='x') and isscalar(uval):\n uval = uval * np.ones(sol.size)\n if variable=='x':\n for i in range(1, len(spikes)):\n # x must be given at x(t_i^+) according to xsol\n vsol[np.where(np.logical_and(time >= spikes[i - 1], time < spikes[i]))[0]] = sol[i-1]*(1-uval[i-1])\n vsol[np.where(time >= spikes[len(spikes) - 1])[0]] = sol[len(spikes) - 1]*(1-uval[len(spikes)-1])\n else:\n for i in range(1, len(spikes)):\n vsol[np.where(np.logical_and(time >= spikes[i - 1], time < spikes[i]))[0]] = sol[i-1]\n vsol[np.where(time >= spikes[len(spikes) - 1])[0]] = sol[len(spikes) - 1]\n vsol[np.where(time < spikes[0])[0]] = ics\n # Compute effective solution\n solution = np.zeros((2, time.size))\n solution[0] = time\n\n if variable=='x':\n # Assumes that the first ICs is x(0)\n solution[1] = xsol(vsol,time-tspk,tau)\n else:\n solution[1] = usol(vsol,time-tspk,tau)\n\n return solution","def step_autocorrelation(self):\n\n max_hops = max([len(x) for x in self.steps])\n\n self.acf = np.zeros([len(self.steps), max_hops])\n\n keep = [] # list to hold indices of trajectories with a non-zero amount of hops\n for i in range(len(self.steps)):\n hops = self.steps[i]\n if len(hops) > 1:\n self.acf[i, :len(self.steps[i])] = timeseries.acf(self.steps[i])\n keep.append(i)\n\n self.acf = self.acf[keep, :]\n\n self.acf = np.array([self.acf[np.nonzero(self.acf[:, i]), i].mean() for i in range(max_hops)])\n\n #self.acf = timeseries.step_autocorrelation(self.z_interpolated.T[..., np.newaxis])","def run(self):\n self.errList = []\n self.initialize()\n\n for i in range(self.maxiter):\n # update U\n for k in range(self.K):\n [p, sigma, q] = np.linalg.svd(self.H.dot(self.S[:, :, k]).dot(self.V.T).dot(self.X[k].T),\n full_matrices=False)\n self.U[k] = q.T.dot(p.T)\n self.U[k] = self.U[k].real\n\n # calculate temporal variable y\n y = np.zeros([self.rank, self.L, self.K])\n for k in range(self.K):\n y[:, :, k] = self.U[k].T.dot(self.X[k])\n\n # get H, V, and temps by running a single iteration of CP_ALS\n if i == 0:\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\n self.rank, tol=self.tol, maxiter=1, printitn=0)\n else:\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\n self.rank, tol=self.tol, maxiter=1,\n init=[self.H, self.V, temps], printitn=0)\n self.H = cp.Us[0]\n self.V = cp.Us[1]\n temps = cp.Us[2].dot(np.diag(cp.lmbda))\n\n # update S\n for k in range(self.K):\n self.S[:, :, k] = np.diag(temps[k, :])\n\n # checking the stop criteria\n # error = 0\n for k in range(self.K):\n temp = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)\n self.sigma_new += np.linalg.norm(temp - self.X[k]) ** 2\n\n error = abs(self.sigma_new - self.sigma_old) #/ self.sigma_old\n self.errList.append(error)\n if (i + 1) % self.printitn == 0:\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\n self.sigma_new)\n elif error < self.tol:\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\n self.sigma_new)\n\n if error < self.tol:\n break\n else:\n self.sigma_old = self.sigma_new\n self.sigma_new = 0\n\n for k in range(self.K):\n self.fit[k] = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)","def empirical_cor(l):\n\n global fig_dphi\n\n # first clean los\n maps_temp = np.matrix.copy(maps[:,:,l]) - np.matrix.copy(models[:,:,l])\n\n # no estimation on the ref image set to zero \n if np.nansum(maps[:,:,l]) != 0:\n\n maxlos,minlos=np.nanpercentile(maps_temp[ibeg_emp:iend_emp,jbeg_emp:jend_emp],float(arguments[\"--perc_los\"])),np.nanpercentile(maps_temp[ibeg_emp:iend_emp,jbeg_emp:jend_emp],100-float(arguments[\"--perc_los\"]))\n logger.debug('Set Max-Min LOS for empirical estimation: {0}-{1}'.format(maxlos,minlos))\n kk = np.nonzero(np.logical_or(maps_temp==0.,np.logical_or((maps_temp>maxlos),(maps_temp<minlos))))\n maps_temp[kk] = float('NaN')\n\n itemp = ibeg_emp\n for lign in range(ibeg_emp,iend_emp,10):\n if np.isnan(np.nanmean(maps[lign:lign+10,:,l])):\n itemp = lign\n else:\n break\n logger.debug('Begining of the image: {}'.format(itemp))\n\n if arguments[\"--topofile\"] is not None:\n ax_dphi = fig_dphi.add_subplot(4,int(N/4)+1,l+1)\n else:\n ax_dphi = None\n\n logger.debug('Threshold RMS: {}'.format(float(arguments[\"--threshold_rms\"])))\n\n # selection pixels\n index = np.nonzero(np.logical_and(elev<maxtopo,\n np.logical_and(elev>mintopo,\n np.logical_and(mask_flat>float(arguments[\"--threshold_mask\"]),\n np.logical_and(~np.isnan(maps_temp),\n np.logical_and(~np.isnan(rmsmap),\n np.logical_and(~np.isnan(elev),\n np.logical_and(rmsmap<float(arguments[\"--threshold_rms\"]),\n np.logical_and(rmsmap>1.e-6,\n np.logical_and(~np.isnan(maps_temp),\n np.logical_and(pix_az>ibeg_emp,\n np.logical_and(pix_az<iend_emp,\n np.logical_and(pix_rg>jbeg_emp,\n np.logical_and(pix_rg<jend_emp, \n slope>0.,\n ))))))))\n ))))))\n\n # extract coordinates for estimation\n temp = np.array(index).T\n x = temp[:,0]; y = temp[:,1]\n # clean maps\n los_clean = maps_temp[index].flatten()\n topo_clean = elev[index].flatten()\n rms_clean = rmsmap[index].flatten()\n \n logger.debug('Number of points for empirical estimation: {}'.format(len(los_clean)))\n if len(los_clean) < 1:\n logger.critical('No points left for empirical estimation. Exit!')\n logger.critical('threshold RMS: {0}, threshold Mask: {1}, Min-Max LOS: {2}-{3}, Min-Max topo: {4}-{5}, lines: {6}-{7}, \\\n cols: {8}- {9}'.format(float(arguments[\"--threshold_rms\"]),float(arguments[\"--threshold_mask\"]),minlos,maxlos,mintopo,maxtopo,ibeg_emp,iend_emp,jbeg_emp,jend_emp))\n sys.exit()\n\n # print itemp, iend_emp\n if flat>5 and iend_emp-itemp < .6*(iend_emp-ibeg_emp):\n logger.warning('Image too short in comparison to master, set flat to 5')\n temp_flat=5\n else:\n temp_flat=flat\n\n if ivar>0 and iend_emp-itemp < .6*(iend_emp-ibeg_emp):\n logger.warning('Image too short in comparison to master, set ivar to 0')\n ivar_temp=0\n nfit_temp=0\n else:\n ivar_temp=ivar\n nfit_temp=nfit\n\n # call ramp estim\n los = as_strided(maps[:,:,l]).flatten()\n samp = int(arguments[\"--emp_sampling\"])\n\n map_ramp, map_flata, map_topo, rmsi = estim_ramp(los,los_clean[::samp],topo_clean[::samp],x[::samp],\\\n y[::samp],temp_flat,rms_clean[::samp],nfit_temp, ivar_temp, l, ax_dphi)\n\n if (lin_start is not None) and (lin_end is not None):\n # try:\n indexref = np.nonzero(np.logical_and(elev<maxtopo,\n np.logical_and(elev>mintopo,\n np.logical_and(mask_flat>float(arguments[\"--threshold_mask\"]),\n np.logical_and(~np.isnan(maps_temp),\n np.logical_and(~np.isnan(rmsmap),\n np.logical_and(~np.isnan(elev),\n np.logical_and(rmsmap<float(arguments[\"--threshold_rms\"]),\n np.logical_and(rmsmap>1.e-6,\n np.logical_and(~np.isnan(maps_temp),\n np.logical_and(pix_az>lin_start,\n np.logical_and(pix_az<lin_end,\n np.logical_and(pix_rg>col_start,\n np.logical_and(pix_rg<col_end, \n slope>0.,\n ))))))))))))\n ))\n \n if len(indexref[0]) == 0:\n logger.warning('Ref zone is empty! Re-define --ref_zone argument. Exit!')\n sys.exit()\n\n ## Set data minus temporal model to zero in the ref area\n zone = as_strided(map_flata[:,:] - models[:,:,l])\n los_ref2 = zone[indexref].flatten()\n rms_ref = rmsmap[indexref].flatten()\n amp_ref = 1./rms_ref\n amp_ref = amp_ref/np.nanmax(amp_ref)\n # weigth avera of the phase\n cst = np.nansum(los_ref2*amp_ref) / np.nansum(amp_ref)\n logger.info('Re-estimation of a constant within lines {0}-{1} and cols {2}-{3}'.format(lin_start,lin_end,col_start,col_end))\n logger.info('Average phase within ref area: {0}:'.format(cst))\n if np.isnan(cst):\n cst = 0.\n map_ramp, map_flata = map_ramp + cst, map_flata - cst\n del zone\n \n else:\n map_flata = np.copy(maps[:,:,l])\n map_ramp, map_topo = np.zeros(np.shape(map_flata)), np.zeros(np.shape(map_flata))\n rmsi = 1\n\n # set ramp to NaN to have ramp of the size of the images\n kk = np.nonzero(np.isnan(map_flata))\n ramp = as_strided(map_ramp)\n ramp[kk] = float('NaN')\n topo = as_strided(map_topo)\n topo[kk] = float('NaN')\n del ramp, topo\n \n return map_ramp, map_flata, map_topo, rmsi","def _solver_dirty(X, R, coef_shared_, coef_specific_, Ls, alpha, beta,\n max_iter, tol, positive):\n n_tasks = len(X)\n n_samples, n_features = X[0].shape\n theta = coef_shared_ + coef_specific_\n alpha *= n_samples\n beta *= n_samples\n\n # dg = 1.\n for i in range(max_iter):\n w_max = 0.0\n d_w_max = 0.0\n for j in range(n_features):\n if Ls[j] == 0.:\n continue\n # compute residual\n grad = np.zeros(n_tasks)\n tmp1 = np.zeros(n_tasks)\n tmp2 = np.zeros(n_tasks)\n\n normtmp = 0.\n for t in range(n_tasks):\n for n in range(n_samples):\n grad[t] += X[t, n, j] * R[t, n]\n grad[t] /= Ls[j]\n tmp1[t] = grad[t] + coef_shared_[j, t]\n tmp2[t] = grad[t] + coef_specific_[j, t]\n\n normtmp += tmp1[t] ** 2\n\n normtmp = np.sqrt(normtmp)\n\n # l2 thresholding\n\n thresholdl2 = 0.\n if normtmp:\n thresholdl2 = max(1. - alpha / (Ls[j] * normtmp), 0.)\n tmp1 *= thresholdl2\n thresholdl1 = beta / Ls[j]\n tmp2 = np.sign(tmp2) * np.maximum(np.abs(tmp2) - thresholdl1, 0.)\n if positive:\n tmp2 = np.maximum(tmp2, 0.)\n tmp1 = np.maximum(tmp1, 0.)\n new_theta = tmp1 + tmp2\n if theta[j].any():\n for t in range(n_tasks):\n R[t] += X[t, :, j] * theta[j, t]\n\n d_w_j = np.abs(theta[j] - new_theta).max()\n d_w_max = max(d_w_max, d_w_j)\n w_max = max(w_max, np.abs(tmp1 + tmp2).max())\n coef_shared_[j] = tmp1\n coef_specific_[j] = tmp2\n theta[j] = new_theta\n\n if theta[j].any():\n for t in range(n_tasks):\n R[t] -= X[t, :, j] * theta[j, t]\n\n if (w_max == 0.0 or d_w_max / w_max < tol):\n break\n\n return coef_shared_, coef_specific_, R, i","def _fit(self, init_step_size, y):\n step_size = np.zeros(self.max_iter + 1)\n beta = np.zeros((self.max_iter + 1, self.d))\n theta = np.zeros((self.max_iter + 1, self.d))\n beta_mask = np.zeros((self.max_iter + 1, self.n))\n theta_mask = np.zeros((self.max_iter + 1, self.n))\n grad_beta = np.zeros((self.max_iter + 1, self.d))\n grad_theta = np.zeros((self.max_iter + 1, self.d))\n norm_grad_beta = np.zeros(self.max_iter + 1)\n norm_grad_theta = np.zeros(self.max_iter + 1)\n\n step_size[0] = init_step_size\n grad_beta[0, :], beta_mask[0, :] = self._gradient(beta[0, :], y)\n grad_theta[0, :], theta_mask[0, :] = self._gradient(theta[0, :], y)\n norm_grad_beta[0] = np.linalg.norm(grad_beta[0, :])\n norm_grad_theta[0] = np.linalg.norm(grad_theta[0, :])\n for t in range(self.max_iter):\n if self.verbose:\n print(\"ITERATION {}\".format(t))\n\n step_size[t + 1], beta_mask[t + 1, :] = self._backtracking(step_size[t], theta[t], theta_mask[t, :], grad_theta[t, :], norm_grad_theta[t], y)\n beta[t + 1, :] = theta[t, :] - step_size[t + 1]*grad_theta[t, :]\n theta[t + 1, :] = beta[t + 1, :] + t/(t + 3)*(beta[t + 1, :] - beta[t, :])\n\n grad_beta[t + 1, :], _ = self._gradient(beta[t + 1, :], y, mask=beta_mask[t + 1, :])\n grad_theta[t + 1, :], theta_mask[t + 1, :] = self._gradient(theta[t + 1, :], y)\n norm_grad_beta[t + 1] = np.linalg.norm(grad_beta[t + 1, :])\n norm_grad_theta[t + 1] = np.linalg.norm(grad_theta[t + 1, :])\n\n if norm_grad_beta[t + 1] <= self.epsilon:\n break\n\n if self.verbose and t + 1 == self.max_iter:\n print(\"Maximum iterations reached\")\n\n return beta[t + 1, :]","def _solve(self) -> CasADiArrayType:\n\n # Setup solver\n self.m = osqp.OSQP()\n self.m.setup(**self._setup_input)\n\n # Warm start optimization\n if self.use_warm_start:\n self.m.warm_start(x=self.x0.toarray().flatten())\n\n # Solve problem\n self._solution = self.m.solve()\n\n return self._solution.x","def run(self):\n\n # Initializing required variables for the algorithm\n start = time.time()\n i = 0\n w = self.w\n k = 99.99\n\n #Running the algorithm till tolerance is reached\n while k > self.tolerance: \n\n i = i + 1\n\n if self.verbose:\n print(\"Iteration \" + str(i),end=\"\\r\")\n\n # Following is a gradient descent algorithm\n # You can find the update step at the following\n # link, https://raw.githubusercontent.com/mnk400/linearRegression/master/img/EUC.png\n t_0 = w.T.dot(w)\n t_1 = self.x.T.dot(self.x).dot(w)\n gradient = (2/t_0) * (t_1) - (2/t_0**2) * np.transpose(w).dot(t_1) * (w)\n w_new = w - (1/self.DATAPOINTS) * 0.3 * gradient\n w_new[-1] = -1\n l = len(self.x[0]) - 1 \n y_plt = np.dot(self.x[:,0:l],w_new[:-1]) \n\n #tolerance is checked against the root mean square of change in weights\n k = np.dot(np.transpose(w - w_new),(w - w_new))\n\n #Updating the weights \n w = w_new\n\n if self.verbose:\n print(\"Tolerance Reached\")\n timetaken = round(time.time() - start, 3)\n print(\"Ran for \" + str(timetaken) + \" seconds\" + \" in \" + str(i) + \" iterations.\")\n\n return w_new, y_plt","def solve(self) -> jnp.ndarray:\n pass","def fit(self, f: callable, a: float, b: float, d: int, maxtime: float) -> callable:\r\n\r\n # replace these lines with your solution\r\n initial_T = time.time()\r\n\r\n def get_points(f, a, b, n):\r\n x = np.linspace(a, b, n)\r\n y_lst = f(x)\r\n y = np.array(y_lst)\r\n\r\n return x, y\r\n\r\n def build_vector(x, y, size, deg):\r\n if deg == size:\r\n y_n = y.sum()\r\n else:\r\n y_n = np.dot(y, (x ** (size - deg)))\r\n pol1 = np.zeros(size + 1)\r\n for i in range(size + 1):\r\n pol1[i] = (x ** (2 * size - deg - i)).sum()\r\n return pol1, y_n\r\n\r\n def build_coeff_matrix(f, a, b, n, d):\r\n x, y = get_points(f, a, b, n)\r\n deg = d\r\n b = np.array([])\r\n coeff_matrix = np.array([])\r\n for i in range(d + 1):\r\n x_n, y_n = build_vector(x, y, d, i)\r\n deg -= 1\r\n coeff_matrix = np.append(coeff_matrix, x_n)\r\n b = np.append(b, y_n)\r\n coeff_matrix = np.reshape(coeff_matrix, (d + 1, d + 1))\r\n return coeff_matrix, b\r\n\r\n def solve_coeff_matrix(coeff_matrix, b):\r\n A_inverse = np.linalg.inv(coeff_matrix)\r\n coeffs = A_inverse.dot(b)\r\n return coeffs\r\n\r\n def build_function_from_coeffs(coeffs):\r\n f = np.poly1d(coeffs)\r\n return f\r\n\r\n n = 100 # fisrt sample size\r\n while (time.time() - initial_T) + 0.2 < maxtime: # while i still have time loop again\r\n Ax, B = build_coeff_matrix(f, a, b, n, d=d)\r\n if time.time() - initial_T + 0.2 >= maxtime: # first break point\r\n break\r\n coeffs = solve_coeff_matrix(coeff_matrix=Ax, b=B)\r\n if time.time() - initial_T + 0.2 >= maxtime: # second break point\r\n break\r\n result = build_function_from_coeffs(coeffs)\r\n if time.time() - initial_T + 0.2 >= maxtime: # third break point\r\n break\r\n n += 200 # increasing sample size\r\n\r\n return result","def run():\n return estimate(0,1,0)","def get_s0_xy_mc(N, delta, beta,starting_counter, n_evals):\n tolerance = 0.1 #energy tolerance\n energy_per_bond = -1 + delta * 0.001 # delta in miliergs\n\n S0_TEMPLATE = 's0_{}'# format is S0_N_energy_per_bond_i\n if delta < 50:# was 50\n angle = np.degrees(acos(0.99-delta*0.001))\n s0 = get_s0_xy_equipartition(N,angle)\n else:\n s0 = get_s0_random_xy(N)\n solver = spin_solver.SpinSolver(1, N, t_ode = 1,s0 = s0, beta = beta)\n\n #initial converging towards right energy using xy updates\n while abs(solver.hamilt - energy_per_bond * N) > tolerance:\n solver.mc_update_xy()\n\n #initial shuffling around, not generating any states yet\n iters = 0\n while iters < 500:\n iters +=1\n solver.mc_micro_sweep()\n for m in range(N):\n solver.mc_update_xy()\n if iters%50==0:\n solver.mc_twist()\n f = h5py.File('s0_{}_{}.hdf5'.format(starting_counter,n_evals), 'w')\n\n #generating initial states\n for i in range(n_evals):\n iters = 0\n while iters < 100:\n iters +=1\n if iters%10==0:\n solver.mc_twist()\n solver.mc_micro_sweep()\n for m in range(N):\n solver.mc_update_xy()\n # reaching desired energy\n while abs(solver.hamilt - energy_per_bond * N) > tolerance:\n solver.mc_update_xy()\n dset = f.create_dataset(S0_TEMPLATE.format(starting_counter+i), data = solver.s0)\n f.attrs['N'] = N\n f.attrs['delta'] = delta\n f.attrs['beta'] = beta\n f.attrs['starting_counter'] = starting_counter\n f.attrs['n_evals'] = n_evals\n f.attrs['timestamp'] = time.strftime(\"%Y-%m-%d %H:%M:%S\", time.gmtime())\n f.attrs['monte_carlo_method'] = \"500 iters (every50th twist), then 100 iters(every10th twist) between samples, for delta<50 start with gaussian equipartition\"\n f.close()","def fit(self, ymeas, mmeas=None, alg='optls'): # alg: {'optls','mine'}\n\n # [ X ]*dm = [ dy ]\n # [ a ] [ 0 ] <-- using built-in Ridge model does this\n #\n # [ X ]*dm = [ dy ]\n # [-a ] [ a*m ] <-- but I want this for iterated nonlin problem\n #\n # [ X ]*dm = [ dy ]\n # [-aL ] [ a*L*m ] <-- and more generally I want this (higher-order Tihk)\n #\n # which can be rewritten:\n # G * dm = D (and then loop that from m0 with m=m+dm...)\n\n # X is the Jacobian matrix of derivs of predicted data points wrt model\n # params m, as given by ypred,X=self.fwd_deriv_code(m)...\n\n\n if alg=='optls':\n # https://docs.scipy.org/doc/scipy/reference/optimize.html\n # https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.least_squares.html\n def fun(m):\n mlen = m.size\n L = create_findiff_mtx(mlen,self.beta)\n ypred,J = self.fwd_deriv_code(m) # m: model params vector, J: derivs matrix\n resids = ymeas-ypred\n modelfunc = self.alpha * np.dot(L,m)\n modelfunc = modelfunc.reshape(len(modelfunc),1)\n f = np.squeeze(np.concatenate((resids,modelfunc),axis=0))\n return f\n\n def jac(m):\n mlen = m.size\n L = create_findiff_mtx(mlen,self.beta)\n ypred,J = self.fwd_deriv_code(m) # m: model params vector, J: derivs matrix\n Jreg = self.alpha * L\n Jout = np.concatenate((J,Jreg))\n return Jout\n\n if self.usefindiff:\n jacfn='2-point'\n else:\n jacfn=jac\n if self.verbose:\n verblevel=2\n else:\n verblevel=0\n res = least_squares(fun, np.squeeze(self.minit), jac=jacfn,\n bounds=(0., 3.5), diff_step=None, verbose=verblevel, max_nfev=self.max_nfev,\n method='trf', ftol=1e-08, xtol=1e-08, gtol=1e-08, x_scale=1.0)\n #ftol=1e-4, xtol=1e-1, gtol=1e-8, x_scale=1.0)\n #ftol=1e0, xtol=1e-01, gtol=1e-01, x_scale=1.0)\n #ftol=1e-08, xtol=1e-08, gtol=1e-08, x_scale=1.0)\n\n if mmeas is not None:\n testMSE = cplxMSE(res.x.reshape(len(res.x),1),mmeas)\n else:\n testMSE = npl.nan\n ypred,J = self.fwd_deriv_code(res.x.reshape(len(res.x),1))\n ypred=np.log10(ypred)\n residnorm = norm(ypred-ymeas)\n print('resid norm',residnorm)\n L = create_findiff_mtx(len(self.minit),self.beta)\n print('maxeig JJ',np.real(np.amax(np.linalg.eigvals(np.dot(J.T,J))))) # J'J has real eigvals but kept cplx type\n print('maxeig LL',np.amax(np.linalg.eigvals(np.dot(L.T,L))))\n if self.showplot:\n f, ax = plt.subplots(1, 2, figsize=(11,4))\n # plot the meas and pred data:\n # print('ypred',ypred)\n # print('ymeas',ymeas)\n ax[0].plot(ypred,'r.-')\n ax[0].plot(ymeas,'k.-')\n ax[0].grid()\n #ax[0].set_ylabel('cost')\n #ax[0].set_xlabel('iterations')\n ax[0].set_title('Measured (blk) and predicted (blu) data')\n # plot the init, true, and final model param vectors:\n ax[1].plot(self.minit,'g.-')\n ax[1].plot(res.x,'r.--')\n ax[1].plot(mmeas,'k.--')\n ax[1].grid()\n #ax[1].set_ylabel('model value')\n #ax[1].set_xlabel('indep var')\n ax[1].set_title('Model vectors (true=blk, init=grn, soln=red)')\n\n # return m,cost,misfit,modelnorm,norm(dm),testMSE\n return res.x,res.cost,np.nan,np.nan,np.nan,testMSE\n\n elif alg=='mine':\n cost = []\n m = self.minit\n mlen = len(m)\n if self.verbose:\n print('iter alpha cost norm(dd) norm(dm) dmtol')\n for i in range(self.max_nfev):\n ypred,X = self.fwd_deriv_code(m) # m: model params vector, X: derivs matrix\n if self.usefindiff:\n def tmpfwdcode(m):\n return np.squeeze(self.fwd_deriv_code(m)[0])\n X = jacfindiff(tmpfwdcode,m,dx=1.0e-6) # dx=1.0e-6 is problem dependent!\n L = create_findiff_mtx(mlen,self.beta)\n G = np.concatenate((X, -self.alpha*L),axis=0)\n D = np.concatenate((ymeas-ypred, self.alpha*np.dot(L,m)),axis=0)\n misfit = cplxMSE(ymeas, ypred)\n modelnorm = norm(np.dot(L,m))**2\n current_cost = misfit + pow(self.alpha,2)*modelnorm\n dm,res,rnk,sv = lstsq(G,D)\n m = m + dm\n cost.append(current_cost)\n if self.verbose:\n print('%3d %6.1g %10.3f %10.3f %10.2g %6.3g' %\n (i, self.alpha, current_cost, norm(ymeas-ypred), norm(dm), self.dmtol))\n if norm(dm) < self.dmtol:\n break\n self.G = G\n self.ypred = ypred\n if mmeas is not None:\n testMSE = cplxMSE(m,mmeas)\n else:\n testMSE = npl.nan\n print('maxeig JJ',np.real(np.amax(np.linalg.eigvals(np.dot(X.T,X))))) # X'X has real eigvals but kept cplx type\n print('maxeig LL',np.amax(np.linalg.eigvals(np.dot(L.T,L))))\n if self.showplot:\n f, ax = plt.subplots(1, 2, figsize=(11,4))\n # plot the cost (ie loss) per iterations:\n ax[0].semilogy(cost,'.-') # (last element of cost)\n ax[0].grid()\n ax[0].set_ylabel('cost')\n ax[0].set_xlabel('iterations')\n ax[0].set_title('Cost history (misfit^2 + alpha^2*modelnorm^2)')\n # plot the init, true, final, and evolution of model params:\n #print('m',np.squeeze(m.T))\n ax[1].plot(mmeas,'k')\n ax[1].plot(self.minit,'g')\n ax[1].plot(m,'r')\n ax[1].grid()\n #ax[1].set_ylabel('model value')\n ax[1].set_xlabel('indep var')\n ax[1].set_title('Model vectors')\n\n return m,cost[-1],misfit,modelnorm,norm(dm),testMSE","def run_solution1_simple(self):\n fuel_sum = 0\n for n in self.data:\n fuel_sum += self.calculate_fuel(n)\n return fuel_sum","def init_solver(self, cost_func=None, opt_x0=False, init_uncertainty=False):\n self.cost_func = cost_func\n self.opt_x0 = opt_x0\n self.init_uncertainty = init_uncertainty\n\n u_0 = MX.sym(\"init_control\", (self.n_u, 1))\n k_ff_all = MX.sym(\"feed-forward control\", (self.n_safe - 1, self.n_u))\n g = []\n lbg = []\n ubg = []\n g_name = []\n\n p_0 = MX.sym(\"initial state\", (self.n_s, 1))\n q_0 = None\n k_fb_0 = None\n if init_uncertainty:\n q_0 = MX.sym(\"init uncertainty\", (self.n_s, self.n_s))\n k_fb_0 = MX.sym(\"init feddback control matrix\", (self.n_u, self.n_s))\n\n k_fb_safe = MX.sym(\"feedback matrices\",\n (self.n_safe - 1, self.n_s * self.n_u))\n\n p_all, q_all, gp_sigma_pred_safe_all = cas_multistep(p_0, u_0, k_fb_safe, k_ff_all,\n self.ssm_forward, self.l_mu,\n self.l_sigma,\n self.beta_safety, self.a,\n self.b,\n self.lin_trafo_gp_input, q_0, k_fb_0)\n\n # generate open_loop trajectory function [vertcat(x_0,u_0)],[f_x])\n\n if init_uncertainty:\n self._f_multistep_eval = cas.Function(\"safe_multistep\",\n [p_0, u_0, k_fb_safe, k_ff_all, q_0, k_fb_0],\n [p_all, q_all, gp_sigma_pred_safe_all])\n else:\n self._f_multistep_eval = cas.Function(\"safe_multistep\",\n [p_0, u_0, k_fb_safe, k_ff_all],\n [p_all, q_all, gp_sigma_pred_safe_all])\n\n g_safe, lbg_safe, ubg_safe, g_names_safe = self.generate_safety_constraints(\n p_all, q_all, u_0, k_fb_safe, k_ff_all, q_0, k_fb_0)\n g = vertcat(g, g_safe)\n lbg += lbg_safe\n ubg += ubg_safe\n g_name += g_names_safe\n\n # Generate performance trajectory\n if self.n_perf > 1:\n k_ff_perf, k_fb_perf, k_ff_perf_traj, k_fb_perf_traj, mu_perf, sigma_perf, gp_sigma_pred_perf_all, g_perf, lbg_perf, ubg_perf, g_names_perf = self._generate_perf_trajectory_casadi(\n p_0, u_0, k_ff_all, k_fb_safe, self.a, self.b, self.lin_trafo_gp_input)\n g = vertcat(g, g_perf)\n lbg += lbg_perf\n ubg += ubg_perf\n g_name += g_names_perf\n else:\n k_ff_perf = np.array([])\n k_fb_perf = np.array([])\n k_fb_perf_traj = np.array([])\n k_ff_perf_traj = np.array([])\n mu_perf = np.array([])\n sigma_perf = np.array([])\n gp_sigma_pred_perf_all = None\n\n cost = self.generate_cost_function(p_0, u_0, p_all, q_all, mu_perf, sigma_perf,\n k_ff_all, k_fb_safe, gp_sigma_pred_safe_all,\n k_fb_perf=k_fb_perf_traj,\n k_ff_perf=k_ff_perf_traj,\n gp_pred_sigma_perf=gp_sigma_pred_perf_all,\n custom_cost_func=cost_func)\n\n if self.opt_x0:\n opt_vars = vertcat(p_0, u_0, k_ff_perf, k_ff_all.reshape((-1, 1)))\n opt_params = vertcat(k_fb_safe.reshape((-1, 1)), k_fb_perf.reshape((-1, 1)))\n else:\n opt_vars = vertcat(u_0, k_ff_perf, k_ff_all.reshape((-1, 1)))\n opt_params = vertcat(p_0, k_fb_safe.reshape((-1, 1)), k_fb_perf.reshape((-1, 1)))\n\n if self.init_uncertainty:\n opt_params = vertcat(opt_params, q_0.reshape((-1, 1)), k_fb_0.reshape((-1, 1)))\n\n prob = {'f': cost, 'x': opt_vars, 'p': opt_params, 'g': g}\n\n opt = self.opts_solver\n if opt is None:\n opt = {'error_on_fail': False,\n 'ipopt': {'hessian_approximation': 'limited-memory', \"max_iter\": 100,\n \"expect_infeasible_problem\": \"no\", \\\n 'acceptable_tol': 1e-4, \"acceptable_constr_viol_tol\": 1e-5,\n \"bound_frac\": 0.5, \"start_with_resto\": \"no\",\n \"required_infeasibility_reduction\": 0.85,\n \"acceptable_iter\": 8}} # ipopt\n\n # opt = {'max_iter':120,'hessian_approximation':'limited-memory'}#,\"c1\":5e-4} #sqpmethod #,\n # opt = {'max_iter':120,'qpsol':'qpoases'}\n\n solver = cas.nlpsol('solver', 'ipopt', prob, opt)\n # solver = cas.nlpsol('solver','sqpmethod',prob,opt)\n # solver = cas.nlpsol('solver','blocksqp',prob,opt)\n\n self.solver = solver\n self.lbg = lbg\n self.ubg = ubg\n self.solver_initialized = True\n self.g = g\n self.g_name = g_name","def solve(self):\n for step in self.run.values():\n step.solve()","def solve(self):\n initial_fes = eades(self.graph, self.force_forward_edges)\n initial_fes_vec = self.edge_vector(initial_fes)\n\n # bounds for the objective\n lower_bound = 0\n upper_bound = np.sum(initial_fes_vec @ self.weights)\n\n self.logger.info('Calculating FES for graph with %d edges, max %d feedback edges', self.m, len(initial_fes))\n\n simple_cycles = set(induced_cycles(self.graph, initial_fes))\n\n for iteration in itertools.count(1):\n self.logger.info('Baharev iteration %d, %g <= objective <= %g, %d simple cycles', iteration, lower_bound,\n upper_bound, len(simple_cycles))\n\n # Formulate and solve the problem for this iteration:\n y = cp.Variable(self.m, boolean=True, name=\"y\")\n objective = cp.Minimize(cp.sum(y @ self.weights))\n\n cycle_vectors = [self.edge_vector(nx.utils.pairwise(cycle)) for cycle in simple_cycles]\n constraints = [cp.sum(a @ y) >= 1 for a in cycle_vectors]\n constraints.append(cp.sum(y @ self.force_forward_vec) == 0) # no force forward vec may be in the result set\n problem = cp.Problem(objective, constraints)\n resolution = problem.solve(**self.solver_args)\n if problem.status != 'optimal':\n self.logger.warning('Optimization solution is %s. Try solver != %s?', problem.status,\n problem.solver_stats.solver_name)\n self.logger.debug(\n \"Solved optimization problem with %d constraints: %s -> %s (%g + %g seconds, %d iterations, solver %s)\",\n len(constraints), resolution, problem.solution.status,\n problem.solver_stats.solve_time or 0, problem.solver_stats.setup_time or 0,\n problem.solver_stats.num_iters or 0, problem.solver_stats.solver_name)\n current_solution = np.abs(y.value) >= 0.5 # y.value = vector of floats each ≈ 0 or 1\n current_fes = self.edges_for_vector(current_solution)\n self.logger.debug('Iteration %d, resolution: %s, %d feedback edges', iteration, resolution,\n len(current_fes))\n # S, the feedback edge set calculated using the constraint subset, can be an incomplete solution\n # (i.e. cycles remain after removing S from the graph). So lets compare this with the upper bound\n # from the heuristic\n lower_bound = max(lower_bound, objective.value)\n if lower_bound == upper_bound:\n self.logger.info('upper == lower bound == %g, optimal solution found', lower_bound)\n break # y.value is the optimal solution\n\n if resolution > upper_bound:\n self.logger.error('Solution %g > upper bound %g!', resolution, upper_bound)\n break\n\n Gi = self.graph.copy()\n Gi.remove_edges_from(current_fes)\n if nx.is_directed_acyclic_graph(Gi):\n self.logger.info('Graph is acyclic, optimal solution found')\n break # y.value is the optimal solution\n\n # The solution is not yet ideal. So we take G^(i), the graph still containing some feedback edges,\n # calculate a heuristic on it and use the heuristic (= over-estimation) to adjust upper bound and\n # determine additional simple cycles (= constraints)\n Fi = eades(Gi, self.force_forward_edges)\n yi = self.edge_vector(Fi) | current_solution\n zi = np.sum(yi @ self.weights)\n if zi < upper_bound:\n upper_bound = zi\n current_solution = yi\n simple_cycles |= set(induced_cycles(Gi, Fi))\n\n self.solution_vector = current_solution\n self.solution = self.edges_for_vector(current_solution)\n self.objective = objective.value\n self.iterations = iteration\n self.simple_cycles = simple_cycles\n return self.solution","def solve(self):\n\n # sanity check\n if self.G is None or self.curve is None or self.Q is None:\n print(\"Can't solve not all parameters are set\")\n return False # unsuccessful\n\n self.count = 1 # initial count\n self.start = time.time()\n\n order = self.curve.order(self.G) # get order of generator\n\n ############ POLLARD'S RHO + FLOYD'S EXTENSION ############\n found = False\n\n # will probably find a factor, so need to loop with random numbers until we find it\n while not found:\n\n ############ GENERATE RANDOM FUNCTION POINTS ############\n points = [] # list of points to inform our random function\n\n for _ in range(17):\n a = secrets.randbelow(order)\n b = secrets.randbelow(order)\n P = (self.G * a) + (self.Q * b) # linear combination\n points.append([P, a, b]) # add to list\n\n ############ RANDOM START POINTS ############\n Y, aY, bY = X, aX, bX = points.pop() # random starting points\n\n ############ FLOYD'S CYCLE DETECTION ############\n while not found:\n X, aX, bX = g((X, aX, bX), order, points) # first runner\n Y, aY, bY = g(g((Y,aY,bY),order,points),order,points) # second runner\n\n found = X == Y # detect match\n self.count += 1 # increment count\n\n if bX == bY and aX == aY: # if we arrive at identical combinations\n found = False # reset and try again\n else:\n inv = modInverse((bX - bY) % order, order) # get mod inverse\n\n if inv == 0: # if no mod inverse exists\n found = False # need to randomly try again\n else: # we have found k\n self.k = ((aY - aX) * inv) % order # so set it\n\n if self.G * self.k != self.Q: # not always 100% going to work\n print(\"error\")\n found = True\n\n self.time = time.time() - self.start\n\n # set space\n self.space = 18\n\n if self.verbose:\n print(\"k:\", self.k)\n print(\"Time taken: %.3f s\" % (self.time)) # print time taken\n print(\"Space used: %d\" % (self.space)) # print space used\n print(\"Numbers checked:\", self.count) # print total count\n\n return True","def advance(self):\n\n f, n, rtol, atol, neq = \\\n self.f, self.n, self.rtol, self.atol, self.neq\n u_n, t_n, t_next = self.u[n], self.t[n], self.t[n+1]\n dt = t_next - t_n\n\n first_step = dt # try one big step to next desired level\n\n def middle(x,y,z): # Auxilary function\n return sorted([x,y,z])[1]\n\n # Extract coefficients from Butcher-tableau\n table = self._butcher_tableau\n k_len = table.shape[1] - 1 # number of internal stages\n\n # coefficients for internal stages\n factors_u = np.asarray(table[:k_len, 1:])\n # coefficients for t\n factors_t = table[:k_len, 0]\n # coefficients for u_new\n factors_u_new = table[k_len, 1:]\n\n # coefficients for local error between 2 levels\n factors_error = table[k_len+1, 1:] - factors_u_new\n\n u_intermediate = [u_n,]\n t_intermediate = [t_n,]\n u, t, h = u_n, t_n, first_step # initial values\n k = np.zeros((k_len, self.neq), self.dtype) # intern stages\n\n if self.verbose > 0:\n print 'advance solution in [%s, %s], h=%g' % (t_n, t_next, h)\n\n # Loop until next time point is reached\n while (abs(t - t_n) < abs(t_next - t_n)):\n u, t = u_intermediate[-1], t_intermediate[-1]\n\n # Internal steps\n k[:, :] = 0. # initialization for next step\n for m in range(k_len):\n k_factors = (np.dot(factors_u, k))[m]\n #print u, u+h*k_factors, f(u+h*k_factor, 0.5), self.dtype\n k[m] = f(u+h*k_factors, t+h*factors_t[m])\n u_new = u + h*(np.dot(factors_u_new, k))\n\n self.info['rejected'] += 1 # reduced below if accepted\n if self.verbose > 0:\n print ' u(t=%g)=%g: ' % (t+h, u_new),\n\n # local error between 2 levels\n error = h*np.abs(np.dot(factors_error, k))\n # Acceptable error tolerance\n tol = rtol*np.abs(u_new) + atol\n\n accurate = (error <= tol).all()\n\n if accurate or h <= self.min_step or h >= self.max_step:\n # Accurate enough,\n # or the step size exceeds valid range,\n # must accept this solution\n u_intermediate.append(u_new)\n t_intermediate.append(t+h)\n if not self.disk_storage:\n self.u_all.append(u_new)\n self.t_all.append(t+h)\n self.info['rejected'] -= 1\n\n if self.verbose > 0:\n print 'accepted, ',\n else:\n if self.verbose > 0:\n print 'rejected, ',\n\n if self.verbose > 0:\n print 'err=%s, ' % str(error),\n if hasattr(self, 'u_exact') and callable(self.u_exact):\n print 'exact-err=%s, ' % \\\n (np.asarray(self.u_exact(t+h))-u_new),\n if h <= self.min_step:\n print 'h=min_step!! ',\n\n\n # Replace 0 values by 1e-16 since we will divide by error\n error = np.asarray([(1e-16 if x == 0. else x) \\\n for x in error])\n\n # Normarized error rate\n rms = error/tol\n rms_norm = np.sqrt(np.sum(rms*rms)/self.neq)\n\n order = float(self._method_order[0])\n # factor to adjust the size of next step\n # Formula is from <Numerical Methods for Engineers,\n # Chappra & Cannle>\n s = .8 *((1./rms_norm)**(1/order))\n # scalar should be in range(0.1, 4.)\n # for better accuracy and smoothness\n s = middle(s, 0.1, 4.0)\n h *= s\n\n # step size should be in range [min_step, max_step]\n h = middle(h, self.min_step, self.max_step)\n # adjust h to fit the last step\n h = min(h, t_next - t_intermediate[-1])\n\n if self.verbose > 0:\n print 'new h=%g' % h\n\n if h == 0:\n break\n\n return u_new","def _initialize(self):\n self._solution = self._problem_instance.build_solution(method=\"Greedy\")\n\n while not self._problem_instance.is_admissible(self._solution):\n self._solution = self._problem_instance.build_solution(method=\"Greedy\")\n \n self._problem_instance.evaluate_solution(self._solution, feedback=self._feedback)","def solve(self):\n self.m.optimize()\n if self.m.status == GRB.OPTIMAL:\n self.solution = self.sol_as_mat()\n return self.solution","def _screener_init(self):\n subject = 0\n self.model.uu.remove(subject) # selects from untested and performs e\n self.model.tt.append(subject)\n self.model.b -= (self.cz + self.cy) # update budget\n self.model.z[subject] = self.z[subject] # update model\n self.model.y[subject] = self.y[subject]","def run_trial(self, occ):\n from scitbx.array_family import flex\n seed = int(time.time() / os.getpid())\n random.seed(seed)\n flex.set_random_seed(seed)\n fmodel = self.fmodel\n selection = self.selection.deep_copy()\n iselection = self.iselection.deep_copy()\n d_min = fmodel.f_obs().d_min()\n xrs = fmodel.xray_structure.deep_copy_scatterers()\n hd_sel = xrs.hd_selection()\n sites_start = xrs.sites_cart().deep_copy()\n assert (len(selection) == len(sites_start))\n fmodel.update_xray_structure(xrs, update_f_calc=True)\n sites_start_selected = sites_start.select(iselection)\n occ_start = xrs.scatterers().extract_occupancies().deep_copy()\n u_start = xrs.extract_u_cart_plus_u_iso()\n if (self.params.adjust_b_factors_if_poor_density):\n fofc_map = fmodel.map_coefficients(\n map_type=\"mFo-DFc\",\n exclude_free_r_reflections=True).fft_map(\n resolution_factor=1/4.).apply_sigma_scaling().real_map_unpadded()\n sites_frac = xrs.sites_frac()\n b_scale_isel = flex.size_t()\n for i_seq in iselection :\n map_value = fofc_map.tricubic_interpolation(sites_frac[i_seq])\n if (map_value < -2.5):\n b_scale_isel.append(i_seq)\n if (len(b_scale_isel) > 0):\n b_scale_sel = flex.bool(sites_frac.size(), False).set_selected(\n b_scale_isel, True)\n xrs.scale_adp(factor=0.75, selection=b_scale_sel)\n nearby_water_selection = mmtbx.building.get_nearby_water_selection(\n pdb_hierarchy=self.pdb_hierarchy,\n xray_structure=xrs,\n selection=selection)\n two_fofc_map, fofc_map = alt_confs.get_partial_omit_map(\n fmodel=fmodel,\n selection=iselection,\n selection_delete=None,#nearby_water_selection,\n negate_surrounding=self.params.negate_surrounding,\n partial_occupancy=occ)\n #xrs.set_occupancies(occ_start)\n make_sub_header(\"Simulated annealing into mFo-DFc map\", out=self.out)\n if (self.params.shake_sites is not None):\n xrs.shake_sites_in_place(self.params.shake_sites, selection=selection)\n sites_new = mmtbx.building.run_real_space_annealing(\n xray_structure=xrs,\n pdb_hierarchy=self.pdb_hierarchy,\n processed_pdb_file=self.processed_pdb_file,\n selection=selection,\n target_map=fofc_map,\n d_min=d_min,\n params=self.params.simulated_annealing,\n #wc=5, # FIXME why does this need to be scaled?\n target_map_rsr=two_fofc_map,\n rsr_after_anneal=self.params.rsr_after_anneal,\n out=self.out,\n debug=True)\n # now compute CC of refined sites to difference map\n fmodel.update_xray_structure(xrs, update_f_calc=True)\n fc_coeffs = fmodel.f_model()\n fc_fft_map = fc_coeffs.fft_map(resolution_factor=1/4.)\n fc_map = fc_fft_map.apply_sigma_scaling().real_map_unpadded()\n pdb_atoms = self.pdb_hierarchy.atoms()\n # XXX should this only calculate statistics for the central atoms?\n map_stats = mmtbx.building.get_model_map_stats(\n selection=self.selection_score,\n target_map=fofc_map,\n model_map=fc_map,\n unit_cell=xrs.unit_cell(),\n sites_cart=sites_new,\n pdb_atoms=pdb_atoms,\n local_sampling=False)\n # reset xray structure\n xrs.set_sites_cart(sites_start)\n xrs.set_u_cart(u_start)\n fmodel.update_xray_structure(xrs, update_f_calc=True)\n # we may only want the rmsd and max. dev. from a subset of sites, e.g.\n # the central residue of a sliding window (minus hydrogens)\n selection_score = self.selection_score.deep_copy()\n if (type(selection_score).__name__ != 'bool'):\n selection_score = flex.bool(hd_sel.size(), False).set_selected(\n self.selection_score, True)\n selection_score &= ~hd_sel\n site_stats = alt_confs.coord_stats_with_flips(\n sites1=sites_start.select(selection_score),\n sites2=sites_new.select(selection_score),\n atoms=self.pdb_hierarchy.atoms().select(selection_score))\n return alt_confs.trial_result(\n sites_cart=sites_new.select(self.iselection),\n min_fofc=map_stats.min,\n mean_fofc=map_stats.mean,\n rmsd=site_stats.rmsd,\n max_dev=site_stats.max_dev,\n cc=map_stats.cc)","def calculate(self, model_name, number_of_points, bandwidth,dis_param, c,k, seed, phi=0):\n if model_name != \"Anderson\":\n raise Error(\"NotImpelmented\")\n prng = np.random.RandomState((None if seed == 0 else seed))\n \n m = models.Model_Anderson_DD_1d(number_of_points=number_of_points,\n bandwidth=bandwidth, dis_param=dis_param, periodic=False, prng = prng)\n prng = np.random.RandomState((None if seed == 0 else seed))\n \n m1 = models.Model_Anderson_DD_1d(number_of_points=number_of_points,\n bandwidth=bandwidth, dis_param=dis_param, periodic=True, prng = prng, phi=0)\n prng = np.random.RandomState((None if seed == 0 else seed))\n \n m2 = models.Model_Anderson_DD_1d(number_of_points=number_of_points,\n bandwidth=bandwidth, dis_param=dis_param, periodic=True, prng = prng, phi=phi)\n \n g = abs(phys_functions.A_matrix_inv(m.rate_matrix, c, k))**2\n psi_1, psi_N = (m1.eig_matrix[0,:]), (m1.eig_matrix[-1,:])\n thouless, prec = phys_functions.pure_thouless_g(m1.eig_vals, m2.eig_vals, phi)\n heat_g = phys_functions.heat_g(psi_1, psi_N)\n psi1psiN = np.nansum(abs(psi_1*psi_N))\n ############# UGLY HACK : Append zeros to fit sizes\n vals_with_N_size = [('psi_1', psi_1),\n ('psi_N', psi_N),('thouless_g', abs(thouless))]\n if self._N == number_of_points :\n appended = vals_with_N_size\n else:\n myzeros = np.zeros(self._N - number_of_points)\n \n appended = [(key, np.append(val,myzeros)) for key,val in vals_with_N_size]\n \n print (prec*number_of_points, np.nansum(thouless))\n return dict([('g', g), ('psi1psiN',psi1psiN), \n ('thouless_sum', abs(np.nansum(abs(thouless)))), ('phi',phi),('heat_g', heat_g)] +appended)"],"string":"[\n \"def _doCalibration(self):\\n self._cmdCalibration(2)\",\n \"def fit_once(self,random_restart=True):\\n \\n if random_restart:\\n ## Main mode of operation\\n \\n # Initializations\\n n_iterations = int(np.ceil(np.log2(self.K))) # log_2(K) iterations\\n self.initialize_empty_solution()\\n self.residual = self.sketch_reweighted\\n \\n # Add the starting atom\\n new_theta = self.randomly_initialize_new_atom()\\n new_theta = self.maximize_atom_correlation(new_theta)\\n self.add_atom(new_theta)\\n \\n # Main loop\\n for i_iteration in range(n_iterations):\\n ## Step 1-2: split the currently selected atoms\\n self.split_all_atoms()\\n \\n ## Step 3: if necessary, hard-threshold to enforce sparsity\\n while self.n_atoms > self.K:\\n beta = self.find_optimal_weights(normalize_atoms=True)\\n index_to_remove = np.argmin(beta)\\n self.remove_atom(index_to_remove)\\n \\n \\n ## Step 4: project to find weights\\n self.alpha = self.find_optimal_weights()\\n \\n ## Step 5: fine-tune\\n self.minimize_cost_from_current_sol()\\n\\n # Cleanup\\n self.update_Atoms() # The atoms have changed: we must re-compute their sketches matrix\\n self.residual = self.sketch_reweighted - self.sketch_of_solution()\\n \\n # Final fine-tuning with increased optimization accuracy\\n self.minimize_cost_from_current_sol(ftol=0.02*self.step5_ftol)\\n \\n # Normalize weights to unit sum\\n self.alpha /= np.sum(self.alpha)\\n \\n # Package into the solution attribute\\n self.current_sol = (self.alpha, self.Theta)\",\n \"def start_uncorrelated_self_optimizer_strategy(wf):\\n\\n optimizer_method = wf.execution_strategy[\\\"optimizer_method\\\"]\\n info(\\\"> ExecStrategy | UncorrelatedSelfOptimizer\\\", Fore.CYAN)\\n info(\\\"> Optimizer | \\\" + optimizer_method, Fore.CYAN)\\n\\n knobs = wf.execution_strategy[\\\"knobs\\\"]\\n wf.totalExperiments = len(knobs) * wf.execution_strategy[\\\"optimizer_iterations\\\"]\\n\\n total_result = dict()\\n # we fill the arrays and use the index to map from gauss-optimizer-value to variable\\n for key in knobs:\\n optimal_knob_value = optimizeOneVariable(wf, wf.execution_strategy[\\\"optimizer_iterations\\\"], key,\\n (knobs[key][0], knobs[key][1]))\\n total_result[key] = optimal_knob_value\\n wf.change_provider[\\\"instance\\\"].applyChange(total_result)\\n info(\\\">\\\")\\n info(\\\"> FinalResult | Best Values: \\\" + str(total_result))\",\n \"def calibrate(self, master):\\n if master.polyorder == 'linear':\\n self.fitfunction = \\\"A0 + A1 * D\\\"\\n self.fit_fkt = self.calc_lin\\n elif master.polyorder == 'quadratic':\\n self.fit_fkt = self.calc_quad\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2\\\"\\n elif master.polyorder == \\\"cubic\\\":\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2 + A3 * D**3\\\"\\n self.fit_fkt = self.calc_cubic\\n else:\\n print(\\\"Polynomgrad nicht definiert\\\")\\n \\n self.mw = np.asarray(self.mw)\\n if master.sensortype == \\\"Druck\\\":\\n self.best, self.covar = curve_fit(self.fit_fkt, self.mw, master.Referencedata.caldat)\\n else:\\n print(\\\"Sensortyp noch nicht Hinterlegt\\\")\",\n \"def solve(self):\\n # check for jacobian and set it if present and to be used\\n if self.use_sparse:\\n if self._use_jac and hasattr(self.problem,'sparse_jac'):\\n jac = self.problem.sparse_jac\\n else:\\n jac = None\\n else:\\n if self._use_jac and hasattr(self.problem,'jac'):\\n jac = self.problem.jac\\n else:\\n jac = None\\n \\n # Initialize solver and solve \\n \\n solved = False\\n local_min = False\\n\\n res = N.zeros(self.x0.__len__())\\n while (not solved) and self.reg_count < 2:\\n try:\\n if self._use_fscale:\\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,self.fscale)\\n else:\\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,None)\\n start = time.clock()\\n res = self.solver.KINSOL_solve(not self._use_ls)\\n stop = time.clock()\\n self.exec_time += (stop - start)\\n solved = True\\n except KINError as error:\\n if error.value == 42:\\n # Try the heuristic\\n if hasattr(self.problem, 'get_heuristic_x0'):\\n print \\\"----------------------------------------------------\\\"\\n print \\\" Solver stuck with zero step-length.\\\"\\n print \\\"----------------------------------------------------\\\"\\n print \\\"The following variables have start value zero\\\"\\n print \\\"and min set to zero causing the zero step-lenght.\\\"\\n print \\\"These settings are either set by default or by user.\\\"\\n print \\\"\\\"\\n\\n self.x0 = self.problem.get_heuristic_x0()\\n self.reg_count += 1\\n \\n print \\\"\\\"\\n print \\\"This setting (start and min to zero) can often\\\"\\n print \\\"cause problem when initializing the system. \\\"\\n print \\\"\\\"\\n print \\\"To avoid this the above variables have\\\"\\n print \\\"their start attributes reset to one.\\\"\\n print \\\"\\\"\\n print \\\"Trying to solve the system again...\\\"\\n else:\\n raise KINSOL_Exception(\\\"Regularization failed due to constraints, tried getting heuristic initial guess but failed.\\\")\\n \\n\\n elif (error.value == 2):\\n print \\\"---------------------------------------------------------\\\"\\n print \\\"\\\"\\n print \\\" !!! WARNING !!!\\\"\\n print \\\"\\\"\\n print \\\" KINSOL has returned a result but the algorithm has converged\\\"\\n print \\\" to a local minima, the initial values are NOT consistant!\\\"\\n print \\\"\\\"\\n print \\\"---------------------------------------------------------\\\"\\n solved = True\\n local_min = True\\n else:\\n # Other error, send onward as exception\\n self.problem.check_constraints(res)\\n raise KINSOL_Exception(error.msg[error.value])\\n \\n if not solved:\\n self.solver.Free_KINSOL()\\n raise KINSOL_Exception(\\\"Algorithm exited solution loop without finding a solution, please contact Assimulo support.\\\")\\n\\n if self.check_with_model:\\n self.problem.check_constraints(res)\\n if not local_min:\\n print \\\"Problem sent to KINSOL solved.\\\"\\n \\n return res\",\n \"def calc_orig(self):\\n measure = self.measure\\n # Calculate work for all possible matching pairs from sim and obs\\n aw = np.full(shape=(len(self.q_obs), len(self.q_sim)), fill_value=np.nan)\\n # iterate through all flow observations\\n for i_o in range(len(self.q_obs)):\\n # Check only simulations within the allowed window\\n for i_s in range(max(0, i_o - self.max_lead),\\n min(len(self.q_sim), i_o + self.max_lag + 1)):\\n if measure in ('nse', 'square'):\\n aw[i_s, i_o] = (self.q_sim[i_s] - self.q_obs[i_o]) ** 2 + self.b ** 2 * (i_s - i_o) ** 2\\n elif measure in ('mae', 'abs'):\\n aw[i_s, i_o] = np.abs(self.q_sim[i_s] - self.q_obs[i_o]) + self.b * np.abs(i_s - i_o)\\n\\n # Calculate cumulative work along possible paths\\n cw = np.ones(shape=aw.shape + (2,)) * np.nan\\n # Populate first column\\n cw[:, 0, 0] = aw[:, 0]\\n\\n if self.keep_internals:\\n self.aw = aw\\n self.cw = cw\\n\\n # Populate other columns\\n # Filter out warning to suppress warnings from numpy when np.nanmin\\n # encounters all NaN slices\\n with warnings.catch_warnings():\\n warnings.simplefilter('ignore')\\n for i_o in range(1, aw.shape[1]):\\n for i_s in range(max(0, i_o - self.max_lead),\\n min(aw.shape[1], i_o + self.max_lag + 1)):\\n # e = aw[i_s, i_o]\\n if measure in ('nse', 'square'):\\n e = (self.q_sim[i_s] - self.q_obs[i_o]) ** 2 + self.b ** 2 * (i_s - i_o) ** 2\\n elif measure in ('mae', 'abs'):\\n e = np.abs(self.q_sim[i_s] - self.q_obs[i_o]) + self.b * np.abs(i_s - i_o)\\n\\n # Repeat the same simulation point\\n cw[i_s, i_o, 1] = e + cw[i_s, i_o - 1, 0]\\n\\n if i_s > 0:\\n m1 = np.nanmin(cw[i_s - 1, i_o - 1, :])\\n if i_s > 1:\\n # Skip a sim point\\n m2 = np.nanmin(cw[i_s - 2, i_o - 1, :])\\n else:\\n m2 = np.inf\\n m = min(m1, m2)\\n cw[i_s, i_o, 0] = e + m\\n self.opt_score = np.nanmin(cw[:, -1, :])\\n self.of = 1 - self.opt_score / self.fbench\\n\\n if self.calc_rays:\\n # self._do_calc_rays(cw[:, :, 0], cw[:, :, 1])\\n s, e = 0, None\\n for i_o in range(len(self.q_obs))[::-1]:\\n # print('')\\n # print(i_o, s, e)\\n # print(cw[s:e, i_o, 0])\\n m = np.nanargmin(cw[s:e, i_o, 0]) + s\\n try:\\n m_rep = np.nanargmin(cw[s:e, i_o, 1]) + s\\n except ValueError:\\n pass\\n else:\\n if cw[m_rep, i_o, 1] <= cw[m, i_o, 0]:\\n m = m_rep\\n self.tau[i_o] = i_o - m\\n self.res[i_o] = self.q_obs[i_o] - self.q_sim[m]\\n self.rays[i_o] = [(i_o, self.q_obs[i_o]), (m, self.q_sim[m])]\\n # print(i_o, s, e, m)\\n s, e = max(0, m - 2), m + 1\\n\\n return self.of\",\n \"def solve_prep(self):\\n\\n par = self.par\\n sol = self.sol\\n\\n # a. retirement\\n sol.m_ret = np.zeros((par.T,par.Nm_ret))\\n sol.c_ret = np.zeros((par.T,par.Nm_ret))\\n sol.a_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_v_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vm_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vn_ret = np.zeros((par.T,par.Nm_ret))\\n\\n # b. working\\n if par.solmethod == 'G2EGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.ucon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.dcon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.acon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.z = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n \\n elif par.solmethod == 'NEGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((0,0,0))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((0,0,0))\\n \\n sol.c_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\\n sol.inv_v_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\",\n \"def on_iteration_start(self):\\n\\n self.Xfprv = self.Xf.copy()\\n if (not self.opt['FastSolve'] or isinstance(self.backtrack,\\n BacktrackRobust)):\\n self.Yfprv = self.Yf.copy()\\n\\n if self.opt['Monotone']:\\n if self.k == 0:\\n self.objfn = self.eval_objfn()\\n self.objfn_prev = self.objfn\",\n \"def _evolve(\\n self,\\n x0_idx: int,\\n ) -> np.ndarray:\\n x0 = self.starting_points[x0_idx, :]\\n if type(x0) != np.ndarray:\\n x0 = x0.toarray()\\n x0 = x0.flatten()\\n # [T, Dims, (Position, Velocity)]\\n trajectory = np.zeros(\\n (self.timesteps, x0.shape[0], 3), dtype=np.float32)\\n \\n # for each timestep, update the position of the phase point\\n # based on the velocity of nearest neighbors and obey any\\n # boundary constraints\\n x = x0\\n for t in range(self.timesteps):\\n trajectory[t, :, 0] = x # match x position to dv/dx\\n v = self.v_fxn(x=x.reshape(-1),)\\n # add white noise if desired to better emulate a stochastic process\\n noise = v[:, 1] * np.random.randn(v.shape[0]) * self.noise_scale\\n x_new = x + (v[:, 0] + noise)*self.step_scale\\n # constrain to a set of pre-defined boundaries\\n # defaults to an identity if not set explicitly\\n x_new = self.boundary_constraint(x_new)\\n trajectory[t, :, 1] = v[:, 0]\\n trajectory[t, :, 2] = v[:, 1]\\n x = x_new\\n return trajectory\",\n \"def automatic_results(self):\\n self.find_coefficients()\\n self.calculate_numerical_solution()\\n self.plot_solution()\\n self.L2_norm()\",\n \"def run_calib(projector=OPTOMA_HD33()):\\n w, h = (0.2160, 0.2794)\\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\\n [-w/2, 0, 0], [w/2, 0, 0],\\n [-w/2, 0, h/2], [w/2, 0, h/2]])\\n\\n global img_points, going\\n img_points = []\\n\\n try:\\n window = Window()\\n window.MoveXY(1600,0)\\n window.ShowFullScreen(True)\\n going = True\\n\\n @window.eventx\\n def EVT_MOUSE_EVENTS(evt):\\n global going, img_points\\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\\n img_points.append(evt.Position)\\n print('Picked point %d of 6' % (len(img_points)))\\n if len(img_points) == len(obj_points):\\n print \\\"Done\\\"\\n going = False\\n\\n print(\\\"\\\"\\\"[Extrinsic Calibration] \\n\\nThere should be 6 points marked on the table and backdrop. \\nMoving the mouse over the projected display, click each of the points\\nin order:\\n (left top, on the backdrop),\\n (right top, on the backdrop),\\n (left center, on the crease),\\n (right center, on the crease),\\n (left bottom, on the table),\\n (right bottom, on the table)\\n\\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\\n\\nClick the six points:\\n\\\"\\\"\\\")\\n\\n while going: cv.WaitKey(10)\\n\\n finally:\\n window.Close()\\n\\n img_points = np.array(img_points, 'f')\\n projector.calibrate_extrinsic(img_points, obj_points)\\n\\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\\n print('OK')\",\n \"def calc_dense2(self):\\n # Local copies of instance attributes for faster access\\n b = self.b\\n qs = self.q_sim\\n qo = self.q_obs\\n maxlead = self.max_lead\\n maxlag = self.max_lag\\n measure = self.measure\\n time = self.time\\n n = len(self.q_obs)\\n\\n if self.calc_rays:\\n warnings.warn('Not possible to calculate connecting rays when using HMA.calc_dense2')\\n if self.keep_internals:\\n warnings.warn('Not possible to keep internals when using HMA.calc_dense2')\\n\\n for i_o in range(n):\\n # Cycle cw arrays\\n if i_o > 0:\\n cw0_prev = cw0_cur\\n cw1_prev = cw1_cur\\n cw0_cur = np.full(n, np.inf, dtype=np.float64)\\n cw1_cur = np.full(n, np.inf, dtype=np.float64)\\n\\n iss = max(0, i_o - maxlead) # sim index start\\n ise = min(n, i_o + maxlag + 1) # sim index end\\n isv = np.arange(iss, ise) # sim index as vector\\n if time is not None:\\n dt = time[isv] - time[i_o]\\n # Heavily penalize sim-obs combinations outside allowed window\\n # so that they are not selected\\n dt[(dt < -maxlag) | (dt > maxlead)] = np.inf\\n else:\\n dt = isv - i_o\\n if measure in ('nse', 'square'):\\n e = (qs[iss:ise] - qo[i_o]) ** 2 + b ** 2 * dt ** 2\\n elif measure in ('mae', 'abs'):\\n e = np.abs(qs[iss:ise] - qo[i_o]) + b * np.abs(dt)\\n\\n if i_o == 0:\\n # Only populate first column of cw0 and move to i_o = 1\\n cw0_cur[iss:ise] = e\\n continue\\n\\n # Repeat the same simulation point\\n d = cw0_prev[iss:ise]\\n cw1_cur[iss:ise] = e + d\\n\\n # Find the 'cheapest' available preceding sim point\\n points = np.full((len(isv), 4), np.inf)\\n # Use the previous simulation point\\n st = max(0, iss-1)\\n end = min(n + 1, ise - 1)\\n l = end - st\\n points[-l:, 0] = cw0_prev[st:end]\\n points[-l:, 1] = cw1_prev[st:end]\\n # Skip a simulation point\\n st = max(0, iss - 2)\\n end = min(n + 1, ise - 2)\\n l = end - st\\n points[-l:, 2] = cw0_prev[st:end]\\n points[-l:, 3] = cw1_prev[st:end]\\n cw0_cur[iss:ise] = (e + np.min(points, axis=1))\\n\\n # Find the cheapest point in the last column, i.e. end of cheapest path, i.e. optimum score\\n self.opt_score = min(np.min(cw0_cur), np.min(cw1_cur))\\n self.of = 1 - self.opt_score / self.fbench\\n\\n return self.of\",\n \"def on_iteration_start(self):\\n\\n self.Xprv = self.X.copy()\\n if (not self.opt['FastSolve'] or isinstance(self.backtrack,\\n BacktrackRobust)):\\n self.Yprv = self.Y.copy()\\n\\n if self.opt['Monotone']:\\n if self.k == 0:\\n self.objfn = self.eval_objfn()\\n self.objfn_prev = self.objfn\",\n \"def calibration(self) -> int:\",\n \"def _generate_solution(self):\\n \\n operation_list = []\\n available = {job.get_job_id(): [operation for operation in job.get_operations() if operation.get_sequence() == 0] for job in self.jssp_instance_data.jobs} # dictionary of first unprocessed operations of each job\\n \\n while 0 < len(available):\\n rand_job_id = random.choice(list(available.keys()))\\n rand_operation = random.choice(available[rand_job_id])\\n rand_machine = np.random.choice(rand_operation.get_required_machines())\\n\\n available[rand_job_id].remove(rand_operation)\\n \\n if len(available[rand_job_id]) == 0:\\n # if selected operation is last operation of the job \\n if rand_operation.get_sequence() == self.jssp_instance_data.get_job(rand_job_id).get_max_sequence():\\n del available[rand_job_id]\\n else:\\n available[rand_job_id] = [t for t in self.jssp_instance_data.get_job(rand_job_id).get_operations() if\\n t.get_sequence() == rand_operation.get_sequence() + 1]\\n\\n\\n operation_list.append([rand_job_id, rand_operation.get_operation_id(), rand_operation.get_sequence(), rand_machine]) # chromosome representation \\n return Solution(self.jssp_instance_data, np.array(operation_list, dtype=np.intc))\",\n \"def solve_and_apply_ensemble(self, save_datapack, ant_idx, time_idx, dir_idx, freq_idx, iterations,\\n interval, shift, init_solutions = None, num_threads=1,verbose=False,\\n model_kwargs = {}):\\n if init_solutions is not None:\\n data = np.load(init_solutions)\\n\\n kern_ls = data['kern_ls']\\n kern_var = data['kern_var']\\n kern_times = data['time']\\n kern_antenna_labels = data['antenna']\\n\\n \\n datapack = self.datapack\\n directions, patch_names = datapack.get_directions(dir_idx)\\n times,timestamps = datapack.get_times(time_idx)\\n antennas,antenna_labels = datapack.get_antennas(ant_idx)\\n freqs = datapack.get_freqs(freq_idx)\\n\\n if ant_idx is -1:\\n ant_idx = range(len(antennas))\\n if time_idx is -1:\\n time_idx = range(len(times))\\n if freq_idx is -1:\\n freq_idx = range(len(freqs))\\n if dir_idx is -1:\\n dir_idx = range(len(directions))\\n \\n\\n phase = datapack.get_phase(ant_idx,time_idx,dir_idx,freq_idx)\\n Na,Nt,Nd,Nf = phase.shape\\n logging.warning(\\\"Working on shapes {}\\\".format(phase.shape))\\n \\n if interval is None:\\n interval = Nt\\n\\n assert interval <= Nt\\n\\n variance = datapack.get_variance(ant_idx,time_idx,dir_idx,freq_idx)\\n error = np.sqrt(variance)\\n data_mask = variance < 0\\n error[data_mask] = -1\\n logging.warning(\\\"Total masked phases: {}\\\".format(np.sum(data_mask)))\\n\\n enu = ENU(obstime=times[0],location = self.datapack.radio_array.get_center())\\n \\n ant_enu = antennas.transform_to(enu)\\n x = np.array([ant_enu.east.to(au.km).value, ant_enu.north.to(au.km).value]).T\\n t = times.mjd*86400.#mjs\\n d = np.array([directions.ra.deg, directions.dec.deg]).T\\n f = freqs\\n \\n lock = Lock()\\n with futures.ThreadPoolExecutor(max_workers=num_threads) as executor:\\n jobs = []\\n\\n for j,aj in enumerate(time_idx[::shift]):\\n start = j*shift\\n stop = min(start+interval,Nt)\\n time_slice = slice(start,stop,1)\\n \\n# if init_solutions is not None:\\n# ###\\n# # interpolate kern_params with this interval/shift\\n# mean_time = np.mean(times.gps[time_slice])\\n\\n# model_kwargs['ls_init'] = (\\n# np.interp(mean_time, kern_times, kern_ls[ant_idx,:,1].mean(0)),\\n# np.interp(mean_time, kern_times, kern_ls[ant_idx,:,0].mean(0))\\n# )\\n #logging.warning(model_kwargs['ls_init'])\\n \\n # initial ls_scale (if they exist)\\n\\n# (phase, error, coords, lock, error_sigma_clip=4., m_type='sgp', \\n# iterations=1000, pargs=None,verbose=False,model_kwargs={}):\\n model_file = os.path.join(self.proj_dir,\\\"model_{}_{}\\\".format(start,stop))\\n\\n jobs.append(executor.submit(\\n self._solve_interval_full,\\n model_file,\\n phase[:,time_slice,:,:],\\n error[:,time_slice,:,:],\\n (x, t[time_slice],d,f),\\n lock,\\n load_model = model_file,\\n error_sigma_clip = None,\\n m_type='sgp_full',\\n iterations=iterations,\\n pargs=\\\"Working on time chunk ({}) {} to ({}) {}\\\".format(\\n start,timestamps[start],stop-1,timestamps[stop-1]),\\n verbose=verbose,\\n model_kwargs = model_kwargs\\n )\\n )\\n results = futures.wait(jobs)\\n if verbose:\\n logging.warning(results)\\n results = [j.result() for j in jobs]\\n\\n phase_mean = np.zeros(phase.shape)\\n phase_weights = np.zeros(phase.shape)\\n variance_mean = np.zeros(variance.shape)\\n res_idx = 0\\n for j,aj in enumerate(time_idx[::shift]):\\n start = j*interval\\n stop = min((j+1)*interval,Nt)\\n time_slice = slice(start,stop,1)\\n res = results[res_idx]\\n p,v = res\\n phase_mean[:,time_slice,:,:] += p/(v+1e-6)\\n variance_mean[:,time_slice,:,:] += 1.\\n phase_weights[:,time_slice,:,:] += 1./(v+1e-6)\\n res_idx += 1\\n phase_mean /= (phase_weights+1e-6)\\n variance_mean /= (phase_weights+1e-6)\\n datapack.set_phase(phase_mean, ant_idx=ant_idx,time_idx=time_idx,dir_idx=dir_idx,freq_idx=freq_idx)\\n datapack.set_variance(variance_mean, ant_idx=ant_idx,time_idx=time_idx,dir_idx=dir_idx,freq_idx=freq_idx)\\n datapack.save(save_datapack)\",\n \"def _fit(self, X):\\n n = len(X)\\n\\n # Initialise start vectors\\n w = [0] * n\\n for i in range(n):\\n if self.randomState is None:\\n w[i] = np.ones((X[i].shape[1], 1))\\n else:\\n w[i] = self.randomState.rand(X[i].shape[1], 1)\\n w[i] = w[i] / np.linalg.norm(w[i])\\n\\n # Find model (Gauss-Siedel iteration)\\n func_val = [self.f(X, w)]\\n for it in range(self.max_iter):\\n for i in range(n):\\n wi = 0.0\\n for j in range(n):\\n if self.pred_comp[i][j] > 0:\\n wi += np.dot(X[i].T, np.dot(X[j], w[j]))\\n norm_wi = np.linalg.norm(wi)\\n if norm_wi > consts.TOLERANCE:\\n wi /= norm_wi\\n w[i] = wi\\n\\n func_val.append(self.f(X, w))\\n\\n if it >= 1:\\n err = func_val[-1] - func_val[-2]\\n else:\\n err = func_val[-1]\\n\\n self.num_iter = it + 1\\n\\n if abs(err) < consts.TOLERANCE:\\n break\\n\\n # Find all model vectors\\n t = [0] * n\\n p = [0] * n\\n for i in range(n):\\n t[i] = np.dot(X[i], w[i])\\n p[i] = np.dot(X[i].T, t[i])\\n titi = np.linalg.norm(t[i])**2.0\\n if titi > consts.TOLERANCE:\\n p[i] = p[i] / titi\\n else:\\n self.warn(\\\"Too small joint component for matrix %d! \\\"\\n \\\"Trying to continue!\\\" % (i,))\\n\\n # Normalise P? It matters whether we update with W or with P!\\n # TODO: Option?\\n# normp = norm(P{i});\\n# P{i} = P{i} / normp;\\n# T{i} = T{i} * normp;\\n\\n return w, t, p, func_val\",\n \"def solve(self):\\n \\n # Check if cost is available for both estimators\\n if not self.est0.cost_avail or not self.est1.cost_avail:\\n self.comp_cost = False\\n \\n # Initial estimate from the input node\\n if self.comp_cost:\\n z0, zvar0, cost0 = self.est0.est_init(return_cost=True)\\n else:\\n z0, zvar0 = self.est0.est_init(return_cost=False)\\n cost0 = 0\\n self.z0 = z0\\n self.zvar0 = zvar0\\n self.cost0 = cost0\\n \\n # Initialize other variables\\n self.var_cost0 = 0\\n self.var_cost1 = 0\\n self.cost = 0\\n self.s = np.zeros(self.shape1)\\n \\n for it in range(self.nit):\\n \\n # Forward transform to est1\\n t0 = time.time()\\n rvar1_new = self.A.var_dot(self.zvar0)\\n rvar1_rep = common.repeat_axes(rvar1_new,self.shape1,\\\\\\n self.var_axes1,rep=False)\\n z1_mult = self.A.dot(self.z0)\\n r1_new = z1_mult - rvar1_rep*self.s\\n \\n # Damping\\n if it > 0: \\n self.r1 = (1-self.step)*self.r1 + self.step*r1_new\\n self.rvar1 = (1-self.step)*self.rvar1 + self.step*rvar1_new\\n else:\\n self.r1 = r1_new\\n self.rvar1 = rvar1_new\\n\\n # Estimator 1 \\n if self.comp_cost: \\n z1, zvar1, cost1 = self.est1.est(self.r1, self.rvar1, return_cost=True) \\n if not self.map_est:\\n cost1 -= self.cost_adjust(self.r1,z1,self.rvar1,zvar1,\\\\\\n self.shape1,self.var_axes1)\\n else:\\n z1, zvar1 = self.est1.est(self.r1, self.rvar1, return_cost=False) \\n cost1 = 0\\n self.z1 = z1\\n self.zvar1 = zvar1\\n self.cost1 = cost1 \\n con_new = np.mean(np.abs(z1-z1_mult)**2) \\n \\n # Reverse nonlinear transform to est 0\\n self.s = (self.z1-self.r1)/rvar1_rep\\n self.sprec = 1/self.rvar1*(1-self.zvar1/self.rvar1)\\n t1 = time.time()\\n self.time_est1 = t1-t0\\n \\n # Reverse linear transform to est 0 \\n rvar0_new = 1/self.A.var_dotH(self.sprec)\\n rvar0_rep = common.repeat_axes(rvar0_new,self.shape0,\\\\\\n self.var_axes0,rep=False)\\n r0_new = self.z0 + rvar0_rep*self.A.dotH(self.s)\\n \\n # Damping\\n if it > 0:\\n self.r0 = (1-self.step)*self.r0 + self.step*r0_new\\n self.rvar0 = (1-self.step)*self.rvar0 + self.step*rvar0_new\\n else:\\n self.r0 = r0_new\\n self.rvar0 = rvar0_new\\n \\n \\n # Estimator 0\\n if self.comp_cost:\\n z0, zvar0, cost0 = self.est0.est(self.r0, self.rvar0, return_cost=True)\\n if not self.map_est:\\n cost0 -= self.cost_adjust(self.r0,z0,self.rvar0,zvar0,\\\\\\n self.shape0,self.var_axes0)\\n \\n else:\\n z0, zvar0 = self.est0.est(self.r0, self.rvar0, return_cost=False)\\n cost0 = 0\\n self.z0 = z0\\n self.zvar0 = zvar0\\n self.cost0 = cost0 \\n\\n \\n # Compute total cost and constraint \\n cost_new = self.cost0 + self.cost1 \\n if not self.map_est:\\n cost_new += self.cost_gauss()\\n \\n # Step size adaptation\\n if (self.step_adapt) and (it > 0):\\n if (con_new < self.con):\\n self.step = np.minimum(1,self.step_inc*self.step)\\n else:\\n self.step = np.maximum(self.step_min, self.step_dec*self.step)\\n self.cost=cost_new\\n self.con=con_new\\n \\n t2 = time.time()\\n self.time_est0 = t2-t1\\n self.time_iter = t2-t0\\n \\n # Print progress\\n if self.prt_period > 0:\\n if (it % self.prt_period == 0):\\n if self.comp_cost:\\n print(\\\"it={0:4d} cost={1:12.4e} con={2:12.4e} step={3:12.4e}\\\".format(\\\\\\n it, self.cost, self.con, self.step))\\n else:\\n print(\\\"it={0:4d} con={1:12.4e}\\\".format(\\\\\\n it, self.con))\\n \\n # Save history\\n self.save_hist()\",\n \"def selfcal_apcal(imc, trial='1'):\\n flagmanager(imc.vislf, mode='restore', versionname='startup')\\n applycal(vis=imc.vislf,\\n spwmap=np.zeros(54),\\n interp='linearPDperobs',\\n gaintable=[imc.path_base+'.pcal'+trial],\\n calwt=False,\\n flagbackup=False)\",\n \"def solve(self):\\n\\n # Open status display\\n fmtstr, nsep = self.display_start()\\n\\n # Start solve timer\\n self.timer.start(['solve', 'solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n\\n # Main optimisation iterations\\n for self.k in range(self.k, self.k + self.opt['MaxMainIter']):\\n\\n # Update record of X and Y from previous iteration\\n self.on_iteration_start()\\n\\n # Compute backtracking\\n if self.opt['Backtrack'] is not None and self.k >= 0:\\n self.timer.stop('solve_wo_btrack')\\n # Compute backtracking\\n self.backtrack.update(self)\\n self.timer.start('solve_wo_btrack')\\n else:\\n # Compute just proximal step\\n self.xstep()\\n # Update by combining previous iterates\\n self.ystep()\\n\\n # Compute residuals and stopping thresholds\\n self.timer.stop(['solve_wo_rsdl', 'solve_wo_btrack'])\\n if not self.opt['FastSolve']:\\n frcxd, adapt_tol = self.compute_residuals()\\n self.timer.start('solve_wo_rsdl')\\n\\n # Compute and record other iteration statistics and\\n # display iteration stats if Verbose option enabled\\n self.timer.stop(['solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n if not self.opt['FastSolve']:\\n itst = self.iteration_stats(self.k, frcxd)\\n self.itstat.append(itst)\\n self.display_status(fmtstr, itst)\\n self.timer.start(['solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n\\n # Call callback function if defined\\n if self.opt['Callback'] is not None:\\n if self.opt['Callback'](self):\\n break\\n\\n # Stop if residual-based stopping tolerances reached\\n if not self.opt['FastSolve']:\\n if frcxd < adapt_tol:\\n break\\n\\n # Increment iteration count\\n self.k += 1\\n\\n # Record solve time\\n self.timer.stop(['solve', 'solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n\\n # Print final separator string if Verbose option enabled\\n self.display_end(nsep)\\n\\n return self.getmin()\",\n \"def step(self):\\n if self.Y.shape[0]<self.initial_design_numdata:\\n self.suggested_sample = initial_design('random', self.space, 1)\\n else:\\n self.suggested_sample = self._compute_next_evaluations()\\n\\n self.X = np.vstack((self.X,self.suggested_sample))\\n\\n # --- Update current evaluation time and function evaluations\\n self.num_acquisitions += 1\\n\\n if self.verbosity:\\n print(\\\"num acquisition: {}\\\".format(self.num_acquisitions))\\n\\n return np.array(self.suggested_sample[0,:])\",\n \"def calibrate(self, Otrain, Ftrain, Feval):\\n return Otrain[0] * np.ones(len(Feval))\",\n \"def objective(trial):\\n # The parameters that we will calibrate the model for are shown here.\\n # Optuna trial i\\n BOD = trial.suggest_uniform(\\\"BOD\\\", 0, 1) #Review ranges here\\n k_r = trial.suggest_uniform(\\\"k_r\\\", 0, 1) #Review Ranges here \\n \\n def ChLa(t):\\n return 1 # Need to link to data\\n\\n def I(x):\\n return 1 # Need to link to data\\n\\n K_z = 2 * 10**(-5) # p.51\\n a = K_z\\n k_b = 0.1 # Table 5\\n th_b = 1.047 # Table 5\\n k_r = 0.1 # Table 5\\n YCHO2 = 0.0083 # Table 5\\n th_p = 1.036 # Table 5\\n th_s = 1.065 # Table 5\\n th_r = 1.047 # Table 5\\n\\n def Temp(t):\\n \\\"\\\"\\\"\\n Function that maps time to temperature\\n \\\"\\\"\\\"\\n return 20 # Need to link to data\\n\\n def P_max(t):\\n return 9.6 * 1.036 **(Temp(t) - 20) # Eq. 4\\n\\n def L_min(t):\\n I = 1 # Need to link to PAR data\\n K_1 = 0.687 * 1.086**(Temp(t) - 20)\\n K_2 = 15\\n return I * (1 + 2 * np.sqrt(K_1 / K_2)) / (I + K_1 + I**2 / K_2) # Eq. 5\\n \\n # f deals with sink and source terms \\n def f(x, t):\\n return -1 / YCHO2 * k_r * th_r**(Temp(t) - 20) * ChLa(t) + P_max(t) * L_min(t) * ChLa(t) - k_b * th_b**(Temp(t)-20) * BOD \\n\\n L = 200 # Length of domain\\n dt = 1 / 48 # Mesh spacing in t\\n F = a * dt # a * dt / dx**2\\n T = 100 # Simulation time stop\\n\\n # Solving the PDE\\n DO, x, t, _ = solver_FE_simple(I, a, f, L, dt, F, T)\\n \\n # Creating some bogus targets while database errors are happening\\n DO_data = DO + np.random.random(len(DO))\\n\\n # Using mean squared error as the measure of fit, where we want\\n # to minimize this number\\n return ((DO - DO_data)**2).mean()\",\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 fit_once(self,random_restart=True,n_iterations=None):\\n \\n if random_restart:\\n ## Main mode of operation\\n \\n # Initializations\\n if n_iterations is None:\\n n_iterations = 2*self.K # By default: CLOMP-*R* (repeat twice)\\n self.initialize_empty_solution()\\n self.residual = self.sketch_reweighted\\n \\n # Main loop\\n for i_iteration in range(n_iterations):\\n ## Step 1: find new atom theta most correlated with residual\\n new_theta = self.randomly_initialize_new_atom()\\n new_theta = self.maximize_atom_correlation(new_theta) \\n \\n ## Step 2: add it to the support\\n self.add_atom(new_theta)\\n \\n ## Step 3: if necessary, hard-threshold to enforce sparsity\\n if self.n_atoms > self.K:\\n beta = self.find_optimal_weights(normalize_atoms=True)\\n index_to_remove = np.argmin(beta)\\n self.remove_atom(index_to_remove)\\n # Shortcut: if the last added atom is removed, we can skip to next iter\\n if index_to_remove == self.K: continue\\n \\n \\n ## Step 4: project to find weights\\n self.alpha = self.find_optimal_weights()\\n \\n ## Step 5: fine-tune\\n self.minimize_cost_from_current_sol()\\n\\n # Cleanup\\n self.update_Atoms() # The atoms have changed: we must re-compute their sketches matrix\\n self.residual = self.sketch_reweighted - self.sketch_of_solution()\\n \\n # Final fine-tuning with increased optimization accuracy\\n self.minimize_cost_from_current_sol(ftol=0.02*self.step5_ftol)\\n \\n # Normalize weights to unit sum\\n self.alpha /= np.sum(self.alpha)\\n \\n # Package into the solution attribute\\n self.current_sol = (self.alpha, self.Theta)\",\n \"def calc_dense(self, calc_aw=False):\\n # Local copies of instance attributes for faster access\\n b = self.b\\n qs = self.q_sim\\n qo = self.q_obs\\n maxlead = self.max_lead\\n maxlag = self.max_lag\\n measure = self.measure\\n time = self.time\\n n = len(self.q_obs)\\n\\n # Calculate work between obs and sim pairs, not needed anymore.\\n if calc_aw:\\n aw = np.full((n, n), np.nan)\\n st = pd.Timestamp.now()\\n print('Start aw loops')\\n # iterate through all flow observations\\n for i_o in range(len(qo)):\\n # Check only simulations within the allowed window\\n for i_s in range(max(0, i_o - self.max_lead),\\n min(len(qs), i_o + maxlag + 1)):\\n aw[i_s, i_o] = (qs[i_s] - qo[i_o]) ** 2 + b ** 2 * (i_s - i_o) ** 2\\n print('End aw loops', (pd.Timestamp.now()-st)/pd.Timedelta('1s'))\\n self.aw = aw\\n\\n # Old debugging code: run original implementation alongside\\n # Applies to all variables appended with _orig\\n # aw_orig = np.zeros(shape=(len(self.q_obs), len(self.q_sim))) * np.nan\\n # # iterate through all flow observations\\n # for i_o in range(len(self.q_obs)):\\n # # Check only simulations within the allowed window\\n # for i_s in range(max(0, i_o - self.max_lead),\\n # min(len(self.q_sim), i_o + self.max_lag + 1)):\\n # aw_orig[i_s, i_o] = (self.q_sim[i_s] - self.q_obs[i_o]) ** 2 + self.b ** 2 * (i_s - i_o) ** 2\\n\\n # Calculate cumulative work along possible paths\\n cw0 = np.full((n, n), np.inf, dtype=np.float64)\\n cw1 = np.full((n, n), np.inf, dtype=np.float64)\\n\\n # Old debugging code: run original implementation (with dense arrays) alongside\\n # Applies to all variables marked _orig\\n # # Calculate cumulative work along possible paths\\n # cw_orig = np.ones(shape=aw_orig.shape + (2,)) * np.nan\\n # # Populate first column\\n # cw_orig[:, 0, 0] = aw_orig[:, 0]\\n\\n if self.keep_internals:\\n # self.aw_orig = aw_orig\\n self.cw0 = cw0\\n self.cw1 = cw1\\n # self.cw_orig = cw_orig\\n\\n # Filter out warning to suppress warnings from numpy when np.nanmin\\n # encounters all NaN slices\\n # with warnings.catch_warnings():\\n # warnings.simplefilter('ignore')\\n\\n # Populate other columns\\n for i_o in range(n):\\n iss = max(0, i_o - maxlead) # sim index start\\n ise = min(n, i_o + maxlag + 1) # sim index end\\n isv = np.arange(iss, ise) # sim index as vector\\n if time is not None:\\n dt = time[isv] - time[i_o]\\n # Heavily penalize sim-obs combinations outside allowed window\\n # so that they are not selected\\n dt[(dt < -maxlag) | (dt > maxlead)] = np.inf\\n else:\\n dt = isv - i_o\\n # Vectorized version of the calculation.\\n # For understanding it is best to take a look at the calc_sparse, where non-vectorized code is kept for\\n # reference\\n # Calculate the work for each (sim, obs_i) pair\\n if measure in ('nse', 'square'):\\n e = (qs[iss:ise] - qo[i_o]) ** 2 + b ** 2 * dt ** 2\\n elif measure in ('mae', 'abs'):\\n e = np.abs(qs[iss:ise] - qo[i_o]) + b * np.abs(dt)\\n if i_o == 0:\\n # Only populate first column of cw0 and move to i_o = 1\\n cw0[iss:ise, 0] = e\\n continue\\n\\n # Repeat the same simulation point\\n d = cw0[iss:ise, i_o - 1]#.toarray()\\n d[d == 0] = np.nan\\n cw1[iss:ise, i_o] = e + d\\n\\n # Find the 'cheapest' available preceding sim point\\n points = np.full((len(isv), 4), np.inf)\\n # Use the previous simulation point, not repeated\\n st = max(0, iss-1)\\n end = min(n + 1, ise - 1)\\n l = end - st\\n points[-l:, 0] = cw0[st:end, i_o - 1]\\n # Use the previous simulation point, repeated\\n points[-l:, 1] = cw1[st:end, i_o - 1]\\n # Skip a simulation point, not repeated\\n st = max(0, iss-2)\\n end = min(n + 1, ise - 2)\\n l = end - st\\n points[-l:, 2] = cw0[st:end, i_o - 1]\\n # Skip a simulation point, repeated\\n points[-l:, 3] = cw1[st:end, i_o - 1]\\n # Take best preceding point\\n cw0[iss:ise, i_o] = (e + np.min(points, axis=1))\\n # Find the cheapest point in the last column, i.e. end of cheapest path, i.e. optimum score\\n self.opt_score = min(np.min(cw0[:, -1]), np.min(cw1[:, -1]))\\n self.of = 1 - self.opt_score / self.fbench\\n\\n if self.calc_rays:\\n self._do_calc_rays(cw0, cw1)\\n\\n return self.of\",\n \"def calibrate(): \\n \\n # Calibrate of the run using beam data. Creates a folder cal-files/caltag \\n # containing all calibration data. \\n CalObj = Calibration(steerfiles=steerfiles, name=localcaltag + '-cal') \\n\\n # Set Beam energy\\n CalObj.set_beam_momentum(beamenergy)\\n\\n # Get gearfile and set air as DUT material\\n localgearfile = CalObj.get_filename('gear.xml')\\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='thickness', value=0.0001)\\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='radLength', value=304000.0)\\n \\n # Create list of calibration steps \\n calpath = create_calibration_path(CalObj)\\n \\n # Run the calibration steps \\n CalObj.calibrate(path=calpath,ifile=rawfile_air,caltag=localcaltag)\",\n \"def photometric_calibration():\\n pass\",\n \"def _compute_results(self):\\n self.Y_best = best_value(self.Y)\\n self.x_opt = self.X[np.argmin(self.Y),:]\\n self.fx_opt = np.min(self.Y)\\n self.distance = self._compute_distance_betw_consecutive_x()\",\n \"def _reset_solution(self, firm_size):\\n x_lower, x_upper = self.model.workers.lower, self.model.workers.upper\\n y_upper = self.model.firms.upper\\n initial_V = np.array([y_upper, firm_size])\\n\\n if self.model.assortativity == 'positive':\\n self.ivp.set_initial_value(initial_V, x_upper)\\n wage = self.evaluate_wage(x_upper, initial_V)\\n profit = self.evaluate_profit(x_upper, initial_V)\\n self._solution = np.hstack((x_upper, initial_V, wage, profit))\\n else:\\n self.ivp.set_initial_value(initial_V, x_lower)\\n wage = self.evaluate_wage(x_lower, initial_V)\\n profit = self.evaluate_profit(x_lower, initial_V)\\n self._solution = np.hstack((x_lower, initial_V, wage, profit))\",\n \"def calibration(self, cal: int, /) -> None:\",\n \"def optimize(self, acqf: MCAcquisitionFunction) -> Tuple[Tensor, Tensor]:\\n initial_conditions = self.generate_restart_points(acqf)\\n # shape = num_restarts x *acqf.batch_shape x 1 x dim_X\\n if self.inequality_constraints is not None:\\n org_shape = initial_conditions.shape\\n initial_conditions = initial_conditions.reshape(\\n self.num_restarts, -1, self.dim_x\\n )\\n options = {\\\"maxiter\\\": int(self.maxiter / 25)}\\n with settings.propagate_grads(True):\\n solutions, values = gen_candidates_scipy(\\n initial_conditions=initial_conditions,\\n acquisition_function=acqf,\\n lower_bounds=self.bounds[0],\\n upper_bounds=self.bounds[1],\\n options=options,\\n inequality_constraints=self.inequality_constraints,\\n )\\n self.add_solutions(solutions.view(-1, 1, self.dim_x).detach())\\n best_ind = torch.argmax(values, dim=0)\\n if self.inequality_constraints is not None:\\n solutions = solutions.reshape(org_shape)\\n solution = solutions.gather(\\n dim=0,\\n index=best_ind.view(1, *best_ind.shape, 1, 1).repeat(\\n *[1] * (best_ind.dim() + 2), self.dim_x\\n ),\\n )\\n if self.inequality_constraints is not None:\\n org_shape = solution.shape\\n solution = solution.reshape(1, -1, self.dim_x)\\n options = {\\\"maxiter\\\": self.maxiter}\\n with settings.propagate_grads(True):\\n solution, value = gen_candidates_scipy(\\n initial_conditions=solution,\\n acquisition_function=acqf,\\n lower_bounds=self.bounds[0],\\n upper_bounds=self.bounds[1],\\n options=options,\\n inequality_constraints=self.inequality_constraints,\\n )\\n # This is needed due to nested optimization\\n value = acqf(solution)\\n if self.inequality_constraints is not None:\\n solution = solution.reshape(org_shape)\\n return solution, value.reshape(*acqf.batch_shape)\",\n \"def fit(self):\\n \\n self.createGraph()\\n self.setOfdPlus()\\n self.setOfdMoins()\\n\\n self.arrayStep = list()\\n \\n for i in range(0, self.nbIteration):\\n p = self.ptD()\\n for u in range(0, self.nbUser):\\n # Aulieu de prendre tous les users pour la boucle ci-dessus\\n # prendre seulement les successeurs, serait plus efficace.\\n for v in range(0, self.nbUser):\\n sumThetaPtd = 0\\n sumDSets = len(self.dPlus[u,v]) + self.dMoins[u][v]\\n for d in self.dPlus[u,v]:\\n sumThetaPtd += self.theta[u][v]/p[d][v]\\n self.theta[u][v] = sumThetaPtd/sumDSets\\n \\n self.arrayStep.append(self.theta.copy())\\n \\n self.arrayStep = np.asarray(self.arrayStep)\",\n \"def step(self):\\n # A = self.array\\n # B = self.array2\\n # ra, rb, f, k = self.params\\n H = self.array\\n L = self.array2\\n birth_rate, death_rate, a, c = self.params\\n \\n # cA = correlate2d(A, self.kernel, **self.options)\\n # cB = correlate2d(B, self.kernel, **self.options)\\n cH = correlate2d(H, self.kernel,**self.options)\\n cL = correlate2d(L, self.kernel, **self.options)\\n\\n # reaction = A * B**2\\n\\n # self.array += ra * cA - reaction + f * (1-A) \\n # self.array2 += rb * cB + reaction - (f+k) * B\\n self.array += birth_rate*cH - a*L*H\\n self.array2 += c*cL*cH - death_rate*L\",\n \"def calc_control_and_trajectory(x, dw, goal, ob):\\n x_init = np.array(x)\\n\\n best_u = [0.0, 0.0]\\n best_trajectory = None\\n\\n u_samples = []\\n traj_samples = []\\n cost_samples = []\\n # evaluate all trajectory with sampled input in dynamic window\\n for v in np.arange(dw[0], dw[1], Config.v_resolution):\\n for y in np.arange(dw[2], dw[3], Config.yaw_rate_resolution):\\n\\n trajectory = predict_trajectory(x_init, v, y)\\n # calc cost\\n to_goal_cost = calc_to_goal_cost(trajectory, goal)\\n speed_cost = (Config.max_speed - trajectory[-1, 3])\\n ob_cost = calc_obstacle_cost(trajectory, ob)\\n\\n cost_samples.append([to_goal_cost,speed_cost,ob_cost])\\n u_samples.append([v, y])\\n traj_samples.append(trajectory)\\n cost_samples = np.array(cost_samples)\\n # normalization\\n def normalize_0_1(x):\\n if np.max(x)-np.min(x)>1e-4:\\n return (x-np.min(x))/(np.max(x)-np.min(x))\\n else:\\n return np.zeros_like(x)\\n\\n def normalize_div_sum(x):\\n if np.sum(x) > 1e-4:\\n return x/np.sum(x)\\n else:\\n return np.zeros_like(x)\\n\\n # for i in range(3):\\n # non_inf = cost_samples[:,i] != np.inf\\n # if np.sum(non_inf) >0:\\n # cost_samples[non_inf,i] = normalize_0_1(cost_samples[non_inf,i])\\n \\n cost_samples = Config.to_goal_cost_gain*cost_samples[:,0]+Config.speed_cost_gain*cost_samples[:,1]+Config.obstacle_cost_gain*cost_samples[:,2]\\n ind = np.argmin(cost_samples)\\n best_u = u_samples[ind]\\n best_trajectory = traj_samples[ind]\\n\\n if abs(best_u[0]) < Config.robot_stuck_flag_cons \\\\\\n and abs(x[3]) < Config.robot_stuck_flag_cons:\\n # to ensure the robot do not get stuck in\\n # [v,w] = [0,0], force the robot rotate\\n best_u[1] = -Config.max_delta_yaw_rate\\n return best_u, best_trajectory\",\n \"def evolute(self, ngen, x0=None, verbose=True):\\r\\n self.history = {'local_fitness':[], 'global_fitness':[], 'a': [], 'A': []}\\r\\n self.best_fitness=float(\\\"inf\\\") \\r\\n self.verbose=verbose\\r\\n self.Positions = np.zeros((self.nwhales, self.dim))\\r\\n if x0:\\r\\n assert len(x0) == self.nwhales, '--error: the length of x0 ({}) MUST equal the number of whales in the group ({})'.format(len(x0), self.nwhales)\\r\\n for i in range(self.nwhales):\\r\\n self.Positions[i,:] = x0[i]\\r\\n else:\\r\\n #self.Positions=self.init_sample(self.bounds) #TODO, update later for mixed-integer optimisation\\r\\n # Initialize the positions of whales\\r\\n \\r\\n for i in range(self.dim):\\r\\n self.Positions[:, i] = (np.random.uniform(0, 1, self.nwhales) * (self.ub[i] - self.lb[i]) + self.lb[i])\\r\\n \\r\\n fitness0=self.eval_whales()\\r\\n \\r\\n self.best_position, self.best_fitness = self.select(self.Positions, fitness0)\\r\\n \\r\\n for k in range(0, ngen):\\r\\n \\r\\n # a is annealed from 2 to 0\\r\\n self.a = self.a0 - k * ((self.a0) / (ngen))\\r\\n # fac is annealed from -1 to -2 to estimate l\\r\\n self.fac = -1 + k * ((-1) / ngen)\\r\\n #-----------------------------\\r\\n # Update Whale Positions\\r\\n #-----------------------------\\r\\n self.UpdateWhales()\\r\\n \\r\\n #----------------------\\r\\n # Evaluate New Whales\\r\\n #----------------------\\r\\n fitness=self.eval_whales()\\r\\n \\r\\n for i, fits in enumerate(fitness):\\r\\n #save the best of the best!!!\\r\\n if fits < self.best_fitness:\\r\\n self.best_fitness=fits\\r\\n self.best_position=self.Positions[i, :].copy()\\r\\n \\r\\n #--mir\\r\\n if self.mode=='max':\\r\\n self.fitness_best_correct=-self.best_fitness\\r\\n self.local_fitness=-np.min(fitness)\\r\\n else:\\r\\n self.fitness_best_correct=self.best_fitness\\r\\n self.local_fitness=np.min(fitness)\\r\\n\\r\\n self.history['local_fitness'].append(self.local_fitness)\\r\\n self.history['global_fitness'].append(self.fitness_best_correct)\\r\\n self.history['a'].append(self.a)\\r\\n self.history['A'].append(self.A)\\r\\n \\r\\n # Print statistics\\r\\n if self.verbose and i % self.nwhales:\\r\\n print('^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^')\\r\\n print('WOA step {}/{}, nwhales={}, Ncores={}'.format((k+1)*self.nwhales, ngen*self.nwhales, self.nwhales, self.ncores))\\r\\n print('^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^')\\r\\n print('Best Whale Fitness:', np.round(self.fitness_best_correct,6))\\r\\n print('Best Whale Position:', np.round(self.best_position,6))\\r\\n print('a:', np.round(self.a,3))\\r\\n print('A:', np.round(self.A,3))\\r\\n print('^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^')\\r\\n\\r\\n if self.verbose:\\r\\n print('------------------------ WOA Summary --------------------------')\\r\\n print('Best fitness (y) found:', self.fitness_best_correct)\\r\\n print('Best individual (x) found:', self.best_position)\\r\\n print('--------------------------------------------------------------') \\r\\n \\r\\n return self.best_position, self.fitness_best_correct, self.history\",\n \"def fit_once(self,random_restart=False):\\n raise NotImplementedError\",\n \"def _calc_corrections(self): \\n searchIter= self._niter-1\\n while searchIter > 0:\\n trySavefilename= self._createSavefilename(searchIter)\\n if os.path.exists(trySavefilename):\\n trySavefile= open(trySavefilename,'rb')\\n corrections= sc.array(pickle.load(trySavefile))\\n trySavefile.close()\\n break\\n else:\\n searchIter-= 1\\n if searchIter == 0:\\n corrections= sc.ones((self._npoints,2))\\n for ii in range(searchIter,self._niter):\\n if ii == 0:\\n currentDF= self._dftype(surfaceSigma=self._surfaceSigmaProfile,\\n beta=self._beta)\\n else:\\n currentDF= self._dftype(surfaceSigma=self._surfaceSigmaProfile,\\n beta=self._beta,\\n corrections=corrections,\\n npoints=self._npoints,\\n rmax=self._rmax,\\n savedir=self._savedir,\\n interp_k=self._interp_k)\\n newcorrections= sc.zeros((self._npoints,2))\\n for jj in range(self._npoints):\\n thisSurface= currentDF.surfacemass(self._rs[jj],\\n use_physical=False)\\n newcorrections[jj,0]= currentDF.targetSurfacemass(self._rs[jj],use_physical=False)/thisSurface\\n newcorrections[jj,1]= currentDF.targetSigma2(self._rs[jj],use_physical=False)*thisSurface\\\\\\n /currentDF.sigma2surfacemass(self._rs[jj],\\n use_physical=False)\\n #print(jj, newcorrections[jj,:])\\n corrections*= newcorrections\\n #Save\\n picklethis= []\\n for arr in list(corrections):\\n picklethis.append([float(a) for a in arr])\\n save_pickles(self._savefilename,picklethis) #We pickle a list for platform-independence)\\n return corrections\",\n \"def solve(self, regparam):\\n self.regparam = regparam\\n \\n #Some counters for bookkeeping\\n self.stepcounter = 0\\n self.flipcounter = 0\\n self.nochangecounter = 0\\n \\n #Cached results\\n self.evals = np.multiply(self.svals, self.svals)\\n self.newevals = 1. / (self.evals + self.regparam)\\n newevalslamtilde = np.multiply(self.evals, self.newevals)\\n self.D = np.sqrt(newevalslamtilde)\\n #self.D = -newevalslamtilde\\n \\n self.VTY = self.svecs.T * self.Y\\n DVTY = np.multiply(self.D.T, self.svecs.T * self.Y)\\n \\n #Using lists in order to avoid unnecessary matrix slicings\\n self.DVTY_list = []\\n self.YTVDDVTY_list = []\\n self.classFitnessList = []\\n for i in range(self.labelcount):\\n DVTY_i = DVTY[:,i]\\n self.DVTY_list.append(DVTY_i)\\n YTVDDVTY_i = DVTY_i.T * DVTY_i\\n self.YTVDDVTY_list.append(YTVDDVTY_i)\\n fitness_i = self.size - DVTY_i.T * DVTY_i\\n self.classFitnessList.append(fitness_i)\\n \\n self.Dsvecs_list = []\\n self.svecsDDsvecs_list = []\\n for i in range(self.size):\\n Dsvec = np.multiply(self.D.T, self.svecs[i].T)\\n self.Dsvecs_list.append(Dsvec)\\n self.svecsDDsvecs_list.append(Dsvec.T*Dsvec)\\n \\n self.updateA()\\n \\n \\n converged = False\\n print(self.classcounts.T)\\n if self.callbackfun is not None:\\n self.callbackfun.callback(self)\\n while True:\\n \\n converged = self.roundRobin()\\n print(self.classcounts.T)\\n if self.callbackfun is not None:\\n self.callbackfun.callback(self)\\n if converged: break\\n \\n if self.oneclass:\\n self.Y = self.Y[:, 0]\\n self.A = self.A[:, 0]\\n self.results['predicted_clusters_for_training_data'] = self.Y\\n self.predictor = self.svdad.createModel(self)\",\n \"def run_solution1(self):\\n return reduce(lambda a, b: a + self.calculate_fuel(b), self.data, 0)\",\n \"def solve(self):\",\n \"def get_sol(self):\",\n \"def _calibrate(self, Otrain, Ftrain, Feval):\\n raise NotImplementedError()\",\n \"def __update(self):\\n\\n # Make sure loads have been assigned to group\\n if type(self.appliedLoad) == Load:\\n self.appliedLoad = LoadSet(self.appliedLoad)\\n elif type(self.appliedLoad) != LoadSet:\\n raise TypeError(\\\"Applied load must be a Load or LoadSet\\\")\\n\\n # Begin Calculations\\n _cg = self.cg # calculate the cg once to save computation time\\n _appLoad = self.appliedLoad.totalForce\\n _appMoment = self.appliedLoad.totalMoment\\n\\n coef_mat = np.zeros((len(self) * 3, len(self) * 3)) # coeff matrix\\n soln_mat = np.zeros(len(self) * 3) # solution matrix\\n\\n cSet = [[i, i+1, i+2] for i in range(0, 3 * len(self), 3)]\\n rSet = [[i+6, i+7, i+8] for i in range(0, 3 * (len(self) - 2), 3)]\\n\\n for i, j in enumerate(cSet):\\n # i = column fastener ID\\n # j = column fastener set\\n # Mx = yFz - zFy\\n # My = zFx - xFz\\n # Mz = xFy - yFx\\n\\n Fx = j[0]\\n Fy = j[1]\\n Fz = j[2]\\n\\n # fill in first three rows\\n coef_mat[0][Fx] = 1 # sum of Fx\\n coef_mat[1][Fy] = 1 # sum of Fy\\n coef_mat[2][Fz] = 1 # sum of Fz\\n\\n # fill in fourth row (sum of Mx at CG)\\n coef_mat[3][Fy] = -(F[i].xyz[2] - _cg[2]) # -zFy\\n coef_mat[3][Fz] = +(F[i].xyz[1] - _cg[1]) # +yFz\\n\\n # fill in fifth row (sum of My at CG)\\n coef_mat[4][Fx] = +(F[i].xyz[2] - _cg[2]) # +zFx\\n coef_mat[4][Fz] = -(F[i].xyz[0] - _cg[0]) # -xFz\\n\\n # fill in sixth row (sum of Mz at CG)\\n coef_mat[5][Fx] = -(F[i].xyz[1] - _cg[1]) # -yFx\\n coef_mat[5][Fy] = +(F[i].xyz[0] - _cg[0]) # +xFy\\n\\n for u, w in enumerate(rSet):\\n # u = row fastener ID\\n # w = row fastener set\\n\\n rX = w[0]\\n rY = w[1]\\n rZ = w[2]\\n\\n coef_mat[rX][Fy] = -(F[i].xyz[2] - F[u].xyz[2]) # -zFy\\n coef_mat[rX][Fz] = +(F[i].xyz[1] - F[u].xyz[1]) # +yFz\\n\\n coef_mat[rY][Fx] = +(F[i].xyz[2] - F[u].xyz[2]) # +zFx\\n coef_mat[rY][Fz] = -(F[i].xyz[0] - F[u].xyz[0]) # -xFz\\n\\n coef_mat[rZ][Fx] = -(F[i].xyz[1] - F[u].xyz[1]) # -yFx\\n coef_mat[rZ][Fy] = +(F[i].xyz[0] - F[u].xyz[0]) # +xFy\\n\\n # fill in the solution matrix (soln_mat)\\n for i in range(3):\\n soln_mat[i] = -_netLoad.force[i]\\n soln_mat[i+3] = -_netLoad.moment[i]\\n\\n # fill in the remaining rows\\n for i, j in enumerate(rSet):\\n # i = fastener\\n # j = row\\n\\n rX = j[0]\\n rY = j[1]\\n rZ = j[2]\\n\\n # Mx = (y_cg - y_i)F_znet - (z_cg - z_i)F_ynet + M_xnet\\n soln_mat[rX] = - ((_cg[1] - F[i].xyz[1]) * _netLoad.force[2]\\n - (_cg[2] - F[i].xyz[2]) * _netLoad.force[1]\\n + _netLoad.moment[0])\\n\\n # My = (z_cg - z_i)F_xnet - (x_cg - x_i)F_znet + M_ynet\\n soln_mat[rY] = -((_cg[2] - F[i].xyz[2]) * _netLoad.force[0]\\n - (_cg[0] - F[i].xyz[0]) * _netLoad.force[2]\\n + _netLoad.moment[1])\\n\\n # Mz = (x_cg - x_i)F_ynet - (y_cg - y_i)F_xnet + M_znet\\n soln_mat[rZ] = -((_cg[0] - F[i].xyz[0]) * _netLoad.force[1]\\n - (_cg[1] - F[i].xyz[1]) * _netLoad.force[0]\\n + _netLoad.moment[2])\\n\\n # Solve system of equations\\n matSol = np.linalg.lstsq(coef_mat, soln_mat)[0]\\n\\n # Add resulting fastener loads to fastener objects\\n for i, j in enumerate(cSet):\\n rX = j[0]\\n rY = j[1]\\n rZ = j[2]\\n\\n F[i].force[0] = matSol[rX]\\n F[i].force[1] = matSol[rY]\\n F[i].force[2] = matSol[rZ]\",\n \"def solve(self):\\n\\n # Set up display header if verbose operation enabled\\n if self.opt['Verbose']:\\n hdr = 'Itn DFidX PriResX DuaResX DFidG' + \\\\\\n ' ResG '\\n print(hdr)\\n print('-' * len(hdr))\\n\\n # Main iteration loop\\n for n in range(self.opt['MaxMainIter']):\\n\\n # At start of 2nd iteration, set the numbers of inner\\n # iterations for the X and G solvers from the options\\n # object for the outer solver\\n if n == 1:\\n self.slvX.opt['MaxMainIter'] = self.opt['XslvIter']\\n self.slvG.opt['MaxMainIter'] = self.opt['GslvIter']\\n\\n # Run the configured number of iterations of the X (CSC)\\n # solver and assign the result to X\\n self.X = self.slvX.solve()\\n\\n # Compute the sum of the subpixel shifts of X\\n Xhs = np.sum(fftconv(self.H, self.X.squeeze(), axes=(0, 1)),\\n axis=-1)\\n\\n # Set the convolution kernel in the deconvolution solver\\n # to the sum of the subpixel shifts of X\\n self.slvG.setG(Xhs)\\n # Run the configured number of iterations of the G\\n # (deconvolution) solver and crop the result to obtain the\\n # updated g\\n self.g = self.slvG.solve()[0:self.gshp[0], 0:self.gshp[1]]\\n\\n # Construct a new dictionary for the X (CSC) solver from\\n # the updated psf g\\n self.D, self.dn = self.getD(self.g)\\n self.slvX.setdict(self.D[..., np.newaxis, np.newaxis, :])\\n\\n # Display iteration statistics if verbose operation enabled\\n if self.opt['Verbose']:\\n itsX = self.slvX.getitstat()\\n itsG = self.slvG.getitstat()\\n fmt = '%3d %.3e %.3e %.3e %.3e %.3e'\\n tpl = (n, itsX.DFid[-1], itsX.PrimalRsdl[-1],\\n itsX.DualRsdl[-1], itsG.DFid[-1], itsG.Rsdl[-1])\\n print(fmt % tpl)\\n\\n # Return the (normalised) psf estimate g\\n return self.g / np.linalg.norm(self.g)\",\n \"def compute(self):\\n\\n self.setd = []\\n self.satc = [False for cl in self.soft] # satisfied clauses\\n self.solution = None\\n self.bb_assumps = [] # backbone assumptions\\n self.ss_assumps = [] # satisfied soft clause assumptions\\n\\n if self.oracle.solve():\\n # hard part is satisfiable => there is a solution\\n self._filter_satisfied(update_setd=True)\\n self._compute()\\n\\n self.solution = list(map(lambda i: i + 1, filter(lambda i: not self.satc[i], range(len(self.soft)))))\\n\\n return self.solution\",\n \"def solve(self):\\n\\n constrains, bounds = self.init_constraint_list()\\n result = minimize(self.objective_function,\\n x0=self.init_guess,\\n constraints=constrains,\\n bounds=bounds,\\n options={'disp': False})\\n\\n return result\",\n \"def _solve_explicit(self, initial_conditions):\\n coeff = self.a ** 2 * self.tau / self.h ** 2\\n current_solution = initial_conditions\\n next_solution = np.empty_like(current_solution)\\n solutions = []\\n\\n for t in self.t_grid:\\n next_solution[1:-1] = (\\n current_solution[1:-1]\\n + (current_solution[:-2] - 2 * current_solution[1:-1] + current_solution[2:]) * coeff\\n ) + self.rhs(self.x_grid[1:-1], t) * self.tau\\n\\n # left bc\\n if self.left_bc_type == \\\"DIRICHLET\\\":\\n next_solution[0] = self.left_bc(t)\\n elif self.left_bc_type == \\\"NEUMANN\\\":\\n next_solution[0] = (\\n 4 * next_solution[1]\\n - next_solution[2]\\n - 2 * self.h * self.left_bc(t)\\n ) / 3.0\\n\\n # right bc\\n if self.right_bc_type == \\\"DIRICHLET\\\":\\n next_solution[-1] = self.right_bc(t)\\n elif self.right_bc_type == \\\"NEUMANN\\\":\\n next_solution[-1] = (\\n 4 * next_solution[-2]\\n - next_solution[-3]\\n + 2 * self.h * self.right_bc(t)\\n ) / 3.0\\n if self.mode == \\\"VISUALIZATION\\\":\\n solutions.append((t, next_solution.copy()))\\n current_solution = next_solution\\n if self.mode == \\\"TEST\\\":\\n # print(\\\"Result: \\\", current_solution.tolist())\\n # print(\\\"Right answer: \\\", self.anl_solution.tolist())\\n self._norma(current_solution)\\n elif self.mode == \\\"VISUALIZATION\\\":\\n return solutions\",\n \"def __solve(self) -> None:\\n pyo.TransformationFactory(\\\"contrib.detect_fixed_vars\\\").apply_to(self.model) # type: ignore\\n pyo.TransformationFactory(\\\"contrib.deactivate_trivial_constraints\\\").apply_to(self.model) # type: ignore\\n\\n # initialise the solver object\\n self._logger.debug(\\\"[ModelSolver] Solver object initiated...\\\")\\n solver = Config.OPTIMISATION_MODEL_CONFIG['SOLVER_TYPE']\\n opt = pyo.SolverFactory(solver)\\n if Config.OPTIMISATION_MODEL_CONFIG['SOLVER_OPTION'].get(solver) is not None:\\n for k, v in Config.OPTIMISATION_MODEL_CONFIG['SOLVER_OPTION'].get(solver).items():\\n opt.options[k] = v\\n\\n try:\\n start_time = datetime.now()\\n self._logger.debug(\\\"[ModelSolver] Solver starting...\\\")\\n results = opt.solve(self.model, tee=True)\\n self.results = results\\n end_time = datetime.now()\\n self._logger.info(f\\\"[ModelSolver] Solver completed in {end_time - start_time}.\\\")\\n except Exception as e:\\n raise Exception(f\\\"Model optimisation failed with {solver} with error message {e}.\\\")\\n\\n if (results.solver.status == SolverStatus.ok) and (results.solver.termination_condition == TerminationCondition.optimal):\\n self._logger.info(\\\"Solution is feasible and optimal\\\")\\n results.write()\\n elif results.solver.termination_condition == TerminationCondition.infeasible:\\n raise ValueError(\\\"Model optimisation resulted into an infeasible solution\\\")\\n\\n self.model.optimised = True\",\n \"def calibrate_onc(data, path, model_name):\\n \\n #split test data (subsets 7-9) into new test (7-8)/train(9) sets\\n calibration_train_set = data[((data.subset==7)|(data.subset==8))].copy()\\n calibration_test_set = data[data.subset==9].copy()\\n\\n #define calibration model\\n ir = IsotonicRegression(out_of_bounds=\\\"clip\\\")\\n #fit the model to the probas from the training set\\n ir.fit(calibration_train_set.score, calibration_train_set.y )\\n \\n #evaluate with the test set and save\\n calibration_test_set.loc[:,'p_calibrated'] = ir.transform(calibration_test_set.score) \\n \\n #calibration_test_set.loc[:,'p_calibrated'] = p_calibrated\\n \\n #save\\n with open(path + 'model_calibrated_' + model_name + '.pickle', 'wb') as picklefile: \\n pickle.dump(ir,picklefile)\\n \\n with open(path + 'y_calibrated_' + model_name + '.pickle', 'wb') as picklefile: \\n pickle.dump(calibration_test_set, picklefile)\\n \\n print_calibrated_results(calibration_test_set.y, calibration_test_set.score, calibration_test_set.p_calibrated)\\n return calibration_test_set\",\n \"def solve_environment(self):\\n \\n #The first problem formulation\\n #K kinds of towers\\n #See more details about problem formulation in the writeup \\n \\n #Get a full matrix of the concatenated coverage matrices for \\n #each tower type. THis new matrix has dimensions:\\n #(Ntowers) x (sum(potential sites)), where the sum o=is over all tower types\\n coverage = np.hstack(i for i in self.coverage_matrices)\\n print coverage\\n print coverage.shape \\n \\n #Diagonal matrix of the values of each target\\n #(for the scenarios where we don't care about maximizing covered value,\\n #target_values is just all ones, so this is just the identity matrix)\\n V = np.diag(self.target_values)\\n \\n #If doing scenario where we want to fortify weakest link, only makes\\n #sense if all targets are equal value:\\n if self.objective_type == 'min_entries':\\n V = np.eye(len(self.target_values))\\n\\n #Get the matrix of coverage values / expected value saved:\\n C = np.dot(V,coverage)\\n print 'V', V\\n print 'coverage', coverage\\n print 'C', C\\n \\n \\n #Since not gauranteed to reach global optimum on any particular initialization,\\n #run a few times and take the best result.\\n #Just define \\\"best result\\\" as the result which had the most overall \\n #\\\"converged\\\" x, combined over all tower kinds. \\n# for j in xrange(self.N_random_starts_max):\\n \\n \\n a = 2. #1.\\n tau = 1e-4\\n N = sum(i for i in self.N_tower_sites)\\n w = np.zeros(N)\\n ones = np.ones(N)\\n p = 1. #the exponents power when doing he exponent method:\\n \\n for i in xrange(self.N_reweighting_iterations_max):\\n #The concatenated vector of occupancies: Concatenated over all\\n #of the kinds of towers.\\n x = cvx.Variable(N)\\n \\n #Different objective functions depending on which optimization problem.\\n #These are defined in the scenarios in the main function.\\n if self.objective_type == 'min_entries':\\n operation = cvx.min_entries\\n elif self.objective_type == 'sum_entries':\\n operation = cvx.sum_entries\\n else:\\n raise Exception('must specify valid objective_type')\\n \\n #Objective function includes penalty term for non-binary x values\\n if self.penalty_type == 'reweighted_L1':\\n #objective = cvx.Maximize(t - x.T*w)\\n objective = cvx.Maximize(operation(C*x - x.T*w))\\n\\n\\n #Main constraints on 0<=x<=1\\n constraints = [0<=x, x<=1]\\n \\n \\n #And then for each kind of tower, append the constraint that there\\n #be exactly N_i towers, or <= quota (depending on constraint type)\\n if self.constraints__type == 'fixed_N_towers' or self.constraints__type == 'tower_quotas':\\n for tk in xrange(self.N_tower_kinds):\\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\\n print before_sum\\n print before_sum + self.N_tower_sites[tk]\\n if self.constraints__type == 'fixed_N_towers':\\n constraints.append(cvx.sum_entries(\\n x[before_sum : before_sum + self.N_tower_sites[tk]]\\n )==self.N_towers[tk])\\n elif self.constraints__type == 'tower_quotas':\\n constraints.append(cvx.sum_entries(\\n x[before_sum : before_sum + self.N_tower_sites[tk]]\\n )<=self.budget__tower_quotas[tk])\\n print x[before_sum : before_sum + self.N_tower_sites[tk]]\\n \\n elif self.constraints__type == 'total_cost':\\n costs = np.hstack([np.repeat(self.budget__tower_unit_costs[tk],self.N_tower_sites[tk]) for tk in xrange(self.N_tower_kinds)])\\n constraints.append(cvx.sum_entries(costs * x) <= self.budget__total_cost) \\n \\n \\n \\n\\n\\n \\n \\n print 'penalty_type', self.penalty_type\\n print 'objective_type', self.objective_type\\n print 'constraints__type', self.constraints__type\\n print 'budget__tower_quotas', self.budget__tower_quotas\\n print 'operation', operation\\n print 'objective', objective\\n print 'constraints', constraints\\n cvx.Problem(objective, constraints).solve(verbose=self.VERBOSE)\\n x = np.array(x.value).flatten()\\n print 'x', x\\n w = a/(tau+np.abs(x))\\n p += 1.\\n plt.figure(figsize=(5,5))\\n plt.plot(x,marker='o')\\n plt.savefig('histrograms_{}.png'.format(i))\\n print \\n \\n \\n \\n \\n #From the solution x, get the coordinates of those tower sites where we\\n #really do want to place a tower\\n #use = np.isclose(x,1.)\\n for tk in xrange(self.N_tower_kinds):\\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\\n y = x[before_sum : before_sum + self.N_tower_sites[tk]]\\n inds = np.argsort(y)\\n s = y[inds]\\n use = np.where(s>.5)[0]\\n print inds\\n print s\\n print use \\n if self.constraints__type == 'fixed_N_towers':\\n if len(use) != self.N_towers[tk]:\\n print 'Solution did not converge properly. Choosing the K best towers.'\\n print self.N_towers[tk], len(use)\\n # use = use[-self.N_towers[tk]:]\\n use = inds[-self.N_towers[tk]:]\\n elif self.constraints__type == 'tower_quotas':\\n pass #Just use the towers thresholded at > .5\\n print use\\n \\n \\n self.coordinates__solved_towers.append([self.coordinates__tower_sites[tk][mm] for mm in inds[use]])\",\n \"def start_solving(self):\\n self.mesh.output_vtk_mesh(self.model_name + \\\"0\\\", \\n [self.current_pressure, \\n self.mesh.get_cell_domain_all()], \\n [\\\"pressure\\\", \\\"domain\\\"])\\n\\n self.time_step_output(0., 0)\\n\\n for time_step in range(1,self.number_of_time_steps+1):\\n current_time = time_step*self.delta_t\\n print(time_step)\\n\\n self.update_pressure()\\n self.find_upwinding_direction()\\n self.update_concentration()\\n \\n if time_step%self.output_frequency == 0:\\n self.mesh.output_vtk_mesh(self.model_name+str(time_step), \\n [self.current_pressure,\\n self.current_concentration, \\n self.mesh.get_cell_domain_all()],\\n [\\\"pressure\\\", \\\"concentration\\\" , \\\"domain\\\"])\\n\\n self.time_step_output(current_time, time_step)\",\n \"def determine_analytic_solution(self):\\n\\n self._Janalytic = np.where(self.xr <= self.xint, self.S, 0.5 * self.S)\\n self._Hanalytic = np.where(self.xr <= self.xint, 0, 0.25 * self.S)\\n self._Kanalytic = np.where(self.xr <= self.xint, 1./3. * self.S,\\n 1./6. * self.S)\",\n \"def fit_recurrent(self, x, y):\\n # print('Stage 1')\\n x_ = self.scaler_s1.fit_transform(x)\\n\\n self.basemodel.fit(x_, y)\\n self.training_hit_probability = self._hitprobability(x_, y)\\n\\n # Learn the hit probability\\n self.hitproba = HitProbability()\\n self.hitproba.fit(x_, self.training_hit_probability)\\n\\n # Learn high confidence for all classes\\n hm_y, auto_gamma = self._adjust_gamma(self.training_hit_probability)\\n self.joint_class_hc = HC_LR()\\n self.joint_class_hc.fit(x_, hm_y)\\n\\n # hm_subtypes = []\\n # proba_subtypes = []\\n\\n # while np.mean(y_) > 0.01:\\n # for label in np.unique(y):\\n\\n hm_1hot = []\\n hm_1hot.append(self._one_hot(self.training_hit_probability, y)[0])\\n y_ = y.copy()\\n\\n self.recurrent_base = []\\n self.recurrent_hpc = []\\n for ii in range(self.recurrent_modes):\\n print('Stage 1 iter: ' + str(ii))\\n #self.recurrent_base.append(BaseSvc())\\n\\n if np.sum(y_) > 2:\\n self.basemodel = BaseSvc()\\n hm_y, proba_tmp = self._fit_mode(x_, y_)\\n hm_candidate = self._one_hot(proba_tmp, y_)[1]\\n else:\\n hm_candidate = np.zeros_like(y_)\\n\\n self.recurrent_base.append(self.basemodel)\\n\\n #if np.sum(hm_candidate) >= 2:\\n hm_1hot.append(hm_candidate)\\n\\n # remove the selected subgroup from the target list\\n y_[hm_1hot[-1] == 1] = 0\\n\\n # make the default base model the first\\n self.basemodel = self.recurrent_base[0]\\n\\n print('Stage 2')\\n # Stage 2\\n # hm_1hot = hm_subtypes\\n # train stage2\\n self.confidencemodel.fit(x_, hm_1hot)\",\n \"def recalibrate_start(self):\\n self.epoch += 1\\n self.initialize()\\n self.recalibration_i = 0\\n\\n if self.vr_from_epoch is not None and self.epoch >= self.vr_from_epoch:\\n for group in self.param_groups:\\n for p in group['params']:\\n param_state = self.state[p]\\n param_state['gavg'].zero_()\\n param_state['m2'].zero_()\\n\\n # xk is changed to the running_x\\n p.data.zero_().add_(param_state['running_x'])\\n param_state['tilde_x'] = p.data.clone()\",\n \"def solve(self):\\n measure = None\\n while not self.step():\\n self._nbSteps += 1\\n measure = self.measure(lastMeasure=measure)\",\n \"def solve_l1(y, A_fun, AT_fun, lambda_l1, reshape_img_fun, show_img_progress=False, alpha=0.2, max_iter=100, solver_tol=1e-6):\\n\\n\\n obj_lss = np.zeros(max_iter)\\n x_zs = np.zeros(max_iter)\\n u_norms = np.zeros(max_iter)\\n times = np.zeros(max_iter)\\n\\n ATy = AT_fun(y)\\n x_shape = ATy.shape\\n d = np.prod(x_shape)\\n\\n def A_cgs_fun(x):\\n x = np.reshape(x, x_shape, order='F')\\n y = AT_fun(A_fun(x)) + alpha * x\\n return vec(y)\\n A_cgs = LinearOperator((d,d), matvec=A_cgs_fun, dtype='float')\\n\\n def compute_p_inv_A(b, z0):\\n (z,info) = sp.sparse.linalg.cgs(A_cgs, vec(b), x0=vec(z0), tol=1e-3, maxiter=100)\\n if info > 0:\\n print('cgs convergence to tolerance not achieved')\\n elif info <0:\\n print('cgs gets illegal input or breakdown')\\n z = np.reshape(z, x_shape, order='F')\\n return z\\n\\n\\n def A_cgs_fun_init(x):\\n x = np.reshape(x, x_shape, order='F')\\n y = AT_fun(A_fun(x))\\n return vec(y)\\n A_cgs_init = LinearOperator((d,d), matvec=A_cgs_fun_init, dtype='float')\\n\\n def compute_init(b, z0):\\n (z,info) = sp.sparse.linalg.cgs(A_cgs_init, vec(b), x0=vec(z0), tol=1e-2)\\n if info > 0:\\n print('cgs convergence to tolerance not achieved')\\n elif info <0:\\n print('cgs gets illegal input or breakdown')\\n z = np.reshape(z, x_shape, order='F')\\n return z\\n\\n # initialize z and u\\n z = compute_init(ATy, ATy)\\n u = np.zeros(x_shape)\\n\\n\\n plot_normalozer = matplotlib.colors.Normalize(vmin=0.0, vmax=1.0, clip=True)\\n\\n\\n start_time = timeit.default_timer()\\n\\n for iter in range(max_iter):\\n\\n # x-update\\n net_input = z+u\\n Wzu, wbook = wavelet_transform(net_input)\\n q = soft_threshold(Wzu, lambda_l1/alpha)\\n x = inverse_wavelet_transform(q, wbook, x_shape)\\n x = np.reshape(x, x_shape)\\n\\n # z-update\\n b = ATy + alpha * (x - u)\\n z = compute_p_inv_A(b, z)\\n\\n # u-update\\n u += z - x;\\n\\n if show_img_progress == True:\\n\\n fig = plt.figure('current_sol')\\n plt.gcf().clear()\\n fig.canvas.set_window_title('iter %d' % iter)\\n plt.subplot(1,3,1)\\n plt.imshow(reshape_img_fun(np.clip(x, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\\n plt.title('x')\\n plt.subplot(1,3,2)\\n plt.imshow(reshape_img_fun(np.clip(z, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\\n plt.title('z')\\n plt.subplot(1,3,3)\\n plt.imshow(reshape_img_fun(np.clip(net_input, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\\n plt.title('netin')\\n plt.pause(0.00001)\\n\\n\\n obj_ls = 0.5 * np.sum(np.square(y - A_fun(x)))\\n x_z = np.sqrt(np.mean(np.square(x-z)))\\n u_norm = np.sqrt(np.mean(np.square(u)))\\n\\n print('iter = %d: obj_ls = %.3e |x-z| = %.3e u_norm = %.3e' % (iter, obj_ls, x_z, u_norm))\\n\\n\\n obj_lss[iter] = obj_ls\\n x_zs[iter] = x_z\\n u_norms[iter] = u_norm\\n times[iter] = timeit.default_timer() - start_time\\n\\n if x_z < solver_tol:\\n break\\n\\n infos = {'obj_lss': obj_lss, 'x_zs': x_zs, 'u_norms': u_norms,\\n 'times': times, 'alpha':alpha, 'lambda_l1':lambda_l1,\\n 'max_iter':max_iter, 'solver_tol':solver_tol}\\n\\n\\n return (x, z, u, infos)\",\n \"def calibrate(self):\\n\\t\\tLTOGRIGHT = []\\n\\t\\tLTOGUP = []\\n\\t\\tRTOGRIGHT = []\\n\\t\\tRTOGUP = []\\n\\t\\tstart = time.time()\\n\\t\\tcalibration_time = 5.0\\n\\t\\twhile time.time() - start < calibration_time:\\n\\t\\t\\tevents = pygame.event.get()\\n\\t\\t\\tfor event in events:\\n\\t\\t\\t\\tif event.type == pygame.JOYAXISMOTION:\\n\\t\\t\\t\\t\\tLTOGRIGHT.append(self.joystick.get_axis(self.LTOGRIGHT))\\n\\t\\t\\t\\t\\tLTOGUP.append(-self.joystick.get_axis(self.LTOGUP))\\n\\t\\t\\t\\t\\tRTOGRIGHT.append(self.joystick.get_axis(self.RTOGRIGHT))\\n\\t\\t\\t\\t\\tRTOGUP.append(-self.joystick.get_axis(self.RTOGUP))\\n\\n\\t\\t# calibration sets highest value equal to 1.0\\n\\t\\tself.calibration[0] = 1.0/max(LTOGRIGHT)\\n\\t\\tself.calibration[1] = -1.0/min(LTOGRIGHT)\\n\\t\\tself.calibration[2] = -1.0/min(LTOGUP)\\n\\t\\tself.calibration[3] = 1.0/max(LTOGUP)\\n\\t\\tself.calibration[4] = 1.0/max(RTOGRIGHT)\\n\\t\\tself.calibration[5] = -1.0/min(RTOGRIGHT)\\n\\t\\tself.calibration[6] = -1.0/min(RTOGUP)\\n\\t\\tself.calibration[7] = 1.0/max(RTOGUP)\",\n \"def generatelookup(num_probes = 16):\\n calibration_lookup= [[0] * 3 for i in range(num_probes)]\\n # print(calibration_lookup)\\n day = '050119r'\\n date = '050119'\\n\\n def _run_calib(shots, dir):\\n \\\"\\\"\\\" Helper function \\\"\\\"\\\"\\n for shot in shots:\\n shot = day+str(shot)\\n ratios = ratio_4_doc(shot, dir)\\n for i in range(num_probes):\\n calibration_lookup[i][dir] = calibration_lookup[i][dir] + ratios[i][dir]\\n if shot == shots[-1]: #on the last shot, divide by the number of shots\\n calibration_lookup[i][dir] = calibration_lookup[i][dir]/ len(shots)\\n\\n # shot = day+str(13)\\n # ratios = ratio_4_doc(shot, 2)\\n # time,eastcurrent,westcurrent = loadcurrent(shot)#u\\n # plt.plot(time, eastcurrent, label = 'current')\\n #\\n # plt.show()\\n # print(\\\"And the max current is %f\\\" %polyPeak_noPlot(time,eastcurrent))\\n # #check if cm or m\\n # r = get_probeLocs_calib_setup(shot)\\n # print(\\\"r is:\\\", r[1])\\n # print(ratios)\\n #\\n #\\n # X - direction\\n print(\\\"Generating X - dir\\\")\\n shots = np.arange(17,21)\\n _run_calib(shots, 0)\\n\\n\\n # Y - direction\\n print(\\\"Generating Y - dir\\\")\\n shots = np.arange(21,26)\\n _run_calib(shots, 1)\\n\\n print(\\\"Generating Z - dir\\\")\\n # Z - direction\\n shots = np.arange(11,16)\\n _run_calib(shots, 2)\\n\\n\\n pth = os.getcwd()\\n print(\\\"Finished! File saved as calib-%s-4x4_lookup_5.txt in cwd\\\" %(date))\\n savetxt(os.path.join(pth, 'calib-%s-4x4_lookup_5.txt' % (date)) , calibration_lookup)\",\n \"def _redef_sp1_vars(self):\\r\\n\\r\\n if len(self.fq_list) == 0:\\r\\n no_rad = True\\r\\n lst_tmp = np.matrix(np.reshape(self.lst_tmp, \\r\\n (self.lst_tmp.size, 1)))\\r\\n else: no_rad = False\\r\\n # The practically constants...\\r\\n # Big Epsilon:\\r\\n if self.cond == True:\\r\\n self.Epsilon = self.d_T * self.thermal_conductivity\\r\\n else:\\r\\n self.Epsilon = (self.diff_scale ** 2) / \\\\\\r\\n (3.0 * self.absorb_coeffs[self.rad] ** 2)\\r\\n # Beta:\\r\\n if self.cond == True:\\r\\n self.Beta = (self.diff_scale * self.thermal_conductivity) / \\\\\\r\\n (self.convect_coeff)\\r\\n else:\\r\\n self.Beta = (1.0 + 3.0 * self.r2) * (2.0 * self.diff_scale) / \\\\\\r\\n ((1.0 - 2.0 * self.r1) * (\\r\\n 3.0 * self.absorb_coeffs[self.rad]))\\r\\n\\r\\n # The feild solutions at the last timestep.\\r\\n # The integral vF:\\r\\n if self.cond == True:\\r\\n # The horrifically complicated F:\\r\\n def F_func_cond(elem, eta):\\r\\n F = 0.0\\r\\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n F += Tn\\r\\n for k in range(0, len(self.fq_list)):\\r\\n vk = self.fq_list[k]\\r\\n try:\\r\\n vk_m = self.fq_list[k - 1]\\r\\n except:\\r\\n vk_m = self.v0_frequency\\r\\n absorbtion = self.absorb_coeffs[k]\\r\\n phi = elem.eval_elem(self.node_map, self.lst_rad[k],\\r\\n [eta])[0]\\r\\n inter1 = phi - 4.0 * sconst.pi * \\\\\\r\\n self.B_int_function(Tn, self.refr_idx_vol,\\r\\n vk, vk_m)\\r\\n inter2 = absorbtion * self.d_T / (self.diff_scale ** 2)\\r\\n F += inter2 * inter1\\r\\n return elem.funcs(eta) * F\\r\\n if not no_rad:\\r\\n # We're integrating something non-linear for SP1\\r\\n self.vF_vect_vol = et.elems_2_array(self.mesh,\\r\\n F_func_cond,\\r\\n self.node_map)\\r\\n else:\\r\\n # Or something easier if we're only looking at heat.\\r\\n self.vF_vect_vol = np.array(self.uv_vol * lst_tmp).reshape(-1)\\r\\n else:\\r\\n def F_func_radiative(elem, eta):\\r\\n T = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n vk = self.fq_list[self.rad]\\r\\n try:\\r\\n vk_minus = self.fq_list[self.rad - 1]\\r\\n except:\\r\\n vk_minus = self.v0_frequency\\r\\n n = self.refr_idx_vol\\r\\n F = 4.0 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\\r\\n return elem.funcs(eta) * F\\r\\n\\r\\n self.vF_vect_vol = et.elems_2_array(self.mesh,\\r\\n F_func_radiative,\\r\\n self.node_map)\\r\\n # The path integral vf:\\r\\n if self.cond == True:\\r\\n def f_func_cond(elem, eta):\\r\\n Tb = self.background_temperature\\r\\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n n = self.refr_idx_background\\r\\n vk = self.v0_frequency\\r\\n vk_minus = 0\\r\\n Bb0 = self.B_int_function(Tb, n, vk, vk_minus)\\r\\n Bn0 = self.B_int_function(Tn, n, vk, vk_minus)\\r\\n B_coeff = (self.alpha * sconst.pi) / self.convect_coeff\\r\\n f = Tb + B_coeff * (Bb0 - Bn0)\\r\\n return elem.funcs(eta) * f\\r\\n if not no_rad:\\r\\n self.vf_vect_bound = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n f_func_cond,\\r\\n self.node_map)\\r\\n else:\\r\\n try:\\r\\n self.vf_vect_bound = self.cache_tb_integral_array\\r\\n except AttributeError:\\r\\n def elem_functor(elem, eta): return elem.funcs(eta)\\r\\n self.cache_tb_integral_array = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n elem_functor,\\r\\n self.node_map)\\r\\n self.cache_tb_integral_array *= self.background_temperature\\r\\n self.vf_vect_bound = self.cache_tb_integral_array\\r\\n \\r\\n else:\\r\\n # Radiation f = 4*pi*B^{(k)}(T_b, n_g)\\r\\n def f_func_radiative(elem, eta):\\r\\n T = self.background_temperature\\r\\n vk = self.fq_list[self.rad]\\r\\n try:\\r\\n vk_minus = self.fq_list[self.rad - 1]\\r\\n except:\\r\\n vk_minus = self.v0_frequency\\r\\n n = self.refr_idx_vol\\r\\n f = 4 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\\r\\n return elem.funcs(eta) * f\\r\\n\\r\\n self.vf_vect_bound = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n f_func_radiative,\\r\\n self.node_map)\\r\\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\\r\\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\\r\\n assert (self.vf_vect_bound.shape[0] == \\\\\\r\\n self.vF_vect_vol.shape[0])\",\n \"def new_iteration(self):\\n if (\\n self.inner_solutions is not None\\n and self.inner_solutions.size(0) > self.raw_samples\\n ):\\n indices = torch.randperm(n=self.inner_solutions.size(0))[: self.raw_samples]\\n self.inner_solutions = self.inner_solutions[indices]\\n self.inner_values = self.inner_values[indices]\",\n \"def solve_VFI(self):\\r\\n dimC = self.dimA ; dimA = self.dimA ; dimW = self.dimW \\r\\n C = self.c_grid ; A = self.a_grid ; W = self.W_grid\\r\\n tol = self.tol ; Niter = self.Niter ; R = self.R\\r\\n beta = self.beta ; Pi = self.Pi\\r\\n \\r\\n V0 = np.zeros((dimA,dimC,dimW))\\r\\n V1 = np.zeros((dimA,dimC,dimW))\\r\\n Pol = np.zeros((dimA,dimC,dimW))\\r\\n U = np.zeros((dimA,dimC,dimW))\\r\\n \\r\\n t0 = time()\\r\\n diff = 1 ; niter = 0\\r\\n \\r\\n while diff > tol:\\r\\n niter += 1\\r\\n # Value update step\\r\\n for ia in range(dimA):\\r\\n for ic in range(dimC):\\r\\n for iw in range(dimW):\\r\\n c = W[iw] + R*A[ia] - A\\r\\n x = C[ic]\\r\\n \\r\\n c[c < 0] = np.nan \\r\\n if x < 0:\\r\\n x = np.nan\\r\\n \\r\\n u = self.u(c,x) \\r\\n U[:,ic,iw] = u \\r\\n \\r\\n Objective = U + beta * V0 @ Pi.T\\r\\n V1[ia,:,:] = np.nanmax(Objective, axis = 0)\\r\\n Pol[ia,:,:] = np.nanargmax(Objective, axis = 0)\\r\\n \\r\\n # Evaluate distance between the value functions\\r\\n diff = np.max(np.max(np.abs(V1 - V0))) \\r\\n V0[:] = V1\\r\\n \\r\\n # Break the while loop if too many iterations\\r\\n #print(\\\"The current error is \\\"+str(diff))\\r\\n if niter > Niter:\\r\\n print('Ops, no convergence')\\r\\n break\\r\\n \\r\\n t1 = time()\\r\\n #print('VFI algorithm took {0:0d} iterations and {1:.2f} seconds.'.format(niter, t1 - t0))\\r\\n \\r\\n self.V1 = V1 ; self.Pol = Pol\",\n \"def solve(self):\\n max_iter = 1000\\n iter_count = 0\\n yhat = self.predict()\\n loss = self.cross_entropy(yhat)\\n gradloss = self.cross_entropy_gradient(yhat)\\n while la.norm(gradloss) > 1e-6 and iter_count < max_iter:\\n alpha = 1.0\\n slope = la.norm(gradloss)**2\\n beta_new = self.beta + alpha * gradloss\\n yhat = self.predict(beta=beta_new)\\n loss_new = self.cross_entropy(yhat)\\n while loss_new < loss + 1e-4 * alpha * slope:\\n alpha = alpha / 2\\n beta_new = self.beta + alpha * gradloss\\n yhat = self.predict(beta=beta_new)\\n loss_new = self.cross_entropy(yhat)\\n self.beta = beta_new\\n loss = loss_new\\n gradloss = self.cross_entropy_gradient(yhat)\\n iter_count += 1\",\n \"def initial_guess(self):\\n\\n x0 = [self.material_model.isotropic_matrix.c1, self.material_model.isotropic_matrix.c2]\\n\\n if not self.material_model.is_isotropic:\\n # c5 is scaled in the optimisation function\\n x0.append(self.material_model.fibres.c5 / c5_factor)\\n\\n if self.include_lm:\\n x0.append(self.material_model.fibres.lm)\\n\\n return np.asarray(x0)\",\n \"def GenerateInitialSolution():\\n c = random.random()*C\\n count = 0\\n while np.count_nonzero(alpha) < gamma:\\n rand = random.randint(0, len(x_train)-1)\\n if y_train[rand] == 1:\\n alpha[rand] = c\\n L[rand, 1] = c\\n # L[count, 0] = rand\\n # L[count, 1] = alpha[rand]\\n SVs[count] = rand\\n count += 1\\n while np.count_nonzero(alpha) < 2*gamma:\\n rand = random.randint(0, len(x_train)-1)\\n if y_train[rand] == -1:\\n alpha[rand] = c\\n L[rand, 1] = c\\n # L[count, 0] = rand\\n # L[count, 1] = alpha[rand]\\n SVs[count] = rand\\n count += 1\\n return alpha\",\n \"def _solve(self) -> CasADiArrayType:\\n solver_input = {\\\"x0\\\": self.x0, \\\"p\\\": self.p}\\n if self.opt_type in CONSTRAINED_OPT:\\n solver_input[\\\"lbg\\\"] = self._lbg\\n solver_input[\\\"ubg\\\"] = self._ubg\\n self._solution = self._solver(**solver_input)\\n self._stats = self._solver.stats()\\n self._stats[\\\"solution\\\"] = self._solution\\n return self._solution[\\\"x\\\"]\",\n \"def run_algorithm(self):\\n population_size = self.population_size\\n simulator = self.simulator\\n num_generations = self.num_generations\\n current_dir = os.getcwd()\\n urdf = current_dir + os.sep + os.path.join(\\\"URDF\\\", \\\"Ghost\\\", \\\"urdf\\\", \\\"Ghost.urdf\\\")\\n simulated_robot = Robot(urdf, (0, 0, 0.4))\\n simulated_robot.set_id(simulator.load_new_robot_urdf(simulated_robot))\\n # make placeholders\\n counter = 0\\n best_genome = None\\n best_fit = 0\\n evals = population_size * (num_generations + 1)\\n beam_fit = np.zeros(evals)\\n current_population = self.make_population()\\n current_population_fitness = [0] * self.population_size\\n # print(\\\"build robots\\\")\\n for k in range(self.population_size):\\n #\\tprint(\\\"initial robot \\\" , k)\\n robot = current_population[k]\\n simulator.load_robot_parameters(robot.parameters, 0)\\n robot.set_fitness(simulator.compute_walk_fitness(1000)[0]) # evaluate the robot's fitness\\n fitness = robot.get_fitness()\\n current_population_fitness[k] = fitness\\n \\n if counter == 0:\\n beam_fit[counter] = current_population_fitness[k] \\n else:\\n \\n if beam_fit[counter - 1] < current_population_fitness[k]: # if the best overall robot thus far\\n best_genome = robot.genome.copy() # update the best robot's genome\\n beam_fit[counter] = current_population_fitness[k] \\n else:\\n beam_fit[counter] = beam_fit[counter - 1]\\n best_fit = beam_fit[counter]\\n\\n counter +=1 \\n\\n\\n #\\tprint(\\\"origional robots evaluated, their fitness is \\\" , )\\n for i in range(num_generations): # perform mutations equal to num_Climb\\n #\\t\\t\\tprint(\\\"start of gen , current population_fitness\\\" , current_population_fitness)\\n population = current_population.copy()\\n population_fitness = current_population_fitness.copy()\\n print('gen' , i)\\n for j in range(self.population_size):\\n robot = population[j]\\n mut_loc, old_val = robot.mutate_genome() # Mutation: Keep track of mut location and previous vals\\n simulator.load_robot_parameters(robot.parameters, 0)\\n robot.set_fitness(simulator.compute_walk_fitness(1000)[0]) # evaluate the robot's fitness\\n fit_new = robot.get_fitness()\\n population_fitness[j] = fit_new\\n # BIG POINT - here we keep regardless if the change is better or not\\n if fit_new > best_fit: # update learning curve\\n best_fit = fit_new\\n best_genome = robot.genome.copy()\\n beam_fit[counter] = best_fit\\n counter += 1\\n #\\t\\t\\tprint(\\\" ... \\\")\\n #\\t\\t\\tprint(\\\"end of gen , current population_fitness\\\" , current_population_fitness)\\n # concat the populations and population fitnesses\\n total_population = current_population + population\\n total_population_fitness = current_population_fitness + population_fitness\\n # print(\\\"before quick sort \\\" , total_population_fitness)\\n # print(\\\" ... \\\")\\n # sort the lists\\n self.quick_sort(total_population_fitness, total_population, 0, len(total_population) - 1)\\n # print(\\\" after quick sort \\\" , total_population_fitness)\\n # print(\\\" ... \\\")\\n # keep the top half\\n current_population = total_population[:self.population_size]\\n current_population_fitness = total_population_fitness[:self.population_size]\\n # print(\\\"keep \\\", current_population_fitness)\\n #\\t\\tprint(counter)\\n\\n if not os.path.exists('./data'):\\n os.mkdir('./data')\\n\\n np.savetxt(\\\"beam_genome_gen_999_pop_100.csv\\\", best_genome, delimiter=\\\",\\\")\\n np.savetxt(\\\"beam_learning_gen_999_pop_100.csv\\\", beam_fit, delimiter=\\\",\\\")\",\n \"def evaltr(x_solution): \\n \\n large = 10.0**30\\n pred = np.zeros(cfg.ntrain)\\n e0 = 0.0 # mean of observed values\\n y=0.0\\n for i in range(cfg.ntrain): # Computation of correct piece\\n e0 += cfg.a_unscaled[i][-1]\\n pind = 0\\n ipbest = 0\\n pbest = -large # for max\\n \\n for j1 in range(cfg.nomax):\\n ipmin=pind\\n pmin=large # for min\\n for _ in range(cfg.jk[j1]):\\n piece=x_solution[(pind+1)*cfg.nfea-1] \\n for j3 in range(cfg.nfea-1): #\\n piece += x_solution[pind*cfg.nfea+j3]*cfg.a_unscaled[i][j3]\\n if piece < pmin:\\n ipmin = pind\\n pmin = piece\\n pind += 1 \\n \\n if pmin > pbest:\\n ipbest = ipmin\\n pbest = pmin\\n \\n pred[i] = x_solution[(ipbest+1)*cfg.nfea-1] # Computation of prediction\\n for j1 in range(cfg.nfea-1):\\n pred[i] += x_solution[ipbest*cfg.nfea+j1]*cfg.a_unscaled[i][j1]\\n y += pred[i]\\n \\n y = y/cfg.ntrain \\n e0 = e0/cfg.ntrain\\n \\n # Computation of indices\\n rmse = 0.0\\n mae = 0.0\\n e1 = 0.0\\n for i in range(cfg.ntrain):\\n rmse += (pred[i]-cfg.a_unscaled[i][-1])**2\\n mae += np.abs(pred[i]-cfg.a_unscaled[i][-1]) \\n e1 += (cfg.a_unscaled[i][-1] - e0)**2\\n ce = 1.0 - rmse/e1 \\n rmse = np.sqrt(rmse/cfg.ntrain)\\n mae = mae/cfg.ntrain \\n\\n if cfg.ntrain > 1:\\n sx=0.0\\n sy=0.0\\n rcor=0.0\\n for i in range(cfg.ntrain):\\n sx += (pred[i]-y)**2\\n sy += (cfg.a_unscaled[i][-1]-e0)**2 \\n rcor += (pred[i]-y) * (cfg.a_unscaled[i][-1]-e0) \\n\\n r = rcor/np.sqrt(sx*sy)\\n \\n return rmse,mae,ce,r\",\n \"def _ica_def(X, tol, g, fun_args, max_iter, w_init):\\n\\n n_components = w_init.shape[0]\\n W = np.zeros((n_components, n_components), dtype=X.dtype)\\n n_iter = []\\n\\n # j is the index of the extracted component\\n for j in range(n_components):\\n w = w_init[j, :].copy()\\n w /= np.sqrt((w**2).sum())\\n\\n for i in range(max_iter):\\n gwtx, g_wtx = g(np.dot(w.T, X), fun_args)\\n\\n w1 = (X * gwtx).mean(axis=1) - g_wtx.mean() * w\\n\\n _gs_decorrelation(w1, W, j)\\n\\n w1 /= np.sqrt((w1**2).sum())\\n\\n lim = np.abs(np.abs((w1 * w).sum()) - 1)\\n w = w1\\n if lim < tol:\\n break\\n\\n n_iter.append(i + 1)\\n W[j, :] = w\\n\\n return W, max(n_iter)\",\n \"def solve_model(self): \\n \\n t0 = time.time() #start the clock\\n \\n # a. benchmark case\\n \\n #i. joint pdf of productivity state and tau \\n self.make_joint_pdf(1)\\n \\n #ii. set policy. in RR08 the benchmark economy has no taxes nor subsidies\\n self.tau_benchmark = np.array([0, 0, 0]) #subsidy rate, excempt rate, tax rate \\n self.set_tax_system(self.tau_benchmark) #set tax system\\n \\n #iii. benchmark equilibrium\\n self.Yss_b, self.Kss_b, self.TFPss_b, self.average_firm_size_b, self.E_star_b, _, \\\\\\n _, self.N_ss_b, self.w_ss_b, self.cdf_stationary_b, self.cdf_emp_b = self.solve_stationary_equilibrium()\\n \\n print(\\\"\\\\n-----------------------------------------\\\")\\n print(\\\"Benchmark Stationary Equilibrium\\\")\\n print(\\\"-----------------------------------------\\\")\\n print(f\\\"ss output = {self.Yss_b:.2f}\\\")\\n print(f\\\"ss capital = {self.Kss_b:.2f}\\\")\\n print(f\\\"ss tfp = {self.TFPss_b:.2f}\\\")\\n print(f\\\"ss wage = {self.w_ss_b:.2f}\\\")\\n print(f\\\"entry mass = {self.E_star_b:.3f}\\\")\\n print(f\\\"avg. firm size = {self.average_firm_size_b:.2f}\\\")\\n \\n #b. plot (note that the distributions plotted here are unaffected by the distortionary policies)\\n \\n if self.plott:\\n #i. initialize\\n employed = [4.99, 49.99]\\n firm_size_by_employee = np.zeros(len(employed)+1)\\n share_employment = np.zeros(len(employed)+1)\\n \\n \\n #i. percentage of firms that employ employed\\n \\n for i_e in range(len(employed)):\\n summ = np.sum(firm_size_by_employee)\\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_stationary_b, employed[i_e])[0] #labor_demand_rel is labor demand with the lowest value normalized to 1\\n firm_size_by_employee[i_e] = interpolate - summ\\n firm_size_by_employee[-1] = 1 - np.sum(firm_size_by_employee)\\n \\n plt.pie(firm_size_by_employee, labels=['<5','5<50','50 =<'], autopct=\\\"%.1f%%\\\")\\n plt.title('Size of Firms by Firm Size (Number of Employees)')\\n plt.savefig('firm_size_rr08.pdf')\\n plt.show()\\n \\n \\n #ii. employment percentage by firm size\\n for i_e in range(len(employed)):\\n summ = np.sum(share_employment)\\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_emp_b , employed[i_e])[0]\\n share_employment[i_e] = interpolate - summ\\n share_employment[-1] = 1 - np.sum(share_employment)\\n \\n plt.pie(share_employment, labels=['<5','5<50','50 =<'], autopct=\\\"%.1f%%\\\")\\n plt.title('Employment Share by Firm Size (Number of Employees)')\\n plt.savefig('employment_by_firm_size_rr08.pdf')\\n plt.show()\\n \\n #iii. productivity cdf and employment cdf\\n plt.plot(self.grid_s, self.cdf_stationary_b)\\n plt.plot(self.grid_s, self.cdf_emp_b)\\n plt.title('Stationary CDF' )\\n plt.xlabel('Productivity level')\\n plt.ylabel('Cumulative Sum')\\n plt.legend(['Firms by Productivity Level','Share of Employment'])\\n plt.savefig('cdf_rr08.pdf')\\n plt.show()\\n \\n \\n \\n #c. distortion case\\n \\n #i. joint pdf of productivity state and tau \\n self.make_joint_pdf(0)\\n \\n #ii. compute stationary economy for each tau\\n \\n for idx, tau in enumerate(self.tau_vector):\\n \\n #iii. find the subsidy rate that generates the same capital stock as in benchmark economy\\n self.tau_s[idx] = self.find_subsidy_rate(tau)\\n \\n # set tax system with newly found tau_s and given tau\\n tauv = np.array([-self.tau_s[idx], self.excempt_frac, tau]) #subsidy rate, excempt rate, tax rate \\n self.set_tax_system(tauv) #set tax system\\n \\n #v. distorted stationary equilibrium\\n self.Yss_d[idx], self.Kss_d[idx], self.TFPss_d[idx], self.average_firm_size_d[idx], self.E_star_d[idx], \\\\\\n self.Y_set_d[idx,:], self.subsidy_size_d[idx], self.N_ss_d[idx], self.w_ss_d[idx],\\\\\\n _, _ = self.solve_stationary_equilibrium()\\n \\n print(\\\"\\\\n-----------------------------------------\\\")\\n print(\\\"Distorted Stationary Equilibrium\\\")\\n print(\\\"-----------------------------------------\\\\n\\\")\\n if self.distortion_case == 1:\\n print(\\\"Tax/Subidy Uncorrelated with Firm Level Producitivity\\\\n\\\")\\n elif self.distortion_case == 2:\\n print(\\\"Tax/Subidy Negatively Correlated with Firm Level Producitivity\\\")\\n print(\\\"(low productivity firms recieve subsidy, high productivity taxed)\\\\n\\\")\\n elif self.distortion_case == 2:\\n print(\\\"Tax/Subidy Positively Correlated with Firm Level Producitivity\\\")\\n print(\\\"(high productivity firms recieve subsidy, low productivity taxed)\\\\n\\\")\\n if self.policy_type == 1 :\\n print(\\\"Tax Type: Tax on output\\\\n\\\")\\n elif self.policy_type == 2 :\\n print(\\\"Tax Type: Tax on capital\\\\n\\\")\\n elif self.policy_type == 3 :\\n print(\\\"Tax Type: Tax on labor\\\\n\\\")\\n print(f\\\"fraction of firms recieving subsidy = {self.subsidy_frac:.2f}\\\")\\n print(f\\\"fraction of firms taxed = {1-self.subsidy_frac-self.excempt_frac:.2f}\\\")\\n print(f\\\"fraction of firms excempt = {self.excempt_frac:.2f}\\\")\\n print(\\\"-----------------------------------------\\\\n\\\")\\n \\n print(tabulate([['relative Yss', round(self.Yss_d[0]/self.Yss_b, 2), round(self.Yss_d[1]/self.Yss_b, 2), round(self.Yss_d[2]/self.Yss_b, 2), round(self.Yss_d[3]/self.Yss_b, 2)],\\n ['relative TFPss', round(self.TFPss_d[0]/self.TFPss_b, 2), round(self.TFPss_d[1]/self.TFPss_b, 2), round(self.TFPss_d[2]/self.TFPss_b, 2), round(self.TFPss_d[3]/self.TFPss_b, 2)], \\n ['relative entry mass', round(self.E_star_d[0]/self.E_star_b, 2), round(self.E_star_d[1]/self.E_star_b, 2), round(self.E_star_d[2]/self.E_star_b, 2), round(self.E_star_d[3]/self.E_star_b, 2)],\\n ['share of subsidized output', round(self.Y_set_d[0,0], 2), round(self.Y_set_d[1,0], 2), round(self.Y_set_d[2,0], 2), round(self.Y_set_d[3,0], 2)],\\n ['total subsidy paid of output', round(self.subsidy_size_d[0], 2), round(self.subsidy_size_d[1], 2), round(self.subsidy_size_d[2], 2), round(self.subsidy_size_d[3], 2)],\\n ['subsidy rate (tau_s)', round(self.tau_s[0], 2), round(self.tau_s[1], 2), round(self.tau_s[2], 2), round(self.tau_s[3], 2)],\\n [], \\n ['relative Kss', round(self.Kss_d[0]/self.Kss_b, 2), round(self.Kss_d[1]/self.Kss_b, 2), round(self.Kss_d[2]/self.Kss_b, 2), round(self.Kss_d[3]/self.Kss_b, 2)], \\n ['relative wss', round(self.w_ss_d[0]/self.w_ss_b, 2), round(self.w_ss_d[1]/self.w_ss_b, 2), round(self.w_ss_d[2]/self.w_ss_b, 2), round(self.w_ss_d[3]/self.w_ss_b, 2)], \\n ['relative Nss', round(self.N_ss_d[0]/self.N_ss_b, 2), round(self.N_ss_d[1]/self.N_ss_b, 2), round(self.N_ss_d[2]/self.N_ss_b, 2), round(self.N_ss_d[3]/self.N_ss_b, 2)], \\n ['relative avg. firm size', round(self.average_firm_size_d[0]/self.average_firm_size_b, 2), round(self.average_firm_size_d[1]/self.average_firm_size_b, 2), round(self.average_firm_size_d[2]/self.average_firm_size_b, 2), round(self.average_firm_size_d[3]/self.average_firm_size_b, 2)]],\\n headers=['Variable', 'Tax = '+str(self.tau_vector[0]), \\\"Tax = \\\"+str(self.tau_vector[1]), 'Tax = '+str(self.tau_vector[2]), 'Tax = '+str(self.tau_vector[3])]))\\n \\n\\n t1 = time.time()\\n print(f'\\\\nTotal Run Time: {t1-t0:.2f} seconds')\",\n \"def _RunCalibration(self, graph_key, gdef, input_data, config):\\n return self._RunGraph(graph_key, gdef, input_data, config, 30)\",\n \"def get_Objective(self):\\r\\n \\r\\n ans = 0\\r\\n for i in range(len(self.X.shape)):\\r\\n ans += self.parameter['phi'][i] * self.parameter['lambda1'] *norm(tl.unfold(self.Wlist[i], i), 'nuc') + (1 / self.parameter['m']) * norm(tl.unfold(self.X - self.Wlist[i] - self.V, i))\\r\\n\\r\\n # Augmented part is calculated seperately. \\r\\n augment_part1 = 0.5 * self.parameter['rho1'] * norm(self.V - self.T + self.F1)\\r\\n augment_part2 = 0.5 * self.parameter['rho2'] * norm(tl.fold(np.dot(self.Dmatrix, tl.unfold(self.T, 0)), 0, self.T.shape) - self.S + self.F2)\\r\\n\\r\\n # Combine the result for final objective function\\r\\n ans += self.parameter['beta1'] * norm(self.V.reshape(self.totaldim), 1) + self.parameter['beta2'] * norm(self.S.reshape(self.totaldim), 1) + augment_part1 + augment_part2 \\r\\n return ans\",\n \"def IterateValues(self):\\n agrid = self.agrid\\n self.w = self.setwage(self.K, self.N)\\n self.r = self.setrate(self.K, self.N)\\n self.b = self.benefit(self.N)\\n\\n for l in range(self.Na): \\n self.c[-1][l] = agrid[l]*(1+self.r) + self.b\\n self.v[-1][l] = self.util(self.c[-1][l],0)\\n self.vtilde[-1] = interp1d(agrid,self.v[-1], kind='cubic')\\n\\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\\n m0 = 0 \\n for l in range(self.Na):\\n # Find a bracket within which optimal a' lies\\n m = max(0, m0-1)\\n m0, a, b, c = self.GetBracket(y, l, m, agrid)\\n # Define objective function for optimal a'\\n def objfn(a1):\\n v = self.value(y, agrid[l], a1)\\n return -v\\n # Find optimal a' using Golden Section Search\\n if a == b:\\n self.a[y][l] = 0\\n elif b == c:\\n self.a[y][l] = agrid[-1]\\n else:\\n result = minimize_scalar(objfn, bracket=(a,b,c), method='Golden')\\n #‘Brent’,‘Bounded’,‘Golden’\\n self.a[y][l] = result.x\\n # Computing consumption and labor\\n if y >= -self.R:\\n self.c[y][l], self.n[y][l] = (1+self.r)*agrid[l] + self.b - self.a[y][l], 0\\n else:\\n self.c[y][l], self.n[y][l] = self.solve(agrid[l], self.a[y][l])\\n self.v[y][l] = self.util(self.c[y][l],self.n[y][l]) + self.beta*self.vtilde[y+1](self.a[y][l])\\n self.vtilde[y] = interp1d(agrid, self.v[y], kind='cubic')\",\n \"def determine_analytic_solution(self):\\n\\n solver = analytic_solution_homogeneous_sphere(S=self.S,\\n chi=self.chi_base,\\n R=self.xint)\\n\\n r = 0.5 * (self.xl + self.xr)\\n\\n Janalytic = []\\n Hanalytic = []\\n Kanalytic = []\\n\\n for ri in r:\\n Janalytic.append(solver.J(ri))\\n Hanalytic.append(solver.H(ri))\\n Kanalytic.append(solver.K(ri))\\n\\n self._Janalytic = np.array(Janalytic)\\n self._Hanalytic = np.array(Hanalytic)\\n self._Kanalytic = np.array(Kanalytic)\",\n \"def get_solution(self):\\n return self._generate_solution()\",\n \"def prob_calibration_function(truthvec, scorevec, reg_param_vec='default', knots='sample',\\n method='logistic', force_prob=True, eps=1e-15, max_knots=200,\\n transform_fn='none', random_state=942, verbose=False, cv_folds=5,\\n unity_prior_weight=1, unity_prior_gridsize=20):\\n from sklearn import linear_model\\n from sklearn.metrics import log_loss, make_scorer\\n\\n if (unity_prior_weight>0):\\n scorevec_coda, truthvec_coda = create_yeqx_bias_vectors(unity_prior_gridsize)\\n coda_wt = unity_prior_weight/unity_prior_gridsize\\n weightvec = np.concatenate((np.ones(len(scorevec)), coda_wt * np.ones(len(scorevec_coda))))\\n scorevec = np.concatenate((scorevec, scorevec_coda))\\n truthvec = np.concatenate((truthvec, truthvec_coda))\\n\\n if transform_fn != 'none':\\n scorevec = transform_fn(scorevec)\\n\\n knot_vec = np.unique(scorevec)\\n if (knots == 'sample'):\\n num_unique = len(knot_vec)\\n if (num_unique > max_knots):\\n smallest_knot, biggest_knot = knot_vec[0], knot_vec[-1]\\n inter_knot_vec = knot_vec[1:-1]\\n random.seed(random_state)\\n random.shuffle(inter_knot_vec)\\n reduced_knot_vec = inter_knot_vec[:(max_knots-2)]\\n reduced_knot_vec = np.concatenate((reduced_knot_vec, [smallest_knot, biggest_knot]))\\n reduced_knot_vec = np.concatenate((reduced_knot_vec, np.linspace(0, 1, 21)))\\n if (unity_prior_weight>0):\\n reduced_knot_vec = np.concatenate((reduced_knot_vec, scorevec_coda))\\n knot_vec = np.unique(reduced_knot_vec)\\n if verbose:\\n print(\\\"Originally there were {} knots. Reducing to {} while preserving first and last knot.\\\".format(num_unique, len(knot_vec)))\\n X_mat = _natural_cubic_spline_basis_expansion(scorevec, knot_vec)\\n\\n if (method == 'logistic'):\\n if ((type(reg_param_vec) == str) and (reg_param_vec == 'default')):\\n reg_param_vec = 10**np.linspace(-7, 5, 61)\\n if verbose:\\n print(\\\"Trying {} values of C between {} and {}\\\".format(len(reg_param_vec), np.min(reg_param_vec), np.max(reg_param_vec)))\\n reg = linear_model.LogisticRegressionCV(Cs=reg_param_vec, cv=StratifiedKFold(cv_folds, shuffle=True),\\n scoring=make_scorer(log_loss, needs_proba=True, greater_is_better=False))\\n if (unity_prior_weight>0):\\n reg.fit(X_mat, truthvec, weightvec)\\n else:\\n reg.fit(X_mat, truthvec)\\n if verbose:\\n print(\\\"Best value found C = {}\\\".format(reg.C_))\\n\\n if (method == 'ridge'):\\n if ((type(reg_param_vec) == str) and (reg_param_vec == 'default')):\\n reg_param_vec = 10**np.linspace(-7, 7, 71)\\n if verbose:\\n print(\\\"Trying {} values of alpha between {} and {}\\\".format(len(reg_param_vec), np.min(reg_param_vec),np.max(reg_param_vec)))\\n reg = linear_model.RidgeCV(alphas=reg_param_vec, cv=KFold(cv_folds, shuffle=True), scoring=make_scorer(mean_squared_error_trunc,needs_proba=False, greater_is_better=False))\\n reg.fit(X_mat, truthvec)\\n if verbose:\\n print(\\\"Best value found alpha = {}\\\".format(reg.alpha_))\\n\\n def calibrate_scores(new_scores):\\n new_scores = np.maximum(new_scores,knot_vec[0]*np.ones(len(new_scores)))\\n new_scores = np.minimum(new_scores,knot_vec[-1]*np.ones(len(new_scores)))\\n if transform_fn != 'none':\\n new_scores = transform_fn(new_scores)\\n basis_exp = _natural_cubic_spline_basis_expansion(new_scores,knot_vec)\\n if (method == 'logistic'):\\n outvec = reg.predict_proba(basis_exp)[:,1]\\n if (method == 'ridge'):\\n outvec = reg.predict(basis_exp)\\n if force_prob:\\n outvec = np.where(outvec < eps, eps, outvec)\\n outvec = np.where(outvec > 1-eps, 1-eps, outvec)\\n return outvec\\n\\n return calibrate_scores\",\n \"def solve(self):\\n ...\",\n \"def reconstruct_solution(spikes,sol,uval,twin,ics,tau,variable,**kwargs):\\n\\n # Model parameters\\n pars = {'dt' : 1e-3}\\n pars = gu.varargin(pars,**kwargs)\\n\\n # Generate time vector\\n time = np.arange(twin[0],twin[-1],pars['dt'])\\n time = np.sort(np.r_[time,spikes])\\n # Generate spike vector\\n tspk = np.copy(time)\\n for i in range(1,len(spikes)):\\n tspk[np.where(np.logical_and(time>=spikes[i-1],time<spikes[i]))[0]] = spikes[i-1]\\n tspk[np.where(time >= spikes[len(spikes)-1])[0]] = spikes[len(spikes)-1]\\n tspk[np.where(time < spikes[0])[0]] = 0\\n # Generate general solution vector\\n vsol = np.ones(time.size)\\n if (variable=='x') and isscalar(uval):\\n uval = uval * np.ones(sol.size)\\n if variable=='x':\\n for i in range(1, len(spikes)):\\n # x must be given at x(t_i^+) according to xsol\\n vsol[np.where(np.logical_and(time >= spikes[i - 1], time < spikes[i]))[0]] = sol[i-1]*(1-uval[i-1])\\n vsol[np.where(time >= spikes[len(spikes) - 1])[0]] = sol[len(spikes) - 1]*(1-uval[len(spikes)-1])\\n else:\\n for i in range(1, len(spikes)):\\n vsol[np.where(np.logical_and(time >= spikes[i - 1], time < spikes[i]))[0]] = sol[i-1]\\n vsol[np.where(time >= spikes[len(spikes) - 1])[0]] = sol[len(spikes) - 1]\\n vsol[np.where(time < spikes[0])[0]] = ics\\n # Compute effective solution\\n solution = np.zeros((2, time.size))\\n solution[0] = time\\n\\n if variable=='x':\\n # Assumes that the first ICs is x(0)\\n solution[1] = xsol(vsol,time-tspk,tau)\\n else:\\n solution[1] = usol(vsol,time-tspk,tau)\\n\\n return solution\",\n \"def step_autocorrelation(self):\\n\\n max_hops = max([len(x) for x in self.steps])\\n\\n self.acf = np.zeros([len(self.steps), max_hops])\\n\\n keep = [] # list to hold indices of trajectories with a non-zero amount of hops\\n for i in range(len(self.steps)):\\n hops = self.steps[i]\\n if len(hops) > 1:\\n self.acf[i, :len(self.steps[i])] = timeseries.acf(self.steps[i])\\n keep.append(i)\\n\\n self.acf = self.acf[keep, :]\\n\\n self.acf = np.array([self.acf[np.nonzero(self.acf[:, i]), i].mean() for i in range(max_hops)])\\n\\n #self.acf = timeseries.step_autocorrelation(self.z_interpolated.T[..., np.newaxis])\",\n \"def run(self):\\n self.errList = []\\n self.initialize()\\n\\n for i in range(self.maxiter):\\n # update U\\n for k in range(self.K):\\n [p, sigma, q] = np.linalg.svd(self.H.dot(self.S[:, :, k]).dot(self.V.T).dot(self.X[k].T),\\n full_matrices=False)\\n self.U[k] = q.T.dot(p.T)\\n self.U[k] = self.U[k].real\\n\\n # calculate temporal variable y\\n y = np.zeros([self.rank, self.L, self.K])\\n for k in range(self.K):\\n y[:, :, k] = self.U[k].T.dot(self.X[k])\\n\\n # get H, V, and temps by running a single iteration of CP_ALS\\n if i == 0:\\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\\n self.rank, tol=self.tol, maxiter=1, printitn=0)\\n else:\\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\\n self.rank, tol=self.tol, maxiter=1,\\n init=[self.H, self.V, temps], printitn=0)\\n self.H = cp.Us[0]\\n self.V = cp.Us[1]\\n temps = cp.Us[2].dot(np.diag(cp.lmbda))\\n\\n # update S\\n for k in range(self.K):\\n self.S[:, :, k] = np.diag(temps[k, :])\\n\\n # checking the stop criteria\\n # error = 0\\n for k in range(self.K):\\n temp = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)\\n self.sigma_new += np.linalg.norm(temp - self.X[k]) ** 2\\n\\n error = abs(self.sigma_new - self.sigma_old) #/ self.sigma_old\\n self.errList.append(error)\\n if (i + 1) % self.printitn == 0:\\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\\n self.sigma_new)\\n elif error < self.tol:\\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\\n self.sigma_new)\\n\\n if error < self.tol:\\n break\\n else:\\n self.sigma_old = self.sigma_new\\n self.sigma_new = 0\\n\\n for k in range(self.K):\\n self.fit[k] = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)\",\n \"def empirical_cor(l):\\n\\n global fig_dphi\\n\\n # first clean los\\n maps_temp = np.matrix.copy(maps[:,:,l]) - np.matrix.copy(models[:,:,l])\\n\\n # no estimation on the ref image set to zero \\n if np.nansum(maps[:,:,l]) != 0:\\n\\n maxlos,minlos=np.nanpercentile(maps_temp[ibeg_emp:iend_emp,jbeg_emp:jend_emp],float(arguments[\\\"--perc_los\\\"])),np.nanpercentile(maps_temp[ibeg_emp:iend_emp,jbeg_emp:jend_emp],100-float(arguments[\\\"--perc_los\\\"]))\\n logger.debug('Set Max-Min LOS for empirical estimation: {0}-{1}'.format(maxlos,minlos))\\n kk = np.nonzero(np.logical_or(maps_temp==0.,np.logical_or((maps_temp>maxlos),(maps_temp<minlos))))\\n maps_temp[kk] = float('NaN')\\n\\n itemp = ibeg_emp\\n for lign in range(ibeg_emp,iend_emp,10):\\n if np.isnan(np.nanmean(maps[lign:lign+10,:,l])):\\n itemp = lign\\n else:\\n break\\n logger.debug('Begining of the image: {}'.format(itemp))\\n\\n if arguments[\\\"--topofile\\\"] is not None:\\n ax_dphi = fig_dphi.add_subplot(4,int(N/4)+1,l+1)\\n else:\\n ax_dphi = None\\n\\n logger.debug('Threshold RMS: {}'.format(float(arguments[\\\"--threshold_rms\\\"])))\\n\\n # selection pixels\\n index = np.nonzero(np.logical_and(elev<maxtopo,\\n np.logical_and(elev>mintopo,\\n np.logical_and(mask_flat>float(arguments[\\\"--threshold_mask\\\"]),\\n np.logical_and(~np.isnan(maps_temp),\\n np.logical_and(~np.isnan(rmsmap),\\n np.logical_and(~np.isnan(elev),\\n np.logical_and(rmsmap<float(arguments[\\\"--threshold_rms\\\"]),\\n np.logical_and(rmsmap>1.e-6,\\n np.logical_and(~np.isnan(maps_temp),\\n np.logical_and(pix_az>ibeg_emp,\\n np.logical_and(pix_az<iend_emp,\\n np.logical_and(pix_rg>jbeg_emp,\\n np.logical_and(pix_rg<jend_emp, \\n slope>0.,\\n ))))))))\\n ))))))\\n\\n # extract coordinates for estimation\\n temp = np.array(index).T\\n x = temp[:,0]; y = temp[:,1]\\n # clean maps\\n los_clean = maps_temp[index].flatten()\\n topo_clean = elev[index].flatten()\\n rms_clean = rmsmap[index].flatten()\\n \\n logger.debug('Number of points for empirical estimation: {}'.format(len(los_clean)))\\n if len(los_clean) < 1:\\n logger.critical('No points left for empirical estimation. Exit!')\\n logger.critical('threshold RMS: {0}, threshold Mask: {1}, Min-Max LOS: {2}-{3}, Min-Max topo: {4}-{5}, lines: {6}-{7}, \\\\\\n cols: {8}- {9}'.format(float(arguments[\\\"--threshold_rms\\\"]),float(arguments[\\\"--threshold_mask\\\"]),minlos,maxlos,mintopo,maxtopo,ibeg_emp,iend_emp,jbeg_emp,jend_emp))\\n sys.exit()\\n\\n # print itemp, iend_emp\\n if flat>5 and iend_emp-itemp < .6*(iend_emp-ibeg_emp):\\n logger.warning('Image too short in comparison to master, set flat to 5')\\n temp_flat=5\\n else:\\n temp_flat=flat\\n\\n if ivar>0 and iend_emp-itemp < .6*(iend_emp-ibeg_emp):\\n logger.warning('Image too short in comparison to master, set ivar to 0')\\n ivar_temp=0\\n nfit_temp=0\\n else:\\n ivar_temp=ivar\\n nfit_temp=nfit\\n\\n # call ramp estim\\n los = as_strided(maps[:,:,l]).flatten()\\n samp = int(arguments[\\\"--emp_sampling\\\"])\\n\\n map_ramp, map_flata, map_topo, rmsi = estim_ramp(los,los_clean[::samp],topo_clean[::samp],x[::samp],\\\\\\n y[::samp],temp_flat,rms_clean[::samp],nfit_temp, ivar_temp, l, ax_dphi)\\n\\n if (lin_start is not None) and (lin_end is not None):\\n # try:\\n indexref = np.nonzero(np.logical_and(elev<maxtopo,\\n np.logical_and(elev>mintopo,\\n np.logical_and(mask_flat>float(arguments[\\\"--threshold_mask\\\"]),\\n np.logical_and(~np.isnan(maps_temp),\\n np.logical_and(~np.isnan(rmsmap),\\n np.logical_and(~np.isnan(elev),\\n np.logical_and(rmsmap<float(arguments[\\\"--threshold_rms\\\"]),\\n np.logical_and(rmsmap>1.e-6,\\n np.logical_and(~np.isnan(maps_temp),\\n np.logical_and(pix_az>lin_start,\\n np.logical_and(pix_az<lin_end,\\n np.logical_and(pix_rg>col_start,\\n np.logical_and(pix_rg<col_end, \\n slope>0.,\\n ))))))))))))\\n ))\\n \\n if len(indexref[0]) == 0:\\n logger.warning('Ref zone is empty! Re-define --ref_zone argument. Exit!')\\n sys.exit()\\n\\n ## Set data minus temporal model to zero in the ref area\\n zone = as_strided(map_flata[:,:] - models[:,:,l])\\n los_ref2 = zone[indexref].flatten()\\n rms_ref = rmsmap[indexref].flatten()\\n amp_ref = 1./rms_ref\\n amp_ref = amp_ref/np.nanmax(amp_ref)\\n # weigth avera of the phase\\n cst = np.nansum(los_ref2*amp_ref) / np.nansum(amp_ref)\\n logger.info('Re-estimation of a constant within lines {0}-{1} and cols {2}-{3}'.format(lin_start,lin_end,col_start,col_end))\\n logger.info('Average phase within ref area: {0}:'.format(cst))\\n if np.isnan(cst):\\n cst = 0.\\n map_ramp, map_flata = map_ramp + cst, map_flata - cst\\n del zone\\n \\n else:\\n map_flata = np.copy(maps[:,:,l])\\n map_ramp, map_topo = np.zeros(np.shape(map_flata)), np.zeros(np.shape(map_flata))\\n rmsi = 1\\n\\n # set ramp to NaN to have ramp of the size of the images\\n kk = np.nonzero(np.isnan(map_flata))\\n ramp = as_strided(map_ramp)\\n ramp[kk] = float('NaN')\\n topo = as_strided(map_topo)\\n topo[kk] = float('NaN')\\n del ramp, topo\\n \\n return map_ramp, map_flata, map_topo, rmsi\",\n \"def _solver_dirty(X, R, coef_shared_, coef_specific_, Ls, alpha, beta,\\n max_iter, tol, positive):\\n n_tasks = len(X)\\n n_samples, n_features = X[0].shape\\n theta = coef_shared_ + coef_specific_\\n alpha *= n_samples\\n beta *= n_samples\\n\\n # dg = 1.\\n for i in range(max_iter):\\n w_max = 0.0\\n d_w_max = 0.0\\n for j in range(n_features):\\n if Ls[j] == 0.:\\n continue\\n # compute residual\\n grad = np.zeros(n_tasks)\\n tmp1 = np.zeros(n_tasks)\\n tmp2 = np.zeros(n_tasks)\\n\\n normtmp = 0.\\n for t in range(n_tasks):\\n for n in range(n_samples):\\n grad[t] += X[t, n, j] * R[t, n]\\n grad[t] /= Ls[j]\\n tmp1[t] = grad[t] + coef_shared_[j, t]\\n tmp2[t] = grad[t] + coef_specific_[j, t]\\n\\n normtmp += tmp1[t] ** 2\\n\\n normtmp = np.sqrt(normtmp)\\n\\n # l2 thresholding\\n\\n thresholdl2 = 0.\\n if normtmp:\\n thresholdl2 = max(1. - alpha / (Ls[j] * normtmp), 0.)\\n tmp1 *= thresholdl2\\n thresholdl1 = beta / Ls[j]\\n tmp2 = np.sign(tmp2) * np.maximum(np.abs(tmp2) - thresholdl1, 0.)\\n if positive:\\n tmp2 = np.maximum(tmp2, 0.)\\n tmp1 = np.maximum(tmp1, 0.)\\n new_theta = tmp1 + tmp2\\n if theta[j].any():\\n for t in range(n_tasks):\\n R[t] += X[t, :, j] * theta[j, t]\\n\\n d_w_j = np.abs(theta[j] - new_theta).max()\\n d_w_max = max(d_w_max, d_w_j)\\n w_max = max(w_max, np.abs(tmp1 + tmp2).max())\\n coef_shared_[j] = tmp1\\n coef_specific_[j] = tmp2\\n theta[j] = new_theta\\n\\n if theta[j].any():\\n for t in range(n_tasks):\\n R[t] -= X[t, :, j] * theta[j, t]\\n\\n if (w_max == 0.0 or d_w_max / w_max < tol):\\n break\\n\\n return coef_shared_, coef_specific_, R, i\",\n \"def _fit(self, init_step_size, y):\\n step_size = np.zeros(self.max_iter + 1)\\n beta = np.zeros((self.max_iter + 1, self.d))\\n theta = np.zeros((self.max_iter + 1, self.d))\\n beta_mask = np.zeros((self.max_iter + 1, self.n))\\n theta_mask = np.zeros((self.max_iter + 1, self.n))\\n grad_beta = np.zeros((self.max_iter + 1, self.d))\\n grad_theta = np.zeros((self.max_iter + 1, self.d))\\n norm_grad_beta = np.zeros(self.max_iter + 1)\\n norm_grad_theta = np.zeros(self.max_iter + 1)\\n\\n step_size[0] = init_step_size\\n grad_beta[0, :], beta_mask[0, :] = self._gradient(beta[0, :], y)\\n grad_theta[0, :], theta_mask[0, :] = self._gradient(theta[0, :], y)\\n norm_grad_beta[0] = np.linalg.norm(grad_beta[0, :])\\n norm_grad_theta[0] = np.linalg.norm(grad_theta[0, :])\\n for t in range(self.max_iter):\\n if self.verbose:\\n print(\\\"ITERATION {}\\\".format(t))\\n\\n step_size[t + 1], beta_mask[t + 1, :] = self._backtracking(step_size[t], theta[t], theta_mask[t, :], grad_theta[t, :], norm_grad_theta[t], y)\\n beta[t + 1, :] = theta[t, :] - step_size[t + 1]*grad_theta[t, :]\\n theta[t + 1, :] = beta[t + 1, :] + t/(t + 3)*(beta[t + 1, :] - beta[t, :])\\n\\n grad_beta[t + 1, :], _ = self._gradient(beta[t + 1, :], y, mask=beta_mask[t + 1, :])\\n grad_theta[t + 1, :], theta_mask[t + 1, :] = self._gradient(theta[t + 1, :], y)\\n norm_grad_beta[t + 1] = np.linalg.norm(grad_beta[t + 1, :])\\n norm_grad_theta[t + 1] = np.linalg.norm(grad_theta[t + 1, :])\\n\\n if norm_grad_beta[t + 1] <= self.epsilon:\\n break\\n\\n if self.verbose and t + 1 == self.max_iter:\\n print(\\\"Maximum iterations reached\\\")\\n\\n return beta[t + 1, :]\",\n \"def _solve(self) -> CasADiArrayType:\\n\\n # Setup solver\\n self.m = osqp.OSQP()\\n self.m.setup(**self._setup_input)\\n\\n # Warm start optimization\\n if self.use_warm_start:\\n self.m.warm_start(x=self.x0.toarray().flatten())\\n\\n # Solve problem\\n self._solution = self.m.solve()\\n\\n return self._solution.x\",\n \"def run(self):\\n\\n # Initializing required variables for the algorithm\\n start = time.time()\\n i = 0\\n w = self.w\\n k = 99.99\\n\\n #Running the algorithm till tolerance is reached\\n while k > self.tolerance: \\n\\n i = i + 1\\n\\n if self.verbose:\\n print(\\\"Iteration \\\" + str(i),end=\\\"\\\\r\\\")\\n\\n # Following is a gradient descent algorithm\\n # You can find the update step at the following\\n # link, https://raw.githubusercontent.com/mnk400/linearRegression/master/img/EUC.png\\n t_0 = w.T.dot(w)\\n t_1 = self.x.T.dot(self.x).dot(w)\\n gradient = (2/t_0) * (t_1) - (2/t_0**2) * np.transpose(w).dot(t_1) * (w)\\n w_new = w - (1/self.DATAPOINTS) * 0.3 * gradient\\n w_new[-1] = -1\\n l = len(self.x[0]) - 1 \\n y_plt = np.dot(self.x[:,0:l],w_new[:-1]) \\n\\n #tolerance is checked against the root mean square of change in weights\\n k = np.dot(np.transpose(w - w_new),(w - w_new))\\n\\n #Updating the weights \\n w = w_new\\n\\n if self.verbose:\\n print(\\\"Tolerance Reached\\\")\\n timetaken = round(time.time() - start, 3)\\n print(\\\"Ran for \\\" + str(timetaken) + \\\" seconds\\\" + \\\" in \\\" + str(i) + \\\" iterations.\\\")\\n\\n return w_new, y_plt\",\n \"def solve(self) -> jnp.ndarray:\\n pass\",\n \"def fit(self, f: callable, a: float, b: float, d: int, maxtime: float) -> callable:\\r\\n\\r\\n # replace these lines with your solution\\r\\n initial_T = time.time()\\r\\n\\r\\n def get_points(f, a, b, n):\\r\\n x = np.linspace(a, b, n)\\r\\n y_lst = f(x)\\r\\n y = np.array(y_lst)\\r\\n\\r\\n return x, y\\r\\n\\r\\n def build_vector(x, y, size, deg):\\r\\n if deg == size:\\r\\n y_n = y.sum()\\r\\n else:\\r\\n y_n = np.dot(y, (x ** (size - deg)))\\r\\n pol1 = np.zeros(size + 1)\\r\\n for i in range(size + 1):\\r\\n pol1[i] = (x ** (2 * size - deg - i)).sum()\\r\\n return pol1, y_n\\r\\n\\r\\n def build_coeff_matrix(f, a, b, n, d):\\r\\n x, y = get_points(f, a, b, n)\\r\\n deg = d\\r\\n b = np.array([])\\r\\n coeff_matrix = np.array([])\\r\\n for i in range(d + 1):\\r\\n x_n, y_n = build_vector(x, y, d, i)\\r\\n deg -= 1\\r\\n coeff_matrix = np.append(coeff_matrix, x_n)\\r\\n b = np.append(b, y_n)\\r\\n coeff_matrix = np.reshape(coeff_matrix, (d + 1, d + 1))\\r\\n return coeff_matrix, b\\r\\n\\r\\n def solve_coeff_matrix(coeff_matrix, b):\\r\\n A_inverse = np.linalg.inv(coeff_matrix)\\r\\n coeffs = A_inverse.dot(b)\\r\\n return coeffs\\r\\n\\r\\n def build_function_from_coeffs(coeffs):\\r\\n f = np.poly1d(coeffs)\\r\\n return f\\r\\n\\r\\n n = 100 # fisrt sample size\\r\\n while (time.time() - initial_T) + 0.2 < maxtime: # while i still have time loop again\\r\\n Ax, B = build_coeff_matrix(f, a, b, n, d=d)\\r\\n if time.time() - initial_T + 0.2 >= maxtime: # first break point\\r\\n break\\r\\n coeffs = solve_coeff_matrix(coeff_matrix=Ax, b=B)\\r\\n if time.time() - initial_T + 0.2 >= maxtime: # second break point\\r\\n break\\r\\n result = build_function_from_coeffs(coeffs)\\r\\n if time.time() - initial_T + 0.2 >= maxtime: # third break point\\r\\n break\\r\\n n += 200 # increasing sample size\\r\\n\\r\\n return result\",\n \"def run():\\n return estimate(0,1,0)\",\n \"def get_s0_xy_mc(N, delta, beta,starting_counter, n_evals):\\n tolerance = 0.1 #energy tolerance\\n energy_per_bond = -1 + delta * 0.001 # delta in miliergs\\n\\n S0_TEMPLATE = 's0_{}'# format is S0_N_energy_per_bond_i\\n if delta < 50:# was 50\\n angle = np.degrees(acos(0.99-delta*0.001))\\n s0 = get_s0_xy_equipartition(N,angle)\\n else:\\n s0 = get_s0_random_xy(N)\\n solver = spin_solver.SpinSolver(1, N, t_ode = 1,s0 = s0, beta = beta)\\n\\n #initial converging towards right energy using xy updates\\n while abs(solver.hamilt - energy_per_bond * N) > tolerance:\\n solver.mc_update_xy()\\n\\n #initial shuffling around, not generating any states yet\\n iters = 0\\n while iters < 500:\\n iters +=1\\n solver.mc_micro_sweep()\\n for m in range(N):\\n solver.mc_update_xy()\\n if iters%50==0:\\n solver.mc_twist()\\n f = h5py.File('s0_{}_{}.hdf5'.format(starting_counter,n_evals), 'w')\\n\\n #generating initial states\\n for i in range(n_evals):\\n iters = 0\\n while iters < 100:\\n iters +=1\\n if iters%10==0:\\n solver.mc_twist()\\n solver.mc_micro_sweep()\\n for m in range(N):\\n solver.mc_update_xy()\\n # reaching desired energy\\n while abs(solver.hamilt - energy_per_bond * N) > tolerance:\\n solver.mc_update_xy()\\n dset = f.create_dataset(S0_TEMPLATE.format(starting_counter+i), data = solver.s0)\\n f.attrs['N'] = N\\n f.attrs['delta'] = delta\\n f.attrs['beta'] = beta\\n f.attrs['starting_counter'] = starting_counter\\n f.attrs['n_evals'] = n_evals\\n f.attrs['timestamp'] = time.strftime(\\\"%Y-%m-%d %H:%M:%S\\\", time.gmtime())\\n f.attrs['monte_carlo_method'] = \\\"500 iters (every50th twist), then 100 iters(every10th twist) between samples, for delta<50 start with gaussian equipartition\\\"\\n f.close()\",\n \"def fit(self, ymeas, mmeas=None, alg='optls'): # alg: {'optls','mine'}\\n\\n # [ X ]*dm = [ dy ]\\n # [ a ] [ 0 ] <-- using built-in Ridge model does this\\n #\\n # [ X ]*dm = [ dy ]\\n # [-a ] [ a*m ] <-- but I want this for iterated nonlin problem\\n #\\n # [ X ]*dm = [ dy ]\\n # [-aL ] [ a*L*m ] <-- and more generally I want this (higher-order Tihk)\\n #\\n # which can be rewritten:\\n # G * dm = D (and then loop that from m0 with m=m+dm...)\\n\\n # X is the Jacobian matrix of derivs of predicted data points wrt model\\n # params m, as given by ypred,X=self.fwd_deriv_code(m)...\\n\\n\\n if alg=='optls':\\n # https://docs.scipy.org/doc/scipy/reference/optimize.html\\n # https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.least_squares.html\\n def fun(m):\\n mlen = m.size\\n L = create_findiff_mtx(mlen,self.beta)\\n ypred,J = self.fwd_deriv_code(m) # m: model params vector, J: derivs matrix\\n resids = ymeas-ypred\\n modelfunc = self.alpha * np.dot(L,m)\\n modelfunc = modelfunc.reshape(len(modelfunc),1)\\n f = np.squeeze(np.concatenate((resids,modelfunc),axis=0))\\n return f\\n\\n def jac(m):\\n mlen = m.size\\n L = create_findiff_mtx(mlen,self.beta)\\n ypred,J = self.fwd_deriv_code(m) # m: model params vector, J: derivs matrix\\n Jreg = self.alpha * L\\n Jout = np.concatenate((J,Jreg))\\n return Jout\\n\\n if self.usefindiff:\\n jacfn='2-point'\\n else:\\n jacfn=jac\\n if self.verbose:\\n verblevel=2\\n else:\\n verblevel=0\\n res = least_squares(fun, np.squeeze(self.minit), jac=jacfn,\\n bounds=(0., 3.5), diff_step=None, verbose=verblevel, max_nfev=self.max_nfev,\\n method='trf', ftol=1e-08, xtol=1e-08, gtol=1e-08, x_scale=1.0)\\n #ftol=1e-4, xtol=1e-1, gtol=1e-8, x_scale=1.0)\\n #ftol=1e0, xtol=1e-01, gtol=1e-01, x_scale=1.0)\\n #ftol=1e-08, xtol=1e-08, gtol=1e-08, x_scale=1.0)\\n\\n if mmeas is not None:\\n testMSE = cplxMSE(res.x.reshape(len(res.x),1),mmeas)\\n else:\\n testMSE = npl.nan\\n ypred,J = self.fwd_deriv_code(res.x.reshape(len(res.x),1))\\n ypred=np.log10(ypred)\\n residnorm = norm(ypred-ymeas)\\n print('resid norm',residnorm)\\n L = create_findiff_mtx(len(self.minit),self.beta)\\n print('maxeig JJ',np.real(np.amax(np.linalg.eigvals(np.dot(J.T,J))))) # J'J has real eigvals but kept cplx type\\n print('maxeig LL',np.amax(np.linalg.eigvals(np.dot(L.T,L))))\\n if self.showplot:\\n f, ax = plt.subplots(1, 2, figsize=(11,4))\\n # plot the meas and pred data:\\n # print('ypred',ypred)\\n # print('ymeas',ymeas)\\n ax[0].plot(ypred,'r.-')\\n ax[0].plot(ymeas,'k.-')\\n ax[0].grid()\\n #ax[0].set_ylabel('cost')\\n #ax[0].set_xlabel('iterations')\\n ax[0].set_title('Measured (blk) and predicted (blu) data')\\n # plot the init, true, and final model param vectors:\\n ax[1].plot(self.minit,'g.-')\\n ax[1].plot(res.x,'r.--')\\n ax[1].plot(mmeas,'k.--')\\n ax[1].grid()\\n #ax[1].set_ylabel('model value')\\n #ax[1].set_xlabel('indep var')\\n ax[1].set_title('Model vectors (true=blk, init=grn, soln=red)')\\n\\n # return m,cost,misfit,modelnorm,norm(dm),testMSE\\n return res.x,res.cost,np.nan,np.nan,np.nan,testMSE\\n\\n elif alg=='mine':\\n cost = []\\n m = self.minit\\n mlen = len(m)\\n if self.verbose:\\n print('iter alpha cost norm(dd) norm(dm) dmtol')\\n for i in range(self.max_nfev):\\n ypred,X = self.fwd_deriv_code(m) # m: model params vector, X: derivs matrix\\n if self.usefindiff:\\n def tmpfwdcode(m):\\n return np.squeeze(self.fwd_deriv_code(m)[0])\\n X = jacfindiff(tmpfwdcode,m,dx=1.0e-6) # dx=1.0e-6 is problem dependent!\\n L = create_findiff_mtx(mlen,self.beta)\\n G = np.concatenate((X, -self.alpha*L),axis=0)\\n D = np.concatenate((ymeas-ypred, self.alpha*np.dot(L,m)),axis=0)\\n misfit = cplxMSE(ymeas, ypred)\\n modelnorm = norm(np.dot(L,m))**2\\n current_cost = misfit + pow(self.alpha,2)*modelnorm\\n dm,res,rnk,sv = lstsq(G,D)\\n m = m + dm\\n cost.append(current_cost)\\n if self.verbose:\\n print('%3d %6.1g %10.3f %10.3f %10.2g %6.3g' %\\n (i, self.alpha, current_cost, norm(ymeas-ypred), norm(dm), self.dmtol))\\n if norm(dm) < self.dmtol:\\n break\\n self.G = G\\n self.ypred = ypred\\n if mmeas is not None:\\n testMSE = cplxMSE(m,mmeas)\\n else:\\n testMSE = npl.nan\\n print('maxeig JJ',np.real(np.amax(np.linalg.eigvals(np.dot(X.T,X))))) # X'X has real eigvals but kept cplx type\\n print('maxeig LL',np.amax(np.linalg.eigvals(np.dot(L.T,L))))\\n if self.showplot:\\n f, ax = plt.subplots(1, 2, figsize=(11,4))\\n # plot the cost (ie loss) per iterations:\\n ax[0].semilogy(cost,'.-') # (last element of cost)\\n ax[0].grid()\\n ax[0].set_ylabel('cost')\\n ax[0].set_xlabel('iterations')\\n ax[0].set_title('Cost history (misfit^2 + alpha^2*modelnorm^2)')\\n # plot the init, true, final, and evolution of model params:\\n #print('m',np.squeeze(m.T))\\n ax[1].plot(mmeas,'k')\\n ax[1].plot(self.minit,'g')\\n ax[1].plot(m,'r')\\n ax[1].grid()\\n #ax[1].set_ylabel('model value')\\n ax[1].set_xlabel('indep var')\\n ax[1].set_title('Model vectors')\\n\\n return m,cost[-1],misfit,modelnorm,norm(dm),testMSE\",\n \"def run_solution1_simple(self):\\n fuel_sum = 0\\n for n in self.data:\\n fuel_sum += self.calculate_fuel(n)\\n return fuel_sum\",\n \"def init_solver(self, cost_func=None, opt_x0=False, init_uncertainty=False):\\n self.cost_func = cost_func\\n self.opt_x0 = opt_x0\\n self.init_uncertainty = init_uncertainty\\n\\n u_0 = MX.sym(\\\"init_control\\\", (self.n_u, 1))\\n k_ff_all = MX.sym(\\\"feed-forward control\\\", (self.n_safe - 1, self.n_u))\\n g = []\\n lbg = []\\n ubg = []\\n g_name = []\\n\\n p_0 = MX.sym(\\\"initial state\\\", (self.n_s, 1))\\n q_0 = None\\n k_fb_0 = None\\n if init_uncertainty:\\n q_0 = MX.sym(\\\"init uncertainty\\\", (self.n_s, self.n_s))\\n k_fb_0 = MX.sym(\\\"init feddback control matrix\\\", (self.n_u, self.n_s))\\n\\n k_fb_safe = MX.sym(\\\"feedback matrices\\\",\\n (self.n_safe - 1, self.n_s * self.n_u))\\n\\n p_all, q_all, gp_sigma_pred_safe_all = cas_multistep(p_0, u_0, k_fb_safe, k_ff_all,\\n self.ssm_forward, self.l_mu,\\n self.l_sigma,\\n self.beta_safety, self.a,\\n self.b,\\n self.lin_trafo_gp_input, q_0, k_fb_0)\\n\\n # generate open_loop trajectory function [vertcat(x_0,u_0)],[f_x])\\n\\n if init_uncertainty:\\n self._f_multistep_eval = cas.Function(\\\"safe_multistep\\\",\\n [p_0, u_0, k_fb_safe, k_ff_all, q_0, k_fb_0],\\n [p_all, q_all, gp_sigma_pred_safe_all])\\n else:\\n self._f_multistep_eval = cas.Function(\\\"safe_multistep\\\",\\n [p_0, u_0, k_fb_safe, k_ff_all],\\n [p_all, q_all, gp_sigma_pred_safe_all])\\n\\n g_safe, lbg_safe, ubg_safe, g_names_safe = self.generate_safety_constraints(\\n p_all, q_all, u_0, k_fb_safe, k_ff_all, q_0, k_fb_0)\\n g = vertcat(g, g_safe)\\n lbg += lbg_safe\\n ubg += ubg_safe\\n g_name += g_names_safe\\n\\n # Generate performance trajectory\\n if self.n_perf > 1:\\n k_ff_perf, k_fb_perf, k_ff_perf_traj, k_fb_perf_traj, mu_perf, sigma_perf, gp_sigma_pred_perf_all, g_perf, lbg_perf, ubg_perf, g_names_perf = self._generate_perf_trajectory_casadi(\\n p_0, u_0, k_ff_all, k_fb_safe, self.a, self.b, self.lin_trafo_gp_input)\\n g = vertcat(g, g_perf)\\n lbg += lbg_perf\\n ubg += ubg_perf\\n g_name += g_names_perf\\n else:\\n k_ff_perf = np.array([])\\n k_fb_perf = np.array([])\\n k_fb_perf_traj = np.array([])\\n k_ff_perf_traj = np.array([])\\n mu_perf = np.array([])\\n sigma_perf = np.array([])\\n gp_sigma_pred_perf_all = None\\n\\n cost = self.generate_cost_function(p_0, u_0, p_all, q_all, mu_perf, sigma_perf,\\n k_ff_all, k_fb_safe, gp_sigma_pred_safe_all,\\n k_fb_perf=k_fb_perf_traj,\\n k_ff_perf=k_ff_perf_traj,\\n gp_pred_sigma_perf=gp_sigma_pred_perf_all,\\n custom_cost_func=cost_func)\\n\\n if self.opt_x0:\\n opt_vars = vertcat(p_0, u_0, k_ff_perf, k_ff_all.reshape((-1, 1)))\\n opt_params = vertcat(k_fb_safe.reshape((-1, 1)), k_fb_perf.reshape((-1, 1)))\\n else:\\n opt_vars = vertcat(u_0, k_ff_perf, k_ff_all.reshape((-1, 1)))\\n opt_params = vertcat(p_0, k_fb_safe.reshape((-1, 1)), k_fb_perf.reshape((-1, 1)))\\n\\n if self.init_uncertainty:\\n opt_params = vertcat(opt_params, q_0.reshape((-1, 1)), k_fb_0.reshape((-1, 1)))\\n\\n prob = {'f': cost, 'x': opt_vars, 'p': opt_params, 'g': g}\\n\\n opt = self.opts_solver\\n if opt is None:\\n opt = {'error_on_fail': False,\\n 'ipopt': {'hessian_approximation': 'limited-memory', \\\"max_iter\\\": 100,\\n \\\"expect_infeasible_problem\\\": \\\"no\\\", \\\\\\n 'acceptable_tol': 1e-4, \\\"acceptable_constr_viol_tol\\\": 1e-5,\\n \\\"bound_frac\\\": 0.5, \\\"start_with_resto\\\": \\\"no\\\",\\n \\\"required_infeasibility_reduction\\\": 0.85,\\n \\\"acceptable_iter\\\": 8}} # ipopt\\n\\n # opt = {'max_iter':120,'hessian_approximation':'limited-memory'}#,\\\"c1\\\":5e-4} #sqpmethod #,\\n # opt = {'max_iter':120,'qpsol':'qpoases'}\\n\\n solver = cas.nlpsol('solver', 'ipopt', prob, opt)\\n # solver = cas.nlpsol('solver','sqpmethod',prob,opt)\\n # solver = cas.nlpsol('solver','blocksqp',prob,opt)\\n\\n self.solver = solver\\n self.lbg = lbg\\n self.ubg = ubg\\n self.solver_initialized = True\\n self.g = g\\n self.g_name = g_name\",\n \"def solve(self):\\n for step in self.run.values():\\n step.solve()\",\n \"def solve(self):\\n initial_fes = eades(self.graph, self.force_forward_edges)\\n initial_fes_vec = self.edge_vector(initial_fes)\\n\\n # bounds for the objective\\n lower_bound = 0\\n upper_bound = np.sum(initial_fes_vec @ self.weights)\\n\\n self.logger.info('Calculating FES for graph with %d edges, max %d feedback edges', self.m, len(initial_fes))\\n\\n simple_cycles = set(induced_cycles(self.graph, initial_fes))\\n\\n for iteration in itertools.count(1):\\n self.logger.info('Baharev iteration %d, %g <= objective <= %g, %d simple cycles', iteration, lower_bound,\\n upper_bound, len(simple_cycles))\\n\\n # Formulate and solve the problem for this iteration:\\n y = cp.Variable(self.m, boolean=True, name=\\\"y\\\")\\n objective = cp.Minimize(cp.sum(y @ self.weights))\\n\\n cycle_vectors = [self.edge_vector(nx.utils.pairwise(cycle)) for cycle in simple_cycles]\\n constraints = [cp.sum(a @ y) >= 1 for a in cycle_vectors]\\n constraints.append(cp.sum(y @ self.force_forward_vec) == 0) # no force forward vec may be in the result set\\n problem = cp.Problem(objective, constraints)\\n resolution = problem.solve(**self.solver_args)\\n if problem.status != 'optimal':\\n self.logger.warning('Optimization solution is %s. Try solver != %s?', problem.status,\\n problem.solver_stats.solver_name)\\n self.logger.debug(\\n \\\"Solved optimization problem with %d constraints: %s -> %s (%g + %g seconds, %d iterations, solver %s)\\\",\\n len(constraints), resolution, problem.solution.status,\\n problem.solver_stats.solve_time or 0, problem.solver_stats.setup_time or 0,\\n problem.solver_stats.num_iters or 0, problem.solver_stats.solver_name)\\n current_solution = np.abs(y.value) >= 0.5 # y.value = vector of floats each ≈ 0 or 1\\n current_fes = self.edges_for_vector(current_solution)\\n self.logger.debug('Iteration %d, resolution: %s, %d feedback edges', iteration, resolution,\\n len(current_fes))\\n # S, the feedback edge set calculated using the constraint subset, can be an incomplete solution\\n # (i.e. cycles remain after removing S from the graph). So lets compare this with the upper bound\\n # from the heuristic\\n lower_bound = max(lower_bound, objective.value)\\n if lower_bound == upper_bound:\\n self.logger.info('upper == lower bound == %g, optimal solution found', lower_bound)\\n break # y.value is the optimal solution\\n\\n if resolution > upper_bound:\\n self.logger.error('Solution %g > upper bound %g!', resolution, upper_bound)\\n break\\n\\n Gi = self.graph.copy()\\n Gi.remove_edges_from(current_fes)\\n if nx.is_directed_acyclic_graph(Gi):\\n self.logger.info('Graph is acyclic, optimal solution found')\\n break # y.value is the optimal solution\\n\\n # The solution is not yet ideal. So we take G^(i), the graph still containing some feedback edges,\\n # calculate a heuristic on it and use the heuristic (= over-estimation) to adjust upper bound and\\n # determine additional simple cycles (= constraints)\\n Fi = eades(Gi, self.force_forward_edges)\\n yi = self.edge_vector(Fi) | current_solution\\n zi = np.sum(yi @ self.weights)\\n if zi < upper_bound:\\n upper_bound = zi\\n current_solution = yi\\n simple_cycles |= set(induced_cycles(Gi, Fi))\\n\\n self.solution_vector = current_solution\\n self.solution = self.edges_for_vector(current_solution)\\n self.objective = objective.value\\n self.iterations = iteration\\n self.simple_cycles = simple_cycles\\n return self.solution\",\n \"def solve(self):\\n\\n # sanity check\\n if self.G is None or self.curve is None or self.Q is None:\\n print(\\\"Can't solve not all parameters are set\\\")\\n return False # unsuccessful\\n\\n self.count = 1 # initial count\\n self.start = time.time()\\n\\n order = self.curve.order(self.G) # get order of generator\\n\\n ############ POLLARD'S RHO + FLOYD'S EXTENSION ############\\n found = False\\n\\n # will probably find a factor, so need to loop with random numbers until we find it\\n while not found:\\n\\n ############ GENERATE RANDOM FUNCTION POINTS ############\\n points = [] # list of points to inform our random function\\n\\n for _ in range(17):\\n a = secrets.randbelow(order)\\n b = secrets.randbelow(order)\\n P = (self.G * a) + (self.Q * b) # linear combination\\n points.append([P, a, b]) # add to list\\n\\n ############ RANDOM START POINTS ############\\n Y, aY, bY = X, aX, bX = points.pop() # random starting points\\n\\n ############ FLOYD'S CYCLE DETECTION ############\\n while not found:\\n X, aX, bX = g((X, aX, bX), order, points) # first runner\\n Y, aY, bY = g(g((Y,aY,bY),order,points),order,points) # second runner\\n\\n found = X == Y # detect match\\n self.count += 1 # increment count\\n\\n if bX == bY and aX == aY: # if we arrive at identical combinations\\n found = False # reset and try again\\n else:\\n inv = modInverse((bX - bY) % order, order) # get mod inverse\\n\\n if inv == 0: # if no mod inverse exists\\n found = False # need to randomly try again\\n else: # we have found k\\n self.k = ((aY - aX) * inv) % order # so set it\\n\\n if self.G * self.k != self.Q: # not always 100% going to work\\n print(\\\"error\\\")\\n found = True\\n\\n self.time = time.time() - self.start\\n\\n # set space\\n self.space = 18\\n\\n if self.verbose:\\n print(\\\"k:\\\", self.k)\\n print(\\\"Time taken: %.3f s\\\" % (self.time)) # print time taken\\n print(\\\"Space used: %d\\\" % (self.space)) # print space used\\n print(\\\"Numbers checked:\\\", self.count) # print total count\\n\\n return True\",\n \"def advance(self):\\n\\n f, n, rtol, atol, neq = \\\\\\n self.f, self.n, self.rtol, self.atol, self.neq\\n u_n, t_n, t_next = self.u[n], self.t[n], self.t[n+1]\\n dt = t_next - t_n\\n\\n first_step = dt # try one big step to next desired level\\n\\n def middle(x,y,z): # Auxilary function\\n return sorted([x,y,z])[1]\\n\\n # Extract coefficients from Butcher-tableau\\n table = self._butcher_tableau\\n k_len = table.shape[1] - 1 # number of internal stages\\n\\n # coefficients for internal stages\\n factors_u = np.asarray(table[:k_len, 1:])\\n # coefficients for t\\n factors_t = table[:k_len, 0]\\n # coefficients for u_new\\n factors_u_new = table[k_len, 1:]\\n\\n # coefficients for local error between 2 levels\\n factors_error = table[k_len+1, 1:] - factors_u_new\\n\\n u_intermediate = [u_n,]\\n t_intermediate = [t_n,]\\n u, t, h = u_n, t_n, first_step # initial values\\n k = np.zeros((k_len, self.neq), self.dtype) # intern stages\\n\\n if self.verbose > 0:\\n print 'advance solution in [%s, %s], h=%g' % (t_n, t_next, h)\\n\\n # Loop until next time point is reached\\n while (abs(t - t_n) < abs(t_next - t_n)):\\n u, t = u_intermediate[-1], t_intermediate[-1]\\n\\n # Internal steps\\n k[:, :] = 0. # initialization for next step\\n for m in range(k_len):\\n k_factors = (np.dot(factors_u, k))[m]\\n #print u, u+h*k_factors, f(u+h*k_factor, 0.5), self.dtype\\n k[m] = f(u+h*k_factors, t+h*factors_t[m])\\n u_new = u + h*(np.dot(factors_u_new, k))\\n\\n self.info['rejected'] += 1 # reduced below if accepted\\n if self.verbose > 0:\\n print ' u(t=%g)=%g: ' % (t+h, u_new),\\n\\n # local error between 2 levels\\n error = h*np.abs(np.dot(factors_error, k))\\n # Acceptable error tolerance\\n tol = rtol*np.abs(u_new) + atol\\n\\n accurate = (error <= tol).all()\\n\\n if accurate or h <= self.min_step or h >= self.max_step:\\n # Accurate enough,\\n # or the step size exceeds valid range,\\n # must accept this solution\\n u_intermediate.append(u_new)\\n t_intermediate.append(t+h)\\n if not self.disk_storage:\\n self.u_all.append(u_new)\\n self.t_all.append(t+h)\\n self.info['rejected'] -= 1\\n\\n if self.verbose > 0:\\n print 'accepted, ',\\n else:\\n if self.verbose > 0:\\n print 'rejected, ',\\n\\n if self.verbose > 0:\\n print 'err=%s, ' % str(error),\\n if hasattr(self, 'u_exact') and callable(self.u_exact):\\n print 'exact-err=%s, ' % \\\\\\n (np.asarray(self.u_exact(t+h))-u_new),\\n if h <= self.min_step:\\n print 'h=min_step!! ',\\n\\n\\n # Replace 0 values by 1e-16 since we will divide by error\\n error = np.asarray([(1e-16 if x == 0. else x) \\\\\\n for x in error])\\n\\n # Normarized error rate\\n rms = error/tol\\n rms_norm = np.sqrt(np.sum(rms*rms)/self.neq)\\n\\n order = float(self._method_order[0])\\n # factor to adjust the size of next step\\n # Formula is from <Numerical Methods for Engineers,\\n # Chappra & Cannle>\\n s = .8 *((1./rms_norm)**(1/order))\\n # scalar should be in range(0.1, 4.)\\n # for better accuracy and smoothness\\n s = middle(s, 0.1, 4.0)\\n h *= s\\n\\n # step size should be in range [min_step, max_step]\\n h = middle(h, self.min_step, self.max_step)\\n # adjust h to fit the last step\\n h = min(h, t_next - t_intermediate[-1])\\n\\n if self.verbose > 0:\\n print 'new h=%g' % h\\n\\n if h == 0:\\n break\\n\\n return u_new\",\n \"def _initialize(self):\\n self._solution = self._problem_instance.build_solution(method=\\\"Greedy\\\")\\n\\n while not self._problem_instance.is_admissible(self._solution):\\n self._solution = self._problem_instance.build_solution(method=\\\"Greedy\\\")\\n \\n self._problem_instance.evaluate_solution(self._solution, feedback=self._feedback)\",\n \"def solve(self):\\n self.m.optimize()\\n if self.m.status == GRB.OPTIMAL:\\n self.solution = self.sol_as_mat()\\n return self.solution\",\n \"def _screener_init(self):\\n subject = 0\\n self.model.uu.remove(subject) # selects from untested and performs e\\n self.model.tt.append(subject)\\n self.model.b -= (self.cz + self.cy) # update budget\\n self.model.z[subject] = self.z[subject] # update model\\n self.model.y[subject] = self.y[subject]\",\n \"def run_trial(self, occ):\\n from scitbx.array_family import flex\\n seed = int(time.time() / os.getpid())\\n random.seed(seed)\\n flex.set_random_seed(seed)\\n fmodel = self.fmodel\\n selection = self.selection.deep_copy()\\n iselection = self.iselection.deep_copy()\\n d_min = fmodel.f_obs().d_min()\\n xrs = fmodel.xray_structure.deep_copy_scatterers()\\n hd_sel = xrs.hd_selection()\\n sites_start = xrs.sites_cart().deep_copy()\\n assert (len(selection) == len(sites_start))\\n fmodel.update_xray_structure(xrs, update_f_calc=True)\\n sites_start_selected = sites_start.select(iselection)\\n occ_start = xrs.scatterers().extract_occupancies().deep_copy()\\n u_start = xrs.extract_u_cart_plus_u_iso()\\n if (self.params.adjust_b_factors_if_poor_density):\\n fofc_map = fmodel.map_coefficients(\\n map_type=\\\"mFo-DFc\\\",\\n exclude_free_r_reflections=True).fft_map(\\n resolution_factor=1/4.).apply_sigma_scaling().real_map_unpadded()\\n sites_frac = xrs.sites_frac()\\n b_scale_isel = flex.size_t()\\n for i_seq in iselection :\\n map_value = fofc_map.tricubic_interpolation(sites_frac[i_seq])\\n if (map_value < -2.5):\\n b_scale_isel.append(i_seq)\\n if (len(b_scale_isel) > 0):\\n b_scale_sel = flex.bool(sites_frac.size(), False).set_selected(\\n b_scale_isel, True)\\n xrs.scale_adp(factor=0.75, selection=b_scale_sel)\\n nearby_water_selection = mmtbx.building.get_nearby_water_selection(\\n pdb_hierarchy=self.pdb_hierarchy,\\n xray_structure=xrs,\\n selection=selection)\\n two_fofc_map, fofc_map = alt_confs.get_partial_omit_map(\\n fmodel=fmodel,\\n selection=iselection,\\n selection_delete=None,#nearby_water_selection,\\n negate_surrounding=self.params.negate_surrounding,\\n partial_occupancy=occ)\\n #xrs.set_occupancies(occ_start)\\n make_sub_header(\\\"Simulated annealing into mFo-DFc map\\\", out=self.out)\\n if (self.params.shake_sites is not None):\\n xrs.shake_sites_in_place(self.params.shake_sites, selection=selection)\\n sites_new = mmtbx.building.run_real_space_annealing(\\n xray_structure=xrs,\\n pdb_hierarchy=self.pdb_hierarchy,\\n processed_pdb_file=self.processed_pdb_file,\\n selection=selection,\\n target_map=fofc_map,\\n d_min=d_min,\\n params=self.params.simulated_annealing,\\n #wc=5, # FIXME why does this need to be scaled?\\n target_map_rsr=two_fofc_map,\\n rsr_after_anneal=self.params.rsr_after_anneal,\\n out=self.out,\\n debug=True)\\n # now compute CC of refined sites to difference map\\n fmodel.update_xray_structure(xrs, update_f_calc=True)\\n fc_coeffs = fmodel.f_model()\\n fc_fft_map = fc_coeffs.fft_map(resolution_factor=1/4.)\\n fc_map = fc_fft_map.apply_sigma_scaling().real_map_unpadded()\\n pdb_atoms = self.pdb_hierarchy.atoms()\\n # XXX should this only calculate statistics for the central atoms?\\n map_stats = mmtbx.building.get_model_map_stats(\\n selection=self.selection_score,\\n target_map=fofc_map,\\n model_map=fc_map,\\n unit_cell=xrs.unit_cell(),\\n sites_cart=sites_new,\\n pdb_atoms=pdb_atoms,\\n local_sampling=False)\\n # reset xray structure\\n xrs.set_sites_cart(sites_start)\\n xrs.set_u_cart(u_start)\\n fmodel.update_xray_structure(xrs, update_f_calc=True)\\n # we may only want the rmsd and max. dev. from a subset of sites, e.g.\\n # the central residue of a sliding window (minus hydrogens)\\n selection_score = self.selection_score.deep_copy()\\n if (type(selection_score).__name__ != 'bool'):\\n selection_score = flex.bool(hd_sel.size(), False).set_selected(\\n self.selection_score, True)\\n selection_score &= ~hd_sel\\n site_stats = alt_confs.coord_stats_with_flips(\\n sites1=sites_start.select(selection_score),\\n sites2=sites_new.select(selection_score),\\n atoms=self.pdb_hierarchy.atoms().select(selection_score))\\n return alt_confs.trial_result(\\n sites_cart=sites_new.select(self.iselection),\\n min_fofc=map_stats.min,\\n mean_fofc=map_stats.mean,\\n rmsd=site_stats.rmsd,\\n max_dev=site_stats.max_dev,\\n cc=map_stats.cc)\",\n \"def calculate(self, model_name, number_of_points, bandwidth,dis_param, c,k, seed, phi=0):\\n if model_name != \\\"Anderson\\\":\\n raise Error(\\\"NotImpelmented\\\")\\n prng = np.random.RandomState((None if seed == 0 else seed))\\n \\n m = models.Model_Anderson_DD_1d(number_of_points=number_of_points,\\n bandwidth=bandwidth, dis_param=dis_param, periodic=False, prng = prng)\\n prng = np.random.RandomState((None if seed == 0 else seed))\\n \\n m1 = models.Model_Anderson_DD_1d(number_of_points=number_of_points,\\n bandwidth=bandwidth, dis_param=dis_param, periodic=True, prng = prng, phi=0)\\n prng = np.random.RandomState((None if seed == 0 else seed))\\n \\n m2 = models.Model_Anderson_DD_1d(number_of_points=number_of_points,\\n bandwidth=bandwidth, dis_param=dis_param, periodic=True, prng = prng, phi=phi)\\n \\n g = abs(phys_functions.A_matrix_inv(m.rate_matrix, c, k))**2\\n psi_1, psi_N = (m1.eig_matrix[0,:]), (m1.eig_matrix[-1,:])\\n thouless, prec = phys_functions.pure_thouless_g(m1.eig_vals, m2.eig_vals, phi)\\n heat_g = phys_functions.heat_g(psi_1, psi_N)\\n psi1psiN = np.nansum(abs(psi_1*psi_N))\\n ############# UGLY HACK : Append zeros to fit sizes\\n vals_with_N_size = [('psi_1', psi_1),\\n ('psi_N', psi_N),('thouless_g', abs(thouless))]\\n if self._N == number_of_points :\\n appended = vals_with_N_size\\n else:\\n myzeros = np.zeros(self._N - number_of_points)\\n \\n appended = [(key, np.append(val,myzeros)) for key,val in vals_with_N_size]\\n \\n print (prec*number_of_points, np.nansum(thouless))\\n return dict([('g', g), ('psi1psiN',psi1psiN), \\n ('thouless_sum', abs(np.nansum(abs(thouless)))), ('phi',phi),('heat_g', heat_g)] +appended)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61429644","0.61369985","0.6008194","0.58990324","0.58952606","0.58914626","0.58276385","0.5809843","0.58021075","0.5751495","0.57445574","0.5744396","0.5744055","0.57362515","0.57333183","0.56920046","0.5677356","0.56640816","0.5659343","0.5646199","0.56345475","0.56316364","0.56195986","0.56119925","0.56079036","0.559753","0.5583474","0.55735445","0.5566587","0.5560247","0.5558006","0.55563873","0.5556","0.5549846","0.55339956","0.55278075","0.55252707","0.55246687","0.55230945","0.551721","0.5512751","0.55097145","0.5508359","0.55052227","0.55030835","0.5484004","0.5456407","0.54367614","0.5428866","0.5423379","0.542219","0.5422109","0.54212624","0.5412219","0.5407946","0.54005647","0.5398464","0.5397696","0.5394511","0.53914255","0.538884","0.5385035","0.5383744","0.53822404","0.5352159","0.53498554","0.53477913","0.5347317","0.5346655","0.5341459","0.5339337","0.53369266","0.53364855","0.5335799","0.5329721","0.532896","0.5326308","0.5312514","0.5307796","0.530628","0.5295409","0.52947843","0.52929634","0.52921945","0.52874464","0.5286293","0.52827555","0.52811104","0.52773356","0.52771795","0.52736264","0.52733624","0.5266337","0.5258516","0.525351","0.5251604","0.52506286","0.5248653","0.5248186","0.524684","0.52454996"],"string":"[\n \"0.61429644\",\n \"0.61369985\",\n \"0.6008194\",\n \"0.58990324\",\n \"0.58952606\",\n \"0.58914626\",\n \"0.58276385\",\n \"0.5809843\",\n \"0.58021075\",\n \"0.5751495\",\n \"0.57445574\",\n \"0.5744396\",\n \"0.5744055\",\n \"0.57362515\",\n \"0.57333183\",\n \"0.56920046\",\n \"0.5677356\",\n \"0.56640816\",\n \"0.5659343\",\n \"0.5646199\",\n \"0.56345475\",\n \"0.56316364\",\n \"0.56195986\",\n \"0.56119925\",\n \"0.56079036\",\n \"0.559753\",\n \"0.5583474\",\n \"0.55735445\",\n \"0.5566587\",\n \"0.5560247\",\n \"0.5558006\",\n \"0.55563873\",\n \"0.5556\",\n \"0.5549846\",\n \"0.55339956\",\n \"0.55278075\",\n \"0.55252707\",\n \"0.55246687\",\n \"0.55230945\",\n \"0.551721\",\n \"0.5512751\",\n \"0.55097145\",\n \"0.5508359\",\n \"0.55052227\",\n \"0.55030835\",\n \"0.5484004\",\n \"0.5456407\",\n \"0.54367614\",\n \"0.5428866\",\n \"0.5423379\",\n \"0.542219\",\n \"0.5422109\",\n \"0.54212624\",\n \"0.5412219\",\n \"0.5407946\",\n \"0.54005647\",\n \"0.5398464\",\n \"0.5397696\",\n \"0.5394511\",\n \"0.53914255\",\n \"0.538884\",\n \"0.5385035\",\n \"0.5383744\",\n \"0.53822404\",\n \"0.5352159\",\n \"0.53498554\",\n \"0.53477913\",\n \"0.5347317\",\n \"0.5346655\",\n \"0.5341459\",\n \"0.5339337\",\n \"0.53369266\",\n \"0.53364855\",\n \"0.5335799\",\n \"0.5329721\",\n \"0.532896\",\n \"0.5326308\",\n \"0.5312514\",\n \"0.5307796\",\n \"0.530628\",\n \"0.5295409\",\n \"0.52947843\",\n \"0.52929634\",\n \"0.52921945\",\n \"0.52874464\",\n \"0.5286293\",\n \"0.52827555\",\n \"0.52811104\",\n \"0.52773356\",\n \"0.52771795\",\n \"0.52736264\",\n \"0.52733624\",\n \"0.5266337\",\n \"0.5258516\",\n \"0.525351\",\n \"0.5251604\",\n \"0.52506286\",\n \"0.5248653\",\n \"0.5248186\",\n \"0.524684\",\n \"0.52454996\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93180,"cells":{"query":{"kind":"string","value":"Self Calibration. Check the solution"},"document":{"kind":"string","value":"def selfcal_pcal_plot(imc, trial='1'):\n plotcal(caltable=imc.path_base+'.pcal'+trial,\n xaxis='time', yaxis='phase', timerange='', iteration='',\n subplot=111, plotrange=[0,0,-180,180])"},"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 calibration(self) -> int:","def _doCalibration(self):\n self._cmdCalibration(2)","def convergence_check(self):\n air = self.air_alias.val\n flue_gas = self.fuel_alias.val + '_fg'\n fuel = self.fuel_alias.val\n\n for c in self.outl:\n if not c.fluid.val_set[air]:\n if c.fluid.val[air] > 0.95:\n c.fluid.val[air] = 0.95\n if c.fluid.val[air] < 0.5:\n c.fluid.val[air] = 0.5\n\n if not c.fluid.val_set[flue_gas]:\n if c.fluid.val[flue_gas] > 0.5:\n c.fluid.val[flue_gas] = 0.5\n if c.fluid.val[flue_gas] < 0.05:\n c.fluid.val[flue_gas] = 0.05\n\n if not c.fluid.val_set[fuel]:\n if c.fluid.val[fuel] > 0:\n c.fluid.val[fuel] = 0\n\n c.target.propagate_fluid_to_target(c, c.target)\n\n for i in self.inl:\n if i.m.val_SI < 0 and not i.m.val_set:\n i.m.val_SI = 0.01\n\n for c in self.outl:\n if c.m.val_SI < 0 and not c.m.val_set:\n c.m.val_SI = 10\n c.target.propagate_fluid_to_target(c, c.target)\n\n if self.lamb.val < 1 and not self.lamb.is_set:\n self.lamb.val = 2","def _check_calibration():\n image_list = glob.glob(os.path.join(\"C:\\\\Users\\\\chuyangl\\\\Desktop\\\\liushuai\\\\calibrator\\\\board\\\\left\", \"*.bmp\"))\n for single_img in image_list:\n image = cv2.imread(single_img)\n new_image = un_distort_image(image)\n cv2.imshow('before', cv2.resize(image, (int(image.shape[1] * 0.7), int(image.shape[0] * 0.7))))\n cv2.imshow('after', cv2.resize(new_image, (int(new_image.shape[1] * 0.7), int(new_image.shape[0] * 0.7))))\n cv2.waitKey(0)\n\n image = cv2.imread(image_list[0])\n\n # distortion_points = [ge.Point(110, 437), ge.Point(932, 151), ge.Point(1034, 331)]\n # calibration_points = [ge.Point(510, 437), ge.Point(832, 151), ge.Point(1134, 331)]\n\n distortion_points = [ge.Point(110, 437), ge.Point(632, 151), ge.Point(333, 331)]\n calibration_points = [ge.Point(510, 437), ge.Point(532, 151), ge.Point(234, 331)]\n\n for p in distortion_points:\n cv2.circle(image, p.tuple(), 23, (0, 0, 255), 2)\n\n new_image = un_distort_image(image)\n\n for p in calibration_points:\n cv2.circle(new_image, p.tuple(), 23, (255, 0, 0), 4)\n p2 = distort_point(p)\n p3 = un_distort_point(p2)\n cv2.circle(image, p2.int().tuple(), 23, (0, 255, 255), 4)\n cv2.circle(new_image, p3.int().tuple(), 23, (0, 0, 255), 4)\n print(p.int().tuple(), p2.int().tuple(), p3.int().tuple())\n\n for p in distortion_points:\n p2 = un_distort_point(p)\n p3 = distort_point(p2)\n cv2.circle(new_image, p2.int().tuple(), 23, (0, 255, 255), 2)\n cv2.circle(image, p3.int().tuple(), 23, (0, 255, 255), 2)\n print(p.int().tuple(), p2.int().tuple(), p3.int().tuple())\n\n cv2.imshow('before', cv2.resize(image, (int(image.shape[1] * 0.7), int(image.shape[0] * 0.7))))\n cv2.imshow('after', cv2.resize(new_image, (int(new_image.shape[1] * 0.7), int(new_image.shape[0] * 0.7))))\n\n cv2.waitKey(0)","def photometric_calibration():\n pass","def calibration(self, cal: int, /) -> None:","def solve(self):","def run_calib(projector=OPTOMA_HD33()):\n w, h = (0.2160, 0.2794)\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\n [-w/2, 0, 0], [w/2, 0, 0],\n [-w/2, 0, h/2], [w/2, 0, h/2]])\n\n global img_points, going\n img_points = []\n\n try:\n window = Window()\n window.MoveXY(1600,0)\n window.ShowFullScreen(True)\n going = True\n\n @window.eventx\n def EVT_MOUSE_EVENTS(evt):\n global going, img_points\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\n img_points.append(evt.Position)\n print('Picked point %d of 6' % (len(img_points)))\n if len(img_points) == len(obj_points):\n print \"Done\"\n going = False\n\n print(\"\"\"[Extrinsic Calibration] \n\nThere should be 6 points marked on the table and backdrop. \nMoving the mouse over the projected display, click each of the points\nin order:\n (left top, on the backdrop),\n (right top, on the backdrop),\n (left center, on the crease),\n (right center, on the crease),\n (left bottom, on the table),\n (right bottom, on the table)\n\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\n\nClick the six points:\n\"\"\")\n\n while going: cv.WaitKey(10)\n\n finally:\n window.Close()\n\n img_points = np.array(img_points, 'f')\n projector.calibrate_extrinsic(img_points, obj_points)\n\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\n print('OK')","def proz(): \r\n print(\"processing: \",CURDATA()[0]) \r\n Check_180turn(left_boundary,right_boundary)\r\n EF() #exponential window multiplication + fourier\r\n APK0() #1. Phase correction 0th Ordnung\r\n APK1() #1. Phase correction 1st Ordnung\r\n ABS() #Baseline correction\r\n APK()\r\n ABS() #Baseline correction\r\n Check_180turn(left_boundary,right_boundary)","def correct(self):\n stop_flag = False\n self.orbit_class.online_calc = False\n # read orbit devs\n for elem in self.orbit.corrs:\n try:\n elem.kick_mrad = elem.mi.get_value()\n except Exception as e:\n stop_flag = True\n logger.warning(elem.id + \" reading error: \" + str(e))\n return stop_flag\n \n elem.angle_read = elem.kick_mrad*1e-3\n elem.i_kick = elem.kick_mrad\n elem.ui.set_init_value(elem.kick_mrad)\n elem.ui.set_value(elem.kick_mrad)\n elem.transfer_map = self.parent.lat.method.create_tm(elem)\n if elem.ui.alarm:\n stop_flag = True\n logger.warning(\"correct - STOP: corrector shows alarm: \" + elem.id)\n\n\n #self.parent.lat.update_transfer_maps()\n\n for elem in self.orbit.bpms:\n if elem.id not in self.new_ref_orbit.keys():\n logger.warning(\"correct - STOP: BPM is not in new ref orbit: \" + elem.id)\n stop_flag = True\n return stop_flag\n elem.x = self.new_ref_orbit[elem.id][0]\n elem.y = self.new_ref_orbit[elem.id][1]\n elem.ui.set_value((elem.x*1000., elem.y*1000.))\n if elem.ui.alarm:\n logger.warning(\"correct - STOP: BPM shows alarm: \" + elem.id)\n stop_flag = True\n if stop_flag:\n return stop_flag\n self.orbit_class.online_calc = True\n\n\n if not self.orbit_class.is_rm_ok(self.orbit):\n logger.error(\" correct: Calculate Response Matrix\")\n self.parent.error_box(\"Calculate Response Matrix\")\n return 0\n\n self.orbit_class.golden_orbit.dict2golden_orbit()\n\n if self.orbit_class.ui.cb_close_orbit.isChecked():\n self.orbit_class.close_orbit()\n\n self.calc_correction = {}\n for cor in self.orbit.corrs:\n cor.angle = 0.\n self.calc_correction[cor.id] = cor.angle\n\n alpha = 0.\n\n self.orbit.correction(alpha=alpha, p_init=None, beta=0, print_log=False)\n for cor in self.orbit.corrs:\n self.calc_correction[cor.id] = cor.angle\n\n self.set_values2correctors()\n return stop_flag","def solve_prep(self):\n\n par = self.par\n sol = self.sol\n\n # a. retirement\n sol.m_ret = np.zeros((par.T,par.Nm_ret))\n sol.c_ret = np.zeros((par.T,par.Nm_ret))\n sol.a_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_v_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_vm_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_vn_ret = np.zeros((par.T,par.Nm_ret))\n\n # b. working\n if par.solmethod == 'G2EGM':\n\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vn = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.ucon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.ucon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.ucon_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.dcon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.dcon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.dcon_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.acon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.acon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.acon_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.z = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wb = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n \n elif par.solmethod == 'NEGM':\n\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vn = np.zeros((0,0,0))\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wb = np.zeros((0,0,0))\n \n sol.c_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\n sol.inv_v_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))","def solve(self):\n # check for jacobian and set it if present and to be used\n if self.use_sparse:\n if self._use_jac and hasattr(self.problem,'sparse_jac'):\n jac = self.problem.sparse_jac\n else:\n jac = None\n else:\n if self._use_jac and hasattr(self.problem,'jac'):\n jac = self.problem.jac\n else:\n jac = None\n \n # Initialize solver and solve \n \n solved = False\n local_min = False\n\n res = N.zeros(self.x0.__len__())\n while (not solved) and self.reg_count < 2:\n try:\n if self._use_fscale:\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,self.fscale)\n else:\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,None)\n start = time.clock()\n res = self.solver.KINSOL_solve(not self._use_ls)\n stop = time.clock()\n self.exec_time += (stop - start)\n solved = True\n except KINError as error:\n if error.value == 42:\n # Try the heuristic\n if hasattr(self.problem, 'get_heuristic_x0'):\n print \"----------------------------------------------------\"\n print \" Solver stuck with zero step-length.\"\n print \"----------------------------------------------------\"\n print \"The following variables have start value zero\"\n print \"and min set to zero causing the zero step-lenght.\"\n print \"These settings are either set by default or by user.\"\n print \"\"\n\n self.x0 = self.problem.get_heuristic_x0()\n self.reg_count += 1\n \n print \"\"\n print \"This setting (start and min to zero) can often\"\n print \"cause problem when initializing the system. \"\n print \"\"\n print \"To avoid this the above variables have\"\n print \"their start attributes reset to one.\"\n print \"\"\n print \"Trying to solve the system again...\"\n else:\n raise KINSOL_Exception(\"Regularization failed due to constraints, tried getting heuristic initial guess but failed.\")\n \n\n elif (error.value == 2):\n print \"---------------------------------------------------------\"\n print \"\"\n print \" !!! WARNING !!!\"\n print \"\"\n print \" KINSOL has returned a result but the algorithm has converged\"\n print \" to a local minima, the initial values are NOT consistant!\"\n print \"\"\n print \"---------------------------------------------------------\"\n solved = True\n local_min = True\n else:\n # Other error, send onward as exception\n self.problem.check_constraints(res)\n raise KINSOL_Exception(error.msg[error.value])\n \n if not solved:\n self.solver.Free_KINSOL()\n raise KINSOL_Exception(\"Algorithm exited solution loop without finding a solution, please contact Assimulo support.\")\n\n if self.check_with_model:\n self.problem.check_constraints(res)\n if not local_min:\n print \"Problem sent to KINSOL solved.\"\n \n return res","def calibrate(self):\n self.gripper_io.set_signal_value(\"calibrate\", True)\n success = intera_dataflow.wait_for(\n lambda: self.is_calibrated(),\n timeout=5.0,\n raise_on_error=False\n )\n if not success:\n rospy.logerr(\"({0}) calibration failed.\".format(self.name))\n return success","def one_step(self):\r\n assert (self.uv_vol is not None)\r\n assert (self.guv_vol is not None)\r\n assert (self.uv_bound is not None)\r\n assert (self.vf_vect_bound is not None)\r\n assert (self.vF_vect_vol is not None)\r\n # Shape checks\r\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\r\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\r\n assert (self.vF_vect_vol.shape == self.vf_vect_bound.shape)\r\n assert (self.uv_vol.shape[0] == self.uv_vol.shape[1])\r\n assert (self.uv_vol.shape == self.guv_vol.shape)\r\n assert (self.uv_vol.shape == self.uv_bound.shape)\r\n assert (self.uv_vol.shape[0] == self.vF_vect_vol.shape[0])\r\n \r\n if self.step == 0:\r\n self.check_k_matrix_stability()\r\n # print(\"Epsilon is :\"+str(self.Epsilon))\r\n # print(\"Beta is :\"+str(self.Beta))\r\n\r\n # Form \"Stiffness\" matrix:\r\n K = self.make_k_matrix()\r\n # Form \"Force\" vector: \r\n f = self.vF_vect_vol + (self.Epsilon / self.Beta) * self.vf_vect_bound\r\n\r\n # print(\"FORCE VECTOR:\")\r\n # print(f)\r\n # print(\"STIFFNESS MATRIX\")\r\n # print(K)\r\n # print(\"UV_VOL\")\r\n # print(self.uv_vol)\r\n # print(\"EPSILON * GUV_VOL\")\r\n # print(self.Epsilon * self.guv_vol)\r\n # print(\"UV_BOUND * COEFF\")\r\n # print((self.Epsilon / self.Beta) * self.uv_bound)\r\n sol = scipy_sparse_linsolve(K, f)\r\n # print(\"SOLUTION\")\r\n # print(sol)\r\n return sol","def calcIntrasec(self, gui):\n count = len(self.points)\n numpoints = (self.chessSize[0]*self.chessSize[1])\n\n #create matrices that are needed to compute calibration\n mat = cv.CreateMat(3,3,cv.CV_32FC1)\n distCoeffs = cv.CreateMat(4,1,cv.CV_32FC1)\n p3d = cv.CreateMat(count,3,cv.CV_32FC1) #compute 3D points\n p2d = cv.CreateMat(count,2,cv.CV_32FC1) #compute 2D points\n pointCounts = cv.CreateMat( self.nframe ,1,cv.CV_32SC1) #give numpoints per images\n cv.Set(pointCounts,numpoints)\n rvecs = cv.CreateMat(self.nframe,3,cv.CV_32FC1)\n tvecs = cv.CreateMat(self.nframe,3,cv.CV_32FC1)\n\n i = 0\n row = 0\n col = 0\n cv.Set(p3d,0.0) #to set every values to 0.0... and not set Z value\n\n #this compute points in row and cols...\n for p in self.points:\n p2d[i,0] = p[0]\n p2d[i,1] = p[1]\n \n p3d[i,0] = col\n p3d[i,1] = row\n col+=1\n if col >= self.chessSize[0]: \n row+=1\n col=0\n if row >= self.chessSize[1]:\n row = 0\n i+=1\n\n #and now, calibrate...\n cv.CalibrateCamera2(p3d, p2d, pointCounts, self.framesize, mat, distCoeffs, rvecs, tvecs, flags=0)\n gui.setMessage(\"Intrasinc camera parameters checked\")\n\n return (mat, distCoeffs)","def solveOneStep(self):\n ### Student code goes here\n return True","def _calibrate(self, Otrain, Ftrain, Feval):\n raise NotImplementedError()","def calibrate(self, master):\n if master.polyorder == 'linear':\n self.fitfunction = \"A0 + A1 * D\"\n self.fit_fkt = self.calc_lin\n elif master.polyorder == 'quadratic':\n self.fit_fkt = self.calc_quad\n self.fitfunction = \"A0 + A1 * D + A2 * D**2\"\n elif master.polyorder == \"cubic\":\n self.fitfunction = \"A0 + A1 * D + A2 * D**2 + A3 * D**3\"\n self.fit_fkt = self.calc_cubic\n else:\n print(\"Polynomgrad nicht definiert\")\n \n self.mw = np.asarray(self.mw)\n if master.sensortype == \"Druck\":\n self.best, self.covar = curve_fit(self.fit_fkt, self.mw, master.Referencedata.caldat)\n else:\n print(\"Sensortyp noch nicht Hinterlegt\")","def solve(self):\n ...","def solve(self):\n pass","def solve(self):\n pass","def do_calibration(self):\n goal = CalculateParametersGoal()\n self.calibrate_client.send_goal(goal)\n self.calibrate_client.wait_for_result()\n result = self.calibrate_client.get_result()\n rospy.loginfo('Received the calibration results')\n if result.number_of_images is 0:\n rospy.logerr('Failed to calibrate the camera.')\n else:\n rospy.loginfo('Number of pictures: {}, error: {}'.format(result.number_of_images, result.error))\n self.save_calibration_parameters(result.intrinsics, result.error, result.number_of_images)","def get_sol(self):","def calibrate(self):\n if self.iCAL_required:\n logger.info(\"iCAL-sensitive registers were modified, performing calibration...\")\n return self._run_ical()\n else:\n logger.info(\"iCAL-sensitive registers were not modified, skipping calibration...\")\n return 0 # Still success","def calibrate(self):\n\t\tLTOGRIGHT = []\n\t\tLTOGUP = []\n\t\tRTOGRIGHT = []\n\t\tRTOGUP = []\n\t\tstart = time.time()\n\t\tcalibration_time = 5.0\n\t\twhile time.time() - start < calibration_time:\n\t\t\tevents = pygame.event.get()\n\t\t\tfor event in events:\n\t\t\t\tif event.type == pygame.JOYAXISMOTION:\n\t\t\t\t\tLTOGRIGHT.append(self.joystick.get_axis(self.LTOGRIGHT))\n\t\t\t\t\tLTOGUP.append(-self.joystick.get_axis(self.LTOGUP))\n\t\t\t\t\tRTOGRIGHT.append(self.joystick.get_axis(self.RTOGRIGHT))\n\t\t\t\t\tRTOGUP.append(-self.joystick.get_axis(self.RTOGUP))\n\n\t\t# calibration sets highest value equal to 1.0\n\t\tself.calibration[0] = 1.0/max(LTOGRIGHT)\n\t\tself.calibration[1] = -1.0/min(LTOGRIGHT)\n\t\tself.calibration[2] = -1.0/min(LTOGUP)\n\t\tself.calibration[3] = 1.0/max(LTOGUP)\n\t\tself.calibration[4] = 1.0/max(RTOGRIGHT)\n\t\tself.calibration[5] = -1.0/min(RTOGRIGHT)\n\t\tself.calibration[6] = -1.0/min(RTOGUP)\n\t\tself.calibration[7] = 1.0/max(RTOGUP)","def converged(self) -> bool:","def converged(self) -> bool:","def converged(self) -> bool:","def evaluate_solution(still_x, still_y, still_z, still_n, calibration_parameters, still_temperature=None):\n\n # Temporarily adjust the channels of still data, which has collapsed x,y,z values\n do_calibration(still_x, still_y, still_z, still_temperature, calibration_parameters)\n\n # Get the VM of the calibrated channel\n vm = infer_vector_magnitude(still_x, still_y, still_z)\n\n # se = sum error\n se = 0.0\n\n for vm_val,n in zip(vm.data, still_n.data):\n se += (abs(1.0 - vm_val)**2)*n\n\n rmse = math.sqrt(se / len(vm.data))\n\n # Undo the temporary calibration\n undo_calibration(still_x, still_y, still_z, still_temperature, calibration_parameters)\n\n return rmse","def solvate(self):\n\n pass","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 analyse(self):\n self.__try_fitting()\n self.second.rotate()\n self.__try_fitting()","def _advance_settings(self, sol):\r\n if self.cond == True:\r\n # Save last solution...\r\n self.lst_tmp = sol\r\n # Check if all timesteps are complete.\r\n self.current_T += self.d_T\r\n self.step += 1\r\n if self.current_T > self.max_T:\r\n return False\r\n # Set to not be conduction any more\r\n self.cond = False\r\n if len(self.fq_list) > 0:\r\n self.rad = 0\r\n else:\r\n # There are radiation steps to do.\r\n self.cond = True\r\n return True\r\n\r\n # If we're here, we're either not done anything yet or have\r\n # just done a radiation step.\r\n if self.rad != None:\r\n # Save last solution\r\n self.lst_rad[self.rad] = sol\r\n # Advance to next radiation stage if one exists. Else cond.\r\n if self.rad + 1 != len(self.fq_list):\r\n self.rad += 1\r\n else:\r\n self.rad = None\r\n self.cond = True\r\n return True\r\n\r\n # If we've made it to here, we must just setting the simulation\r\n # going.\r\n assert (len(self.fq_list) == len(self.lst_rad))\r\n if len(self.lst_rad) > 0:\r\n assert (len(self.fq_list) == len(self.absorb_coeffs))\r\n assert (self.refr_idx_vol >= 0.0)\r\n # Could set to zero, but that might limit restarts. Just check\r\n # Validity....\r\n assert (self.step != None)\r\n assert (self.d_T > 0.0)\r\n assert (self.current_T != None)\r\n assert (self.max_T != None)\r\n assert (self.max_T > self.current_T)\r\n assert (self.diff_scale >= 0.0)\r\n assert (self.diff_scale <= 1.0)\r\n assert (self.thermal_conductivity > 0.0)\r\n assert (self.alpha >= 0.0)\r\n assert (self.refr_idx_background >= 0.0)\r\n # Set the ball rolling:\r\n if len(self.fq_list) > 0:\r\n # We can set solver for frequencies first...\r\n self.rad = 0\r\n else:\r\n self.cond = True\r\n return True","def solve(self, regparam):\n self.regparam = regparam\n \n #Some counters for bookkeeping\n self.stepcounter = 0\n self.flipcounter = 0\n self.nochangecounter = 0\n \n #Cached results\n self.evals = np.multiply(self.svals, self.svals)\n self.newevals = 1. / (self.evals + self.regparam)\n newevalslamtilde = np.multiply(self.evals, self.newevals)\n self.D = np.sqrt(newevalslamtilde)\n #self.D = -newevalslamtilde\n \n self.VTY = self.svecs.T * self.Y\n DVTY = np.multiply(self.D.T, self.svecs.T * self.Y)\n \n #Using lists in order to avoid unnecessary matrix slicings\n self.DVTY_list = []\n self.YTVDDVTY_list = []\n self.classFitnessList = []\n for i in range(self.labelcount):\n DVTY_i = DVTY[:,i]\n self.DVTY_list.append(DVTY_i)\n YTVDDVTY_i = DVTY_i.T * DVTY_i\n self.YTVDDVTY_list.append(YTVDDVTY_i)\n fitness_i = self.size - DVTY_i.T * DVTY_i\n self.classFitnessList.append(fitness_i)\n \n self.Dsvecs_list = []\n self.svecsDDsvecs_list = []\n for i in range(self.size):\n Dsvec = np.multiply(self.D.T, self.svecs[i].T)\n self.Dsvecs_list.append(Dsvec)\n self.svecsDDsvecs_list.append(Dsvec.T*Dsvec)\n \n self.updateA()\n \n \n converged = False\n print(self.classcounts.T)\n if self.callbackfun is not None:\n self.callbackfun.callback(self)\n while True:\n \n converged = self.roundRobin()\n print(self.classcounts.T)\n if self.callbackfun is not None:\n self.callbackfun.callback(self)\n if converged: break\n \n if self.oneclass:\n self.Y = self.Y[:, 0]\n self.A = self.A[:, 0]\n self.results['predicted_clusters_for_training_data'] = self.Y\n self.predictor = self.svdad.createModel(self)","def _calibration_test(self, dataset_name):\n self.setup_flags()\n test_setup = self._get_setup(dataset_name)\n if test_setup[\"error_test\"]:\n self._calibration_error_test(dataset_name, \"Calibration\")\n else:\n self.run_app(\"Calibration\")\n record = parse_calibration_results(\n self.io_args.log_dir, bin_name=\"Calibration\"\n )\n self.check_metrics(record, test_setup)","def safe_calibrate(self):\n\n status = -1\n while status < 3:\n ifMutexAcquire(self.use_mutex)\n try:\n new_status = self.BNO055.get_calibration_status()[3]\n except:\n new_status = -1\n finally:\n ifMutexRelease(self.use_mutex)\n if new_status != status:\n status = new_status","def calibrate(self, x, y) -> None:\n pass","def solve(self):\n\n # sanity check\n if self.G is None or self.curve is None or self.Q is None:\n print(\"Can't solve not all parameters are set\")\n return False # unsuccessful\n\n self.count = 1 # initial count\n self.start = time.time()\n\n order = self.curve.order(self.G) # get order of generator\n\n ############ POLLARD'S RHO + FLOYD'S EXTENSION ############\n found = False\n\n # will probably find a factor, so need to loop with random numbers until we find it\n while not found:\n\n ############ GENERATE RANDOM FUNCTION POINTS ############\n points = [] # list of points to inform our random function\n\n for _ in range(17):\n a = secrets.randbelow(order)\n b = secrets.randbelow(order)\n P = (self.G * a) + (self.Q * b) # linear combination\n points.append([P, a, b]) # add to list\n\n ############ RANDOM START POINTS ############\n Y, aY, bY = X, aX, bX = points.pop() # random starting points\n\n ############ FLOYD'S CYCLE DETECTION ############\n while not found:\n X, aX, bX = g((X, aX, bX), order, points) # first runner\n Y, aY, bY = g(g((Y,aY,bY),order,points),order,points) # second runner\n\n found = X == Y # detect match\n self.count += 1 # increment count\n\n if bX == bY and aX == aY: # if we arrive at identical combinations\n found = False # reset and try again\n else:\n inv = modInverse((bX - bY) % order, order) # get mod inverse\n\n if inv == 0: # if no mod inverse exists\n found = False # need to randomly try again\n else: # we have found k\n self.k = ((aY - aX) * inv) % order # so set it\n\n if self.G * self.k != self.Q: # not always 100% going to work\n print(\"error\")\n found = True\n\n self.time = time.time() - self.start\n\n # set space\n self.space = 18\n\n if self.verbose:\n print(\"k:\", self.k)\n print(\"Time taken: %.3f s\" % (self.time)) # print time taken\n print(\"Space used: %d\" % (self.space)) # print space used\n print(\"Numbers checked:\", self.count) # print total count\n\n return True","def method1(self):\n cres=0. # Variable for storing Chern number.\n # The U matrices from Fukui's method; storage...\n Ux=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n Uy=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n \n # ... and calculation of U matrices\n for ix in range(self.kS.Nx+1):\n for iy in range(self.kS.Ny+1):\n mat1=self.alleigvecs[:,:,ix ,iy ]\n if ix<self.kS.Nx:\n mat2=self.alleigvecs[:,:,ix+1,iy ]\n else:\n mat2=self.alleigvecs[:,:,1 ,iy ]\n if iy<self.kS.Ny:\n mat3=self.alleigvecs[:,:,ix ,iy+1]\n else:\n mat3=self.alleigvecs[:,:,ix ,1 ]\n Ux[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat2)[:self.NL,:self.NL])\n Uy[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat3)[:self.NL,:self.NL])\n \n # Local estimates of Berry curvature; storage ...\n ftempall=np.zeros((self.kS.Nx,self.kS.Ny),complex)\n # ... and calculation\n for ix in range(self.kS.Nx):\n for iy in range(self.kS.Ny):\n ftemp=np.log(Ux[ix,iy]*Uy[ix+1,iy]/Ux[ix,iy+1]/Uy[ix,iy])\n ftempall[ix,iy]=ftemp # ... of local Berry curvature ...\n cres+=ftemp/2./pi/1j # ... and of Berry phase (Chern number).\n\n return cres.real, ftempall","def solve_VFI(self):\r\n dimC = self.dimA ; dimA = self.dimA ; dimW = self.dimW \r\n C = self.c_grid ; A = self.a_grid ; W = self.W_grid\r\n tol = self.tol ; Niter = self.Niter ; R = self.R\r\n beta = self.beta ; Pi = self.Pi\r\n \r\n V0 = np.zeros((dimA,dimC,dimW))\r\n V1 = np.zeros((dimA,dimC,dimW))\r\n Pol = np.zeros((dimA,dimC,dimW))\r\n U = np.zeros((dimA,dimC,dimW))\r\n \r\n t0 = time()\r\n diff = 1 ; niter = 0\r\n \r\n while diff > tol:\r\n niter += 1\r\n # Value update step\r\n for ia in range(dimA):\r\n for ic in range(dimC):\r\n for iw in range(dimW):\r\n c = W[iw] + R*A[ia] - A\r\n x = C[ic]\r\n \r\n c[c < 0] = np.nan \r\n if x < 0:\r\n x = np.nan\r\n \r\n u = self.u(c,x) \r\n U[:,ic,iw] = u \r\n \r\n Objective = U + beta * V0 @ Pi.T\r\n V1[ia,:,:] = np.nanmax(Objective, axis = 0)\r\n Pol[ia,:,:] = np.nanargmax(Objective, axis = 0)\r\n \r\n # Evaluate distance between the value functions\r\n diff = np.max(np.max(np.abs(V1 - V0))) \r\n V0[:] = V1\r\n \r\n # Break the while loop if too many iterations\r\n #print(\"The current error is \"+str(diff))\r\n if niter > Niter:\r\n print('Ops, no convergence')\r\n break\r\n \r\n t1 = time()\r\n #print('VFI algorithm took {0:0d} iterations and {1:.2f} seconds.'.format(niter, t1 - t0))\r\n \r\n self.V1 = V1 ; self.Pol = Pol","def automatic_results(self):\n self.find_coefficients()\n self.calculate_numerical_solution()\n self.plot_solution()\n self.L2_norm()","def checkSolution(self):\n movesToEndblock = self.gridSize - self.changeable[0] - 2\n if self.checkMove(0,movesToEndblock) == 0:\n return 0\n return 1","def run(self):\n #self.source_fixed = center_of_mass(self.source_mesh.vs)\n #self.destination_fixed = center_of_mass(self.destination_mesh.vs)\n\n source_high_curvature = get_mesh_of_high_curvature(self.source_mesh)\n destination_high_curvature = get_mesh_of_high_curvature(self.destination_mesh)\n\n self.matrix, error = icp(source_high_curvature.vs, \n destination_high_curvature.vs, \n self.source_fixed, \n self.destination_fixed,\n 300,\n verbose = self.verbose)\n\n self.inverse = np.linalg.inv(self.matrix)\n self.global_confidence = 1 - error\n print self.global_confidence","def _check_init_solution(self):\r\n B = np.array([self._A[:, j] for j in self._basic_vars]).transpose()\r\n self._B_inv = np.linalg.inv(B)\r\n x_B = self._B_inv @ self._b\r\n for x in x_B:\r\n if x < 0:\r\n raise AssertionError(\"Initial solution is not feasible!\")","def fit(self):\n self._minuit_problem.migrad() # run optimizer\n self._status = 0 if self._minuit_problem.migrad_ok() else 1","def calibrate(self):\n\n self.update_message('Calibrating platform...')\n\n self.calibrate_platform()\n\n self.update_message('Platform Calibrated.')\n\n # calibrate arm x axis\n self.update_message('Calibrating x axis...')\n calibrated = self.calibrate_arm(0)\n\n if not calibrated:\n self.update_message('ERROR: Could not calibrate x axis.')\n return 0\n else:\n self.update_message('x axis calibrated.')\n\n # calibrate arm y axis\n self.update_message('Calibrating y axis...')\n calibrated = self.calibrate_arm(1)\n\n if not calibrated:\n self.update_message('ERROR: Could not calibrate y axis.')\n return 0\n else:\n self.update_message('y axis calibrated.')\n\n # calibrate arm z axis\n self.update_message('Calibrating z axis...')\n calibrated = self.calibrate_arm(2)\n\n if not calibrated:\n self.update_message('ERROR: Could not calibrate z axis.')\n return 0\n else:\n self.update_message('z axis calibrated.\\n'\n 'Autocalibration done.\\n'\n 'Accuracy: {}'.format(self.matrix_accuracy()))\n\n # Getting the direction to withdraw pipette along x axis\n self.get_withdraw_sign()\n self.inv_mat = np.linalg.inv(self.mat)\n self.calibrated = 1\n self.cam.click_on_window = True\n self.save_calibration()\n return 1","def calibrate(): \n \n # Calibrate of the run using beam data. Creates a folder cal-files/caltag \n # containing all calibration data. \n CalObj = Calibration(steerfiles=steerfiles, name=localcaltag + '-cal') \n\n # Set Beam energy\n CalObj.set_beam_momentum(beamenergy)\n\n # Get gearfile and set air as DUT material\n localgearfile = CalObj.get_filename('gear.xml')\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='thickness', value=0.0001)\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='radLength', value=304000.0)\n \n # Create list of calibration steps \n calpath = create_calibration_path(CalObj)\n \n # Run the calibration steps \n CalObj.calibrate(path=calpath,ifile=rawfile_air,caltag=localcaltag)","def convergence_on_track(self):\n\n on_track = True\n threshold = 5. # used to check condition if at least one of charnge_neutrality, rms-error goes down fast enough\n\n # first check if previous calculation was stopped due to reaching the QBOUND limit\n try:\n calc_reached_qbound = self.ctx.last_calc.outputs.output_parameters.get_dict(\n )['convergence_group']['calculation_converged']\n except AttributeError: # captures error when last_calc dies not have an output node\n calc_reached_qbound = False\n except KeyError: # captures\n calc_reached_qbound = False\n\n if self.ctx.kkrimp_step_success and not calc_reached_qbound:\n first_rms = self.ctx.last_rms_all[0]\n # skip first if this is the initial LDA+U iteration because there we see the original non-LDAU convergence value\n if 'settings_LDAU' in self.inputs and self.ctx.loop_count < 2 and len(self.ctx.last_rms_all) > 1:\n first_rms = self.ctx.last_rms_all[1]\n last_rms = self.ctx.last_rms_all[-1]\n # use this trick to avoid division by zero\n if last_rms == 0:\n last_rms = 10**-16\n r = last_rms / first_rms\n message = f'INFO: convergence check: first/last rms {first_rms}, {last_rms}'\n self.report(message)\n if r < 1:\n message = 'INFO: convergence check: rms goes down'\n self.report(message)\n on_track = True\n elif r > threshold:\n message = 'INFO: convergence check: rms goes up too fast, convergence is not expected'\n self.report(message)\n on_track = False\n elif len(self.ctx.last_rms_all) == 1:\n message = 'INFO: convergence check: already converged after single iteration'\n self.report(message)\n on_track = True\n else:\n message = 'INFO: convergence check: rms does not shrink fast enough, convergence is not expected'\n self.report(message)\n on_track = False\n elif calc_reached_qbound:\n message = 'INFO: convergence check: calculation reached QBOUND'\n self.report(message)\n on_track = True\n else:\n message = 'INFO: convergence check: calculation unsuccessful'\n self.report(message)\n on_track = False\n\n message = f'INFO: convergence check result: {on_track}'\n self.report(message)\n\n return on_track","def start_solving(self):\n self.mesh.output_vtk_mesh(self.model_name + \"0\", \n [self.current_pressure, \n self.mesh.get_cell_domain_all()], \n [\"pressure\", \"domain\"])\n\n self.time_step_output(0., 0)\n\n for time_step in range(1,self.number_of_time_steps+1):\n current_time = time_step*self.delta_t\n print(time_step)\n\n self.update_pressure()\n self.find_upwinding_direction()\n self.update_concentration()\n \n if time_step%self.output_frequency == 0:\n self.mesh.output_vtk_mesh(self.model_name+str(time_step), \n [self.current_pressure,\n self.current_concentration, \n self.mesh.get_cell_domain_all()],\n [\"pressure\", \"concentration\" , \"domain\"])\n\n self.time_step_output(current_time, time_step)","def _calc_corrections(self): \n searchIter= self._niter-1\n while searchIter > 0:\n trySavefilename= self._createSavefilename(searchIter)\n if os.path.exists(trySavefilename):\n trySavefile= open(trySavefilename,'rb')\n corrections= sc.array(pickle.load(trySavefile))\n trySavefile.close()\n break\n else:\n searchIter-= 1\n if searchIter == 0:\n corrections= sc.ones((self._npoints,2))\n for ii in range(searchIter,self._niter):\n if ii == 0:\n currentDF= self._dftype(surfaceSigma=self._surfaceSigmaProfile,\n beta=self._beta)\n else:\n currentDF= self._dftype(surfaceSigma=self._surfaceSigmaProfile,\n beta=self._beta,\n corrections=corrections,\n npoints=self._npoints,\n rmax=self._rmax,\n savedir=self._savedir,\n interp_k=self._interp_k)\n newcorrections= sc.zeros((self._npoints,2))\n for jj in range(self._npoints):\n thisSurface= currentDF.surfacemass(self._rs[jj],\n use_physical=False)\n newcorrections[jj,0]= currentDF.targetSurfacemass(self._rs[jj],use_physical=False)/thisSurface\n newcorrections[jj,1]= currentDF.targetSigma2(self._rs[jj],use_physical=False)*thisSurface\\\n /currentDF.sigma2surfacemass(self._rs[jj],\n use_physical=False)\n #print(jj, newcorrections[jj,:])\n corrections*= newcorrections\n #Save\n picklethis= []\n for arr in list(corrections):\n picklethis.append([float(a) for a in arr])\n save_pickles(self._savefilename,picklethis) #We pickle a list for platform-independence)\n return corrections","def calibration(self, pulse_min: int, pulse_max: int, pulse_centre: int, /) -> None:","def calibration(N,kb,T,Ekinv,V):\n lamb = np.sqrt((N-1)*3*kb*T/(Ekinv*2))\n \n if lamb < 0.9999:\n V = lamb*V\n elif lamb>1.0001:\n V = lamb*V\n \n return V","def solve(self):\n converged = False\n N = 500\n x = np.linspace(-100.0, 100.0, N)\n y = np.linspace(-100.0, 100.0, N)\n X, Y = np.meshgrid(x,y)\n Z = function.evaluate(X,Y)\n fileadd = 0;\n while not converged:\n plt.hold(False)\n plt.contour(X, Y, Z)\n plt.show()\n self.update()\n isconverged = self.checkConvergence(self.iteration)\n converged = isconverged[0] #set to boolean result\n self.iteration += 1\n if self.disp:\n pylab.savefig('single_plot_%s.jpg' %('0'*(3-len(str(fileadd))) + str(fileadd))) # If display is turned on, save figure for visualization\n fileadd += 1\n return [self.overBestPos, self.overBestVal, isconverged[1]]","def test_get_solution(self):\n pass","def _compute_results(self):\n self.Y_best = best_value(self.Y)\n self.x_opt = self.X[np.argmin(self.Y),:]\n self.fx_opt = np.min(self.Y)\n self.distance = self._compute_distance_betw_consecutive_x()","def force_calibration_controller_test():\n print(f\"Running {__file__}::{force_calibration_controller_test.__name__}()\")\n arm_state = State()\n alpha=0.2\n ctrl = EMAForceCalibrator(Connection(arm_state), alpha=alpha)\n cmd = Command()\n state = State()\n ctrl.execute(cmd, state)\n assert np.all(ctrl.force_average.array == 0)\n\n arm_state.sensor_force()[:] = [2,2,2,2,2,2]\n ctrl.execute(cmd, state)\n assert np.all(ctrl.force_average.array != 0)\n assert state.sensor_force().allclose(np.array([2,2,2,2,2,2])*(1-alpha), 0.001)\n\n for i in range(100):\n ctrl.execute(cmd, state)\n assert ctrl.force_average.allclose([2,2,2,2,2,2], 0.001)\n assert state.sensor_force().allclose([0,0,0,0,0,0], 0.001)\n\n arm_state.sensor_force()[:] = [0,0,0,0,0,0]\n ctrl.execute(cmd, state)\n assert state.sensor_force().allclose(np.array([-2,-2,-2,-2,-2,-2])*(1-alpha), 0.001)\n\n for i in range(100):\n ctrl.execute(cmd, state)\n assert ctrl.force_average.allclose([0,0,0,0,0,0], 0.001)\n assert state.sensor_force().allclose([0,0,0,0,0,0], 0.001)\n\n print(\"Passed.\")","def _compute_correction(self, initial_state, final_state, a, b, c, s):\r\n pertub = self.pertub\r\n pertub_s = pertub *10\r\n \r\n pred_no_pertub = self._motion_update_one_shot(initial_state, a, b, c, s)\r\n pred_pertub_a = self._motion_update_one_shot(initial_state, a +pertub, b, c, s)\r\n pred_pertub_b = self._motion_update_one_shot(initial_state, a, b +pertub, c, s)\r\n # no need to correct C, C is constrained by kappa_final\r\n # # pred_pertub_c = self._motion_update_one_shot(initial_state, a, b, c +pertub, s)\r\n pred_pertub_s = self._motion_update_one_shot(initial_state, a, b, c, s +pertub_s)\r\n\r\n d_state = np.zeros((3,1))\r\n d_pertub_state = np.zeros((3,3))\r\n Jacobian = np.zeros((3,3))\r\n for i in range(0, 3):\r\n d_pertub_state[i][0] = (final_state[i] - pred_pertub_a[i]) # a\r\n d_pertub_state[i][1] = (final_state[i] - pred_pertub_b[i]) # b\r\n # d_pertub_state[i][2] = (final_state[i] - pred_pertub_c[i]) # c (no update)\r\n d_pertub_state[i][2] = (final_state[i] - pred_pertub_s[i]) # s\r\n \r\n d_state[i] = final_state[i] - pred_no_pertub[i]\r\n \r\n Jacobian[i][0] = (d_pertub_state[i][0] - d_state[i])/pertub # a\r\n Jacobian[i][1] = (d_pertub_state[i][1] - d_state[i])/pertub # b\r\n # Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub # c (no update)\r\n Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub_s # s\r\n\r\n # inv_Jacobian = np.linalg.inv(Jacobian)\r\n inv_Jacobian = np.linalg.pinv(Jacobian)\r\n correction = np.dot(inv_Jacobian, d_state)\r\n # pdb.set_trace()\r\n return correction","def solve(self):\n if not self.solvable:\n print('Suduko not Solvable')\n return False\n res=self.back(0, 0)\n # if self.a[0][0]!=0:\n # res=self.back(0, 1)\n # else:\n # for i in range(1, 10):\n # self.a[0][0]=i\n # res=self.back(0, 1)\n # if res:\n # break\n if res:\n self.check_if_solvable()\n print(\"Sudoku Solved!\")\n print(self.a)\n return self.a\n else: print(\"Not Solvable\")\n return False","def calibration(exp, args):\n show_text(\"Nous allons faire un calibrage\", args).present()\n exp.clock.wait(1500)\n expyriment.stimuli.FixCross(size=(25, 25),\n line_width=3,\n colour=args[\"stimuli_color\"]).present()\n exp.clock.wait(2100)","def solve(self):\n for x in range(9):\n for y in range(9):\n if self.arr[x][y] == 0:\n for value in range(1,10):\n if self.is_possible_value(x,y,value):\n self.arr[x][y] = value\n self.solve()\n self.arr[x][y] = 0 \n return\n print(np.matrix(self.arr))","def _calibrate_camera():\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)\n vertical, horizon = 7, 9 # target corners in vertical and horizontal direction\n\n grid = np.zeros((vertical * horizon, 3), np.float32)\n grid[:, :2] = np.mgrid[:horizon, :vertical].T.reshape(-1, 2)\n\n obj_points = [] # 3d point in real world space\n img_points = [] # 2d points in image plane\n\n image_list = glob.glob(os.path.join('C:\\\\Users\\\\chuyangl\\\\Desktop\\\\liushuai\\\\calibrator\\\\board\\\\right', \"*.bmp\"))\n #print(image_list)\n gray = None\n for img_name in image_list:\n print(img_name)\n image = cv2.imread(img_name)\n gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n\n # find the chess board corners\n found, corners = cv2.findChessboardCorners(gray, (horizon, vertical), None)\n #print(\"corner shape\",corners.shape,corners)\n\n # add object points, image points (after refining them)\n if found:\n obj_points.append(grid)\n corners = cv2.cornerSubPix(gray, corners, (5, 5), (-1, -1), criteria) #corner是像素坐标 refine 坐标\n img_points.append(corners)\n #print(\"corner shape\",corners.shape,corners)\n else:\n print('can not find %s corners' % img_name)\n\n #print(corners)\n #print(grid)\n ret, matrix, distortion, rotation, translation = \\\n cv2.calibrateCamera(obj_points, img_points, gray.shape[::-1], None, None)\n print(type(img_points[0]),img_points[0].shape,img_points[0])\n print(type(obj_points[0]),obj_points[0].shape,obj_points[0]) \n #cv2.calibrateCamera([obj_points[-1]], [img_points[-1]], gray.shape[::-1], None, None)\n #print(\"RT Matrix\",np.array(rotation).shape,np.array(translation).shape,rotation)\n \n print(\"projMtx:\\n\",getProjMtx(np.array(rotation[0]),np.array(translation[0])))\n projMtx = getProjMtx(np.array(rotation[0]),np.array(translation[0]))\n _3d = np.array([8,0,0,1])\n _2d = np.dot(np.dot(matrix,projMtx,),_3d)\n _2d = _2d/_2d[2]\n print(\"2d:\",_2d,img_points[0][7])\n mean_error = 0\n for i in range(len(obj_points)):\n new_img_points, _ = cv2.projectPoints(obj_points[i], rotation[i], translation[i], matrix, distortion)#3D点投影到平面\n error = cv2.norm(img_points[i], new_img_points, cv2.NORM_L2) / len(new_img_points)\n mean_error += error\n print(\"new and old:\",new_img_points[1],img_points[i][1])\n print(\"mean error: \", mean_error / len(obj_points))\n\n return np.array(matrix), np.array(distortion)","def run(self):\n\n # Initializing required variables for the algorithm\n start = time.time()\n i = 0\n w = self.w\n k = 99.99\n\n #Running the algorithm till tolerance is reached\n while k > self.tolerance: \n\n i = i + 1\n\n if self.verbose:\n print(\"Iteration \" + str(i),end=\"\\r\")\n\n # Following is a gradient descent algorithm\n # You can find the update step at the following\n # link, https://raw.githubusercontent.com/mnk400/linearRegression/master/img/EUC.png\n t_0 = w.T.dot(w)\n t_1 = self.x.T.dot(self.x).dot(w)\n gradient = (2/t_0) * (t_1) - (2/t_0**2) * np.transpose(w).dot(t_1) * (w)\n w_new = w - (1/self.DATAPOINTS) * 0.3 * gradient\n w_new[-1] = -1\n l = len(self.x[0]) - 1 \n y_plt = np.dot(self.x[:,0:l],w_new[:-1]) \n\n #tolerance is checked against the root mean square of change in weights\n k = np.dot(np.transpose(w - w_new),(w - w_new))\n\n #Updating the weights \n w = w_new\n\n if self.verbose:\n print(\"Tolerance Reached\")\n timetaken = round(time.time() - start, 3)\n print(\"Ran for \" + str(timetaken) + \" seconds\" + \" in \" + str(i) + \" iterations.\")\n\n return w_new, y_plt","def calibrate(self):\n\t\t\n\t\t# CALIBRATION\n\t\t# determine the calibration points\n\t\tcalibpoints = []\n\t\tfor x in [0.1,0.5,0.9]:\n\t\t\tfor y in [0.1,0.5,0.9]:\n\t\t\t\tcalibpoints.append((int(x*self.dispsize[0]),int(y*self.dispsize[1])))\n\t\trandom.shuffle(calibpoints)\n\t\t\n\t\t# show a message\n\t\tself.screen.clear()\n\t\tself.screen.draw_text(\n\t\t\ttext=\"Press Space to calibrate, S to skip, and Q to quit\",\n\t\t\tfontsize=20)\n\t\tself.disp.fill(self.screen)\n\t\tself.disp.show()\n\t\t\n\t\t# wait for keyboard input\n\t\tkey, keytime = self.kb.get_key(keylist=['q', 's', 'space'],\n\t\t\ttimeout=None, flush=True)\n\t\tif key == 's':\n\t\t\treturn True\n\t\tif key == 'q':\n\t\t\tquited = True\n\t\telse:\n\t\t\tquited = False\n\t\t\n\t\t# Pause the processing of samples during the calibration.\n#\t\tself.eyetribe._pause_sample_processing()\n\t\t# run until the user is statisfied, or quits\n\t\tcalibrated = False\n\t\tcalibresult = None\n\t\twhile not quited and not calibrated:\n\n\t\t\t# Clear the existing calibration.\n\t\t\tif self.eyetribe._tracker.get_iscalibrated():\n\t\t\t\tself.eyetribe._lock.acquire(True)\n\t\t\t\tself.eyetribe.calibration.clear()\n\t\t\t\tself.eyetribe._lock.release()\n\t\t\t\n\t\t\t# Wait for a bit.\n\t\t\tclock.pause(1500)\n\n\t\t\t# start a new calibration\n\t\t\tif not self.eyetribe._tracker.get_iscalibrating():\n\t\t\t\tself.eyetribe._lock.acquire(True)\n\t\t\t\tself.eyetribe.calibration.start(pointcount=len(calibpoints))\n\t\t\t\tself.eyetribe._lock.release()\n\t\t\t\n\t\t\t# loop through calibration points\n\t\t\tfor cpos in calibpoints:\n\t\t\t\t# Check whether the calibration is already done.\n\t\t\t\t# (Not sure how or why, but for some reason some data\n\t\t\t\t# can persist between calbrations, and the tracker will\n\t\t\t\t# simply stop allowing further pointstart requests.)\n\t\t\t\tif self.eyetribe._tracker.get_iscalibrated():\n\t\t\t\t\tbreak\n\t\t\t\t\n\t\t\t\t# Draw a calibration target.\n\t\t\t\tself.draw_calibration_target(cpos[0], cpos[1])\n\t\t\t\t# wait for a bit to allow participant to start looking at\n\t\t\t\t# the calibration point (#TODO: space press?)\n\t\t\t\tclock.pause(settings.EYETRIBEPRECALIBDUR)\n\t\t\t\t# start calibration of point\n\t\t\t\tself.eyetribe._lock.acquire(True)\n\t\t\t\tself.eyetribe.calibration.pointstart(cpos[0],cpos[1])\n\t\t\t\tself.eyetribe._lock.release()\n\t\t\t\t# wait for a second\n\t\t\t\tclock.pause(settings.EYETRIBECALIBDUR)\n\t\t\t\t# stop calibration of this point\n\t\t\t\tself.eyetribe._lock.acquire(True)\n\t\t\t\tself.eyetribe.calibration.pointend()\n\t\t\t\tself.eyetribe._lock.release()\n\t\t\t\t# check if the Q key has been pressed\n\t\t\t\tif self.kb.get_key(keylist=['q'],timeout=10,flush=False)[0] == 'q':\n\t\t\t\t\t# abort calibration\n\t\t\t\t\tself.eyetribe._lock.acquire(True)\n\t\t\t\t\tself.eyetribe.calibration.abort()\n\t\t\t\t\tself.eyetribe._lock.release()\n\t\t\t\t\t# set quited variable and break this for loop\n\t\t\t\t\tquited = True\n\t\t\t\t\tbreak\n\t\t\t\n\t\t\t# retry option if the calibration was aborted\t\t\t\n\t\t\tif quited:\n\t\t\t\t# show retry message\n\t\t\t\tself.screen.clear()\n\t\t\t\tself.screen.draw_text(\n\t\t\t\t\t\"Calibration aborted. Press Space to restart or 'Q' to quit\",\n\t\t\t\t\tfontsize=20)\n\t\t\t\tself.disp.fill(self.screen)\n\t\t\t\tself.disp.show()\n\t\t\t\t# get input\n\t\t\t\tkey, keytime = self.kb.get_key(keylist=['q','space'], timeout=None, flush=True)\n\t\t\t\tif key == 'space':\n\t\t\t\t\t# unset quited Boolean\n\t\t\t\t\tquited = False\n\t\t\t\t# skip further processing\n\t\t\t\tcontinue\n\n\t\t\t# empty display\n\t\t\tself.disp.fill()\n\t\t\tself.disp.show()\n\t\t\t# allow for a bit of calculation time\n\t\t\t# (this is waaaaaay too much)\n\t\t\tclock.pause(1000)\n\t\t\t# get the calibration result\n\t\t\tself.eyetribe._lock.acquire(True)\n\t\t\tcalibresult = self.eyetribe._tracker.get_calibresult()\n\t\t\tself.eyetribe._lock.release()\n\n\t\t\t# results\n\t\t\t# clear the screen\n\t\t\tself.screen.clear()\n\t\t\t# draw results for each point\n\t\t\tif type(calibresult) == dict:\n\t\t\t\tfor p in calibresult['calibpoints']:\n\t\t\t\t\t# only draw the point if data was obtained\n\t\t\t\t\tif p['state'] > 0:\n\t\t\t\t\t\t# draw the mean error\n\t\t\t\t\t\t# self.screen.draw_circle(colour=(252,233,79),\n\t\t\t\t\t\t# \tpos=(p['cpx'],p['cpy']), r=p['mepix'], pw=0,\n\t\t\t\t\t\t# \tfill=True)\n\t\t\t\t\t\tself.screen.draw_line(spos=(p['cpx'],p['cpy']),\n\t\t\t\t\t\t\tepos=(p['mecpx'],p['mecpy']), pw=2)\n\t\t\t\t\t\t# draw the point\n\t\t\t\t\t\tself.screen.draw_fixation(fixtype='dot',\n\t\t\t\t\t\t\tcolour=(115,210,22), pos=(p['cpx'],p['cpy']))\n\t\t\t\t\t\t# draw the estimated point\n\t\t\t\t\t\tself.screen.draw_fixation(fixtype='dot',\n\t\t\t\t\t\t\tcolour=(32,74,135), pos=(p['mecpx'],p['mecpy']))\n\t\t\t\t\t\t# annotate accuracy\n\t\t\t\t\t\tself.screen.draw_text(text='%.2f' % p['acd'],\n\t\t\t\t\t\t\tpos=(p['cpx']+10,p['cpy']+10), fontsize=20)\n\t\t\t\t\t# if no data was obtained, draw the point in red\n\t\t\t\t\telse:\n\t\t\t\t\t\tself.screen.draw_fixation(fixtype='dot',\n\t\t\t\t\t\t\tcolour=(204,0,0), pos=(p['cpx'],p['cpy']))\n\t\t\t\t# draw box for averages\n\t\t\t\t# self.screen.draw_rect(colour=(238,238,236), x=int(self.dispsize[0]*0.15), y=int(self.dispsize[1]*0.2), w=400, h=200, pw=0, fill=True)\n\t\t\t\t# draw result\n\t\t\t\tif calibresult['result']:\n\t\t\t\t\tself.screen.draw_text(text=\"Calibration successful\",\n\t\t\t\t\t\tcolour='green',\n\t\t\t\t\t\tpos=(int(self.dispsize[0]*0.5), int(self.dispsize[1]*0.25)), \n\t\t\t\t\t\tfontsize=20)\n\t\t\t\telse:\n\t\t\t\t\tself.screen.draw_text(text=\"Calibration failed\",\n\t\t\t\t\t\tcolour='red',\n\t\t\t\t\t\tpos=(int(self.dispsize[0]*0.5),int(self.dispsize[1]*0.25)),\n\t\t\t\t\t\tfontsize=20)\n\t\t\t\t# draw average accuracy\n\t\t\t\tself.screen.draw_text(\n\t\t\t\t\ttext=\"Average error = %.2f degrees\" % (calibresult['deg']),\n\t\t\t\t\tpos=(int(self.dispsize[0]*0.5),int(self.dispsize[1]*0.25+30)),\n\t\t\t\t\tfontsize=20)\n\t\t\t\t# draw input options\n\t\t\t\tself.screen.draw_text(\n\t\t\t\t\ttext=\"Press Space to continue or 'R' to restart\",\n\t\t\t\t\tpos=(int(self.dispsize[0]*0.5),int(self.dispsize[1]*0.25+60)),\n\t\t\t\t\tfontsize=20)\n\t\t\telse:\n\t\t\t\tself.screen.draw_text(\n\t\t\t\t\ttext=\"Calibration failed. Press 'R' to try again.\",\n\t\t\t\t\tfontsize=20)\n\t\t\t# show the results\n\t\t\tself.disp.fill(self.screen)\n\t\t\tself.disp.show()\n\t\t\t# wait for input\n\t\t\tkey, keytime = self.kb.get_key(keylist=['space','r'], timeout=None,\n\t\t\t\tflush=True)\n\t\t\t# process input\n\t\t\tif key == 'space':\n\t\t\t\tcalibrated = True\n\n\t\t# Continue the processing of samples after the calibration.\n#\t\tself.eyetribe._unpause_sample_processing()\n\n\t\t# calibration failed if the user quited\n\t\tif quited:\n\t\t\treturn False\n\n\t\t# NOISE CALIBRATION\n\t\t# get all error estimates (pixels)\n\t\tvar = []\n\t\tfor p in calibresult['calibpoints']:\n\t\t\t# only draw the point if data was obtained\n\t\t\tif p['state'] > 0:\n\t\t\t\tvar.append(p['mepix'])\n\t\tnoise = sum(var) / float(len(var))\n\t\tself.pxdsttresh = (noise, noise)\n\t\t\t\t\n\t\t# AFTERMATH\n\t\t# store some variables\n\t\tpixpercm = (self.dispsize[0]/float(self.screensize[0]) + self.dispsize[1]/float(self.screensize[1])) / 2\n\t\tscreendist = settings.SCREENDIST\n\t\t# calculate thresholds based on tracker settings\n\t\tself.accuracy = ((calibresult['Ldeg'],calibresult['Ldeg']), (calibresult['Rdeg'],calibresult['Rdeg'])) \n\t\tself.pxerrdist = deg2pix(screendist, self.errdist, pixpercm)\n\t\tself.pxfixtresh = deg2pix(screendist, self.fixtresh, pixpercm)\n\t\tself.pxaccuracy = ((deg2pix(screendist, self.accuracy[0][0], pixpercm),deg2pix(screendist, self.accuracy[0][1], pixpercm)), (deg2pix(screendist, self.accuracy[1][0], pixpercm),deg2pix(screendist, self.accuracy[1][1], pixpercm)))\n\t\tself.pxspdtresh = deg2pix(screendist, self.spdtresh/1000.0, pixpercm) # in pixels per millisecond\n\t\tself.pxacctresh = deg2pix(screendist, self.accthresh/1000.0, pixpercm) # in pixels per millisecond**2\n\n\t\t# calibration report\n\t\tself.log(\"pygaze calibration report start\")\n\t\tself.log(\"accuracy (degrees): LX=%s, LY=%s, RX=%s, RY=%s\" % (self.accuracy[0][0],self.accuracy[0][1],self.accuracy[1][0],self.accuracy[1][1]))\n\t\tself.log(\"accuracy (in pixels): LX=%s, LY=%s, RX=%s, RY=%s\" % (self.pxaccuracy[0][0],self.pxaccuracy[0][1],self.pxaccuracy[1][0],self.pxaccuracy[1][1]))\n\t\tself.log(\"precision (RMS noise in pixels): X=%s, Y=%s\" % (self.pxdsttresh[0],self.pxdsttresh[1]))\n\t\tself.log(\"distance between participant and display: %s cm\" % screendist)\n\t\tself.log(\"fixation threshold: %s pixels\" % self.pxfixtresh)\n\t\tself.log(\"speed threshold: %s pixels/ms\" % self.pxspdtresh)\n\t\tself.log(\"acceleration threshold: %s pixels/ms**2\" % self.pxacctresh)\n\t\tself.log(\"pygaze calibration report end\")\n\n\t\treturn True","def has_solution(self) -> bool:\n pass","def solve(self):\n \n raise NotImplementedError(\"not implemented!\")","def test_ackley(self):\n fun = get_problem('ackley', self.dimension)\n self.assertAlmostEqual(fun(self.array), 0.0, places=10)","def steering_calibration(self):\n\n # Minimum change of rotary encoder per 100 ms to detect stall\n min_difference = 5\n # Calibration motor power in percentage (absolute)\n calibration_power = 30\n\n print('Calibration of steering axis started')\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n last_pos = 99999999 # any super big number\n # Left turn calibration\n while abs(current_pos - last_pos) > min_difference:\n last_pos = current_pos\n self.brick_pi.set_motor_power(self.motor_steer, calibration_power)\n time.sleep(0.1)\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n\n self.brick_pi.set_motor_power(self.motor_steer, 0)\n time.sleep(0.1)\n print('Reset motor encoder after left turn: 0')\n self.brick_pi.reset_motor_encoder(self.motor_steer)\n\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n last_pos = 99999999 # any super big number\n # Right turn calibration\n while abs(current_pos - last_pos) > min_difference:\n last_pos = current_pos\n self.brick_pi.set_motor_power(self.motor_steer, -calibration_power)\n time.sleep(0.1)\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n\n self.brick_pi.set_motor_power(self.motor_steer, 0)\n time.sleep(0.1)\n self.brick_pi.offset_motor_encoder(self.motor_steer, current_pos / 2)\n self.steering_limit = abs(\n self.brick_pi.get_motor_encoder(self.motor_steer))\n print('Offset motor encoder after right turn: ' +\n str(self.brick_pi.get_motor_encoder(self.motor_steer)))\n\n self.brick_pi.set_motor_position(self.motor_steer, 0)\n print('Calibration of steering axis completed')","def solve(self):\n raise NotImplementedError(\"This method needs to be implemented.\")","def solve(self, solver):\n solver.solve()","def solve(self) -> jnp.ndarray:\n pass","def did_solve(self) -> bool:\n pass","def run(self):\n cpt = 1\n while cpt < (self.BOUND):\n cpt += 1\n self.incBound()\n\n res = self.s.check()\n if res == sat:\n m = self.s.model()\n self.checkModel(m)\n self.printModel(m)\n return\n else:\n print(\"The problem is UNSAT\")","def __call__(self):\n self.start()\n numberOfIterations, stateVectorConv = self.iterations()\n if numberOfIterations <= 1:\n self.answer = None\n raise DidNotConvergeWarning(\"Number of iterations <= 1.\")\n result = self.diagnostic(numberOfIterations, stateVectorConv)\n return result","def auto_correction(self):\n\n if self.mi_standard_fb is not None:\n try: \n is_st_fb_running = self.mi_standard_fb.is_running()\n except Exception as e:\n logger.warning(\"error during status of st. FB reading: \" + str(e))\n is_st_fb_running = False\n \n if self.mi_standard_fb is not None and is_st_fb_running:\n logger.info(\"auto_correction: St.FB is running. Stop Ad. FB\")\n self.stop_feedback()\n return 0\n \n is_nan = self.ref_orbit_calc()\n if is_nan:\n logger.warning(\"auto_correction: nan in the ref orbit. Pause 1 sec\")\n time.sleep(1)\n return\n\n start = time.time()\n stop_flag = self.correct()\n print(\"correct: \", time.time() - start)\n time.sleep(0.01)\n if not stop_flag:\n start = time.time()\n self.apply_kicks()\n print(\"apply_kicks: \", time.time() - start)\n self.sase_hist.append(self.target_filtered[-1])\n self.le_warn.clear()\n else:\n logger.warning(\"auto_correction: stop_flag = True. Pause 1 sec\")\n self.le_warn.clear()\n self.le_warn.setText(\"Stop flag. Kicks are not applied\")\n self.le_warn.setStyleSheet(\"color: red\")\n\n time.sleep(1)","def solve(self):\n measure = None\n while not self.step():\n self._nbSteps += 1\n measure = self.measure(lastMeasure=measure)","def find_reference(self, f, b, x_0, y_0, res=8e-3, calibrate_nr=3, confidence=0.7, plot=False):\n found = False\n counter = 0\n self.PG1['n_pts'] = f + b + 1\n self.PG2['n_pts'] = f + b + 1\n\n self.ref_path_x.append(x_0)\n self.ref_path_y.append(y_0)\n\n while not found:\n print('\\n#####################'\n '\\n Frame nr. {}'.format(counter+1))\n # update measurement information\n self.PG1['start'] = self.ref_path_x[-1] + (b + 0.5) * res\n self.PG1['stop'] = self.ref_path_x[-1] - (f + 0.5) * res\n self.PG1['mean'] = self.PG1['start'] + (self.PG1['stop'] - self.PG1['start']) / 2.\n\n self.PG2['start'] = self.ref_path_y[-1] + (b + 0.5) * res\n self.PG2['stop'] = self.ref_path_y[-1] - (f + 0.5) * res\n self.PG2['mean'] = self.PG2['start'] + (self.PG2['stop'] - self.PG2['start']) / 2.\n\n # define measurement object\n output_path = os.path.join(self.path_out, 'reference_' + str(counter))\n measurement = ScriptTools.MeasurementObject(\n self.path_in,\n output_path\n )\n\n # recalibrate QPC every 3 frames\n if counter % calibrate_nr == 0 or self.sweet_spot is None:\n calibrate = True\n gate_config = None\n\n else:\n calibrate = False\n gate_config = {\n self.gate_names['QPC_G']: self.sweet_spot\n }\n \n # perform measurement / get data\n measurement_signal = self.get_data_(measurement, output_path,\n DQD_log_channel=self.gate_names['I_DQD'],\n calibrate=calibrate, rescale=False,\n config=gate_config)\n self.ref_frames.append(measurement_signal['I_QPC'])\n I_DQD = measurement_signal['I_DQD']\n\n # reshape data in order to make it suitable for classifier\n reshaped_signal = self.ref_frames[-1].reshape((1, f + b, f + b, 1))\n\n # predict occupation state\n occupation = self.occupation_ref_rec.predict(reshaped_signal)[0]\n self.ref_classif.append(occupation)\n print('Classification confidences:\\n{}'.format(occupation))\n print('PG1: {}V\\n'\n 'PG2: {}V'.format(self.ref_path_x[-1], self.ref_path_y[-1]))\n counter += 1\n\n # plot measurement and visualize filters\n if plot:\n grid = plt.GridSpec(20, 20)\n fig = plt.figure()\n ax = plt.subplot(grid[:20, :20])\n axins1 = inset_axes(ax,\n width=\"3%\",\n height=\"100%\",\n loc='lower left',\n bbox_to_anchor=(1.01, 0., 1, 1),\n bbox_transform=ax.transAxes,\n borderpad=0,\n )\n\n im1 = ax.pcolormesh(self.ref_frames[-1][:, :], linewidth=0, rasterized=True)\n cbar = fig.colorbar(im1, cax=axins1)\n ax.axhline(y=16, color='black', linewidth=2)\n ax.axvline(x=16, color='black', linewidth=2)\n ax.plot(self.ref_path_x[-1], self.ref_path_y[-1])\n ax.set_ylim(0, 20)\n ax.set_xlim(0, 20)\n plt.title('Reference {}'.format(counter))\n plt.show()\n\n # If confidence that DQD empty is larger than a certain threshold -> terminate\n # Classification outcome: [1, 0] -> dots occupied, [0, 1] -> dots empty\n if(occupation[1] > confidence and not self.is_current_(I_DQD, threshold=7e-12)):\n found = True\n print(self.ref_path_x[-1])\n print(self.ref_path_y[-1])\n self.occupation_1 = 0\n self.occupation_2 = 0\n self.trans_path_x.append(self.ref_path_x[-1])\n self.trans_path_y.append(self.ref_path_y[-1])\n print('Found a reference point at\\n'\n 'PG1: {}V\\n'\n 'PG2: {}V'.format(self.ref_path_x[-1], self.ref_path_y[-1]))\n\n else:\n self.ref_path_x.append(self.ref_path_x[-1] - f*res/3)\n self.ref_path_y.append(self.ref_path_y[-1] - f*res/3)\n\n return self.ref_path_x[-1], self.ref_path_y[-1]","def _RunCalibration(self, graph_key, gdef, input_data, config):\n return self._RunGraph(graph_key, gdef, input_data, config, 30)","def start(self):\n ### input check ### ? or done automaticly, how optional?\n self.ctx.last_calc2 = None\n self.ctx.loop_count2 = 0\n self.ctx.calcs = []\n self.ctx.successful2 = False\n\n # set values, or defaults, default: always converge charge density, crit < 0.00002, max 4 fleur runs\n self.ctx.max_number_runs = self.inputs.wf_parameters.get_dict().get('relax_runmax', 4)\n self.ctx.max_force_cycle = self.inputs.wf_parameters.get_dict().get('max_force_cycle', 4)\n print 'start'","def testoptdone(self):\r\n\r\n assert self.data.optdone\r\n\r\n targets = self.data.geotargets\r\n values = numpy.abs(self.data.geovalues[-1])\r\n\r\n target_e = targets[0]\r\n target_g = targets[1:3]\r\n target_x = targets[3:]\r\n value_e = values[0]\r\n value_g = values[1:3]\r\n value_x = values[3:]\r\n\r\n conv_all = all(values < targets)\r\n conv_e = value_e < 25*target_e and all(value_g < target_g) and all(value_x < target_x)\r\n conv_g = value_e < target_e and all(value_g < target_g/3.0) and all(value_x < target_x*3.0)\r\n conv_x = value_e < target_e and all(value_g < target_g*3.0) and all(value_x < target_x/3.0)\r\n converged = conv_all or conv_e or conv_g or conv_x\r\n assert converged","def potentialSolver4(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def test_blank(self):\n self._calibration_test(\"blank\")","def _decisionFunction(self):\n #THIS IS WHERE THE INTELLIGENT AGENT CODE MAKES DECISION\n #since this is the hand coded extension, I'm just going to hard code some stuff\n #q learning and Sarsa should hopefully do better\n \n #this is some other hand coded stuff that you read in stone's paper\n c1 = 64 #c1 = distance in pixels\n c2 = 2.5#c2 = something to multiply angle by\n c3 = 77 #c3 is the number of pixels you assume are in 5 meteres\n #state variable 7 is distance in pixels from K1 to T1\n if self.stateVariables[7] > c1:\n self._holdBall()\n else:\n passMax = float(\"-Inf\")\n passMaxArg = None\n for i in range(1,3):\n var = (c2 * arccos(self.stateVariables[10+i])) + (self.stateVariables[8+i] / c3)\n \"\"\"\n print(\"var = \", var)\n print(\"stateVariable[\", 10 + i, \"]=\", self.stateVariables[10+i] )\n print(\"arccos of stateVariable[\", 10 + i, \"]=\", arccos(self.stateVariables[10+i]) )\n print(\"stateVariable[\", 8 + i, \"]=\", self.stateVariables[8+i] )\n \"\"\"\n \n if var > passMax:\n passMax = var\n passMaxArg = i\n self._passBall(passMaxArg)","def calibration(self) -> tuple[int, int, int, int, int]:","def check_calibrated(self):\n if not self.is_calibrated():\n raise NotCalibratedError()","def potentialSolver5(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def check_error(self):\n refine_results = {}\n for phase_path, phase in self.phases.items():\n refine_results[phase_path] = {}\n\n # Save the original grid to the refine results\n tx = phase.options['transcription']\n gd = tx.grid_data\n num_nodes = gd.subset_num_nodes['all']\n numseg = gd.num_segments\n\n refine_results[phase_path]['num_segments'] = numseg\n refine_results[phase_path]['order'] = gd.transcription_order\n refine_results[phase_path]['segment_ends'] = gd.segment_ends\n refine_results[phase_path]['need_refinement'] = np.zeros(numseg, dtype=bool)\n refine_results[phase_path]['error'] = np.zeros(numseg, dtype=float)\n\n if isinstance(tx, dm.RungeKutta):\n continue\n\n outputs = phase.list_outputs(units=False, out_stream=None)\n\n out_values_dict = {k: v['value'] for k, v in outputs}\n\n prom_to_abs_map = phase._var_allprocs_prom2abs_list['output']\n\n num_scalar_states = 0\n for state_name, options in phase.state_options.items():\n shape = options['shape']\n size = np.prod(shape)\n num_scalar_states += size\n\n x = np.zeros([num_nodes, num_scalar_states])\n f = np.zeros([num_nodes, num_scalar_states])\n c = 0\n\n # Obtain the solution on the current grid\n for state_name, options in phase.state_options.items():\n prom_name = f'timeseries.states:{state_name}'\n abs_name = prom_to_abs_map[prom_name][0]\n rate_source_prom_name = f\"timeseries.state_rates:{state_name}\"\n rate_abs_name = prom_to_abs_map[rate_source_prom_name][0]\n x[:, c] = out_values_dict[prom_name].ravel()\n f[:, c] = out_values_dict[rate_source_prom_name].ravel()\n c += 1\n\n # Obtain the solution on the new grid\n # interpolate x at t_hat\n new_order = gd.transcription_order + 1\n # Gauss-Lobatto does not allow even orders so increase order by 2 instead\n if gd.transcription == 'gauss-lobatto':\n new_order += 1\n new_grid = GridData(numseg, gd.transcription, new_order, gd.segment_ends, gd.compressed)\n left_end_idxs = new_grid.subset_node_indices['segment_ends'][0::2]\n left_end_idxs = np.append(left_end_idxs, new_grid.subset_num_nodes['all'] - 1)\n\n L = interpolation_lagrange_matrix(gd, new_grid)\n I = integration_matrix(new_grid)\n\n # Call the ODE at all nodes of the new grid\n x_hat, x_prime = self.eval_ode(phase, new_grid, L, I)\n E = {}\n e = {}\n err_over_states = {}\n for state_name, options in phase.state_options.items():\n E[state_name] = np.absolute(x_prime[state_name] - x_hat[state_name])\n for k in range(0, numseg):\n e[state_name] = E[state_name]/(1 + np.max(x_hat[state_name][left_end_idxs[k]:left_end_idxs[k + 1]]))\n err_over_states[state_name] = np.zeros(numseg)\n\n for state_name, options in phase.state_options.items():\n for k in range(0, numseg):\n err_over_states[state_name][k] = np.max(e[state_name][left_end_idxs[k]:left_end_idxs[k + 1]])\n\n self.error[phase_path] = np.zeros(numseg)\n refine_results[phase_path]['error'] = np.zeros(numseg)\n refine_results[phase_path]['need_refinement'] = np.zeros(numseg, dtype=bool)\n\n # Assess the errors in each state\n for state_name, options in phase.state_options.items():\n for k in range(0, numseg):\n if err_over_states[state_name][k] > self.error[phase_path][k]:\n self.error[phase_path][k] = err_over_states[state_name][k]\n refine_results[phase_path]['error'][k] = err_over_states[state_name][k]\n if self.error[phase_path][k] > phase.refine_options['tolerance']:\n refine_results[phase_path]['need_refinement'][k] = True\n\n return refine_results","def solve(self):\n\n # Open status display\n fmtstr, nsep = self.display_start()\n\n # Start solve timer\n self.timer.start(['solve', 'solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n\n # Main optimisation iterations\n for self.k in range(self.k, self.k + self.opt['MaxMainIter']):\n\n # Update record of X and Y from previous iteration\n self.on_iteration_start()\n\n # Compute backtracking\n if self.opt['Backtrack'] is not None and self.k >= 0:\n self.timer.stop('solve_wo_btrack')\n # Compute backtracking\n self.backtrack.update(self)\n self.timer.start('solve_wo_btrack')\n else:\n # Compute just proximal step\n self.xstep()\n # Update by combining previous iterates\n self.ystep()\n\n # Compute residuals and stopping thresholds\n self.timer.stop(['solve_wo_rsdl', 'solve_wo_btrack'])\n if not self.opt['FastSolve']:\n frcxd, adapt_tol = self.compute_residuals()\n self.timer.start('solve_wo_rsdl')\n\n # Compute and record other iteration statistics and\n # display iteration stats if Verbose option enabled\n self.timer.stop(['solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n if not self.opt['FastSolve']:\n itst = self.iteration_stats(self.k, frcxd)\n self.itstat.append(itst)\n self.display_status(fmtstr, itst)\n self.timer.start(['solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n\n # Call callback function if defined\n if self.opt['Callback'] is not None:\n if self.opt['Callback'](self):\n break\n\n # Stop if residual-based stopping tolerances reached\n if not self.opt['FastSolve']:\n if frcxd < adapt_tol:\n break\n\n # Increment iteration count\n self.k += 1\n\n # Record solve time\n self.timer.stop(['solve', 'solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n\n # Print final separator string if Verbose option enabled\n self.display_end(nsep)\n\n return self.getmin()","def test_defect_calculation():\n slope1, slope2 = 2., 3.\n step1, step2 = Fraction(5), Fraction(7)\n cosim = ramp_cosimulation(slope1, slope2, step1, step2)\n t_end = Fraction(20)\n defect = cs.evaluate(cosim, t_end)\n\n alpha = Fraction(int(lcm(step1.numerator, step2.numerator)),\n int(gcd(step1.denominator, step2.denominator)))\n num1, num2 = tuple(map(int, [alpha / step for step in (step1, step2)]))\n big = max(num1, num2) + 1\n small = min(num1, num2) - 1\n assert defect.connection['Ramp1', 'u'] > small * slope2 * step2\n assert defect.connection['Ramp1', 'u'] < big * slope2 * step2\n assert defect.connection['Ramp2', 'u'] > small * slope1 * step1\n assert defect.connection['Ramp2', 'u'] < big * slope1 * step1\n\n assert defect.output['Ramp1', 'y'] == pytest.approx(slope1 * step1)\n assert defect.output['Ramp2', 'y'] == pytest.approx(slope2 * step2)","def did_solve(self):\n return self._solution.success","def calibrate(msname, parset, skymodel, logname_root, use_timecorr=False,\n time_block=None, ionfactor=0.5, outdir='.', instrument='instrument',\n solint=None, flag_filler=False, ncores=1):\n log = logging.getLogger(\"Calib\")\n\n if not use_timecorr:\n subprocess.call(\"calibrate-stand-alone -f {0} {1} {2} > {3}/logs/\"\n \"{4}_peeling_calibrate.log 2>&1\".format(msname, parset, skymodel,\n outdir, logname_root), shell=True)\n subprocess.call(\"cp -r {0}/instrument {0}/instrument_out\".format(msname),\n shell=True)\n else:\n # Perform a time-correlated solve\n dataset = msname\n blockl = time_block\n anttab = pt.table(dataset + '/ANTENNA', ack=False)\n antlist = anttab.getcol('NAME')\n instrument_orig = msname+'/instrument'\n instrument_out = msname+'/instrument_out'\n if solint < 1:\n solint = 1\n\n\n # Get time per sample and number of times\n t = pt.table(dataset, readonly=True, ack=False)\n for t2 in t.iter([\"ANTENNA1\",\"ANTENNA2\"]):\n if (t2.getcell('ANTENNA1',0)) < (t2.getcell('ANTENNA2',0)):\n timepersample = t2[1]['TIME']-t2[0]['TIME'] # sec\n trows = t2.nrows()\n t.close()\n\n # Calculate various intervals\n fwhm_min, fwhm_max = modify_weights(msname, ionfactor, dryrun=True) # s\n if time_block is None:\n # Set blockl to enclose the max FWHM and be divisible by 2 and by solint\n blockl = int(np.ceil(fwhm_max / timepersample / 2.0 / solint) * 2 * solint)\n tdiff = solint * timepersample / 3600. # difference between solutions in hours\n tlen = timepersample * np.float(blockl) / 3600. # length of block in hours\n nsols = int(np.ceil(trows / solint)) # number of solutions\n\n log.info('Performing time-correlated peeling for {0}...\\n'\n ' Time per sample: {1} (s)\\n'\n ' Samples in total: {2}\\n'\n ' Block size: {3} (samples)\\n'\n ' {4} (s)\\n'\n ' Number of solutions: {5}\\n'\n ' Ionfactor: {6}\\n'\n ' FWHM range: {7} - {8} (s)'.format(msname, timepersample,\n trows, blockl, tlen*3600.0, nsols, ionfactor, fwhm_min, fwhm_max))\n\n # Make a copy of the master parmdb to store time-correlated solutions\n # in, resetting and flagging as needed\n os.system('rm -rf ' +instrument_out)\n clean_and_copy_parmdb(instrument_orig, instrument_out, blockl,\n flag_filler=flag_filler, msname=msname, timepersample=timepersample)\n\n # Calibrate the chunks\n chunk_list = []\n tlen_mod = tlen / 2.0 # hours\n chunk_mid_start = blockl / 2 / solint\n chunk_mid_end = nsols - blockl / 2 / solint\n for c in range(nsols):\n chunk_obj = Chunk(dataset)\n chunk_obj.chunk = c\n chunk_obj.outdir = outdir\n if c < chunk_mid_start:\n chunk_obj.trim_start = True\n chunk_obj.t0 = 0.0 # hours\n chunk_obj.t1 = np.float(chunk_obj.t0) + tlen_mod # hours\n tlen_mod += tdiff # add one solution interval (in hours)\n elif c > chunk_mid_end:\n tlen_mod -= tdiff # subtract one solution interval (in hours)\n chunk_obj.trim_start = False\n chunk_obj.t0 = tdiff*float(chunk_obj.chunk - chunk_mid_start) # hours\n chunk_obj.t1 = np.float(chunk_obj.t0) + tlen_mod # hours\n else:\n chunk_obj.trim_start = False\n chunk_obj.t0 = tdiff*float(chunk_obj.chunk - chunk_mid_start) # hours\n chunk_obj.t1 = np.float(chunk_obj.t0) + tlen # hours\n chunk_obj.ionfactor = ionfactor\n chunk_obj.parset = parset\n chunk_obj.skymodel = skymodel\n chunk_obj.logname_root = logname_root + '_part' + str(c)\n chunk_obj.solnum = chunk_obj.chunk\n chunk_obj.output = chunk_obj.outdir + '/part' + str(chunk_obj.chunk) + os.path.basename(chunk_obj.dataset)\n chunk_obj.ntot = nsols\n chunk_list.append(chunk_obj)\n\n # Split the dataset into parts\n for chunk_obj in chunk_list:\n split_ms(chunk_obj.dataset, chunk_obj.output, chunk_obj.t0, chunk_obj.t1)\n\n # Calibrate in parallel\n pool = multiprocessing.Pool(ncores)\n pool.map(calibrate_chunk, chunk_list)\n pool.close()\n pool.join()\n\n # Copy over the solutions to the final parmdb\n pdb = lofar.parmdb.parmdb(instrument_out)\n parms = pdb.getValuesGrid(\"*\")\n for chunk_obj in chunk_list:\n instrument_input = chunk_obj.output + '/instrument'\n pdb_part = lofar.parmdb.parmdb(instrument_input)\n parms_part = pdb_part.getValuesGrid(\"*\")\n keynames = parms_part.keys()\n for key in keynames:\n if 'Phase' in key:\n tmp1=np.copy(parms[key]['values'][:,0])\n tmp1[chunk_obj.solnum] = np.copy(parms_part[key]['values'][0,0])\n parms[key]['values'][:,0] = tmp1\n os.system('rm -rf ' + instrument_out)\n lofar.expion.parmdbmain.store_parms(instrument_out, parms, create_new=True)\n\n # Clean up\n for chunk_obj in chunk_list:\n os.system('rm -rf {0}*'.format(chunk_obj.output))\n os.system('rm calibrate-stand-alone*.log')\n\n # Move the solutions to original parmdb\n subprocess.call('cp -r {0} {1}'.format(instrument_out, instrument_orig),\n shell=True)","def main_function(self):\n self.ana_cont_probl = cont.AnalyticContinuationProblem(im_axis=self.input_data.mats,\n im_data=self.input_data.value.real,\n re_axis=self.realgrid.grid,\n kernel_mode='freq_bosonic')\n model = np.ones_like(self.realgrid.grid)\n model /= np.trapz(model, self.realgrid.grid)\n\n preblur, bw = self.get_preblur()\n\n sol = self.ana_cont_probl.solve(method='maxent_svd',\n optimizer='newton',\n alpha_determination='chi2kink',\n model=model,\n stdev=self.input_data.error,\n interactive=False, alpha_start=1e10, alpha_end=1e-3,\n preblur=preblur, blur_width=bw)\n\n inp_str = 'atom {}, orb {}, spin {}, blur {}: '.format(self.input_data.atom,\n self.input_data.orbital,\n self.input_data.spin,\n bw)\n all_chis = np.isfinite(np.array([s.chi2 for s in sol[1]]))\n res_str = 'alpha_opt={:3.2f}, chi2(alpha_opt)={:3.2f}, min(chi2)={:3.2f}'.format(\n sol[0].alpha, sol[0].chi2, np.amin(all_chis)\n )\n self.text_output.append(inp_str + res_str)\n alphas = [s.alpha for s in sol[1]]\n chis = [s.chi2 for s in sol[1]]\n\n self.output_data.update(self.realgrid.grid, sol[0].A_opt, self.input_data)\n\n fig, ax = plt.subplots(ncols=2, nrows=2, figsize=(11.75, 8.25)) # A4 paper size\n ax[0, 0].loglog(alphas, chis, marker='s', color='black')\n ax[0, 0].loglog(sol[0].alpha, sol[0].chi2, marker='*', color='red', markersize=15)\n ax[0, 0].set_xlabel(r'$\\alpha$')\n ax[0, 0].set_ylabel(r'$\\chi^2(\\alpha)$')\n\n ax[1, 0].plot(self.realgrid.grid, sol[0].A_opt)\n ax[1, 0].set_xlabel(r'$\\omega$')\n ax[1, 0].set_ylabel('spectrum')\n\n ax[0, 1].plot(self.input_data.mats, self.input_data.value.real,\n color='blue', ls=':', marker='x', markersize=5,\n label='Re[data]')\n ax[0, 1].plot(self.input_data.mats, self.input_data.value.imag,\n color='green', ls=':', marker='+', markersize=5,\n label='Im[data]')\n ax[0, 1].plot(self.input_data.mats, sol[0].backtransform.real,\n ls='--', color='gray', label='Re[fit]')\n ax[0, 1].plot(self.input_data.mats, sol[0].backtransform.imag,\n color='gray', label='Im[fit]')\n ax[0, 1].set_xlabel(r'$\\nu_n$')\n ax[0, 1].set_ylabel(self.input_data.data_type)\n ax[0, 1].legend()\n\n ax[1, 1].plot(self.input_data.mats, (self.input_data.value - sol[0].backtransform).real,\n ls='--', label='real part')\n ax[1, 1].plot(self.input_data.mats, (self.input_data.value - sol[0].backtransform).imag,\n label='imaginary part')\n ax[1, 1].set_xlabel(r'$\\nu_n$')\n ax[1, 1].set_ylabel('data $-$ fit')\n ax[1, 1].legend()\n plt.tight_layout()\n plt.show()","def ekf_algorithm(self, u, y):\n x_est_before = self.x_estimated_state\n cov_matrix_before = self.cov_matrix\n # 1. Prediction\n # predict the state by integrate the time continuous system numerically\n sim_state_predict = self.heliSim.calc_step(u[0][0], u[1][0], self.no_disturbance_eval)\n x_est_predict = np.resize(sim_state_predict, (8, 1))\n # predict the new covariance by linearizing and discretizing the model\n Ak, Bk, Ck, Dk = self.get_linear_discrete_matrices(x_est_before, u[0][0], u[1][0])\n cov_matrix_predict = Ak @ cov_matrix_before @ np.transpose(Ak) + Bk @ self.N @ np.transpose(Bk)\n # 2. Update\n # compute kalman gain\n Kl = cov_matrix_predict @ np.transpose(Ck) @ np.linalg.inv(Ck @ cov_matrix_predict @ np.transpose(Ck) + self.W)\n # update state\n y_est = x_est_predict[0:3]\n x_est_update = x_est_predict + Kl @ (y - y_est)\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ Ck) @ cov_matrix_predict\n\n # check if the update step state needs to be changed because of limit crossing\n # if that is the case, correct the state and set the state of the simulation accordingly\n corrected_state = self.heliSim.get_limited_state_and_change_state(x_est_update.reshape((1, 8))[0],\n ModelType.GYROMOMENT)\n x_est_update = np.resize(corrected_state, (8, 1))\n\n self.x_estimated_state = x_est_update\n self.cov_matrix = cov_matrix_update\n # print(\"------\")\n # print(cov_matrix_predict)\n return x_est_update","def determine_analytic_solution(self):\n\n self._Janalytic = np.where(self.xr <= self.xint, self.S, 0.5 * self.S)\n self._Hanalytic = np.where(self.xr <= self.xint, 0, 0.25 * self.S)\n self._Kanalytic = np.where(self.xr <= self.xint, 1./3. * self.S,\n 1./6. * self.S)","def calibrate(self):\n import time\n\n CALIBRATE_SLEEP = 0.75\n\n self.change_power(-self._calpow)\n encprev, encnow = 0, None\n while encprev != encnow:\n encprev = encnow\n time.sleep(CALIBRATE_SLEEP)\n encnow = self._bp.get_motor_encoder(self._port)\n self._pmin = encnow\n self.change_power(0)\n\n self.change_power(self._calpow)\n encprev, encnow = 0, None\n while encprev != encnow:\n encprev = encnow\n time.sleep(CALIBRATE_SLEEP)\n encnow = self._bp.get_motor_encoder(self._port)\n self._pmax = encnow\n self.change_power(0)\n\n if self._pmax == self._pmin:\n raise Exception('motor {} does not move'.format(self._port))\n\n self._pinit = (self._pmax + self._pmin) * 0.5\n time.sleep(0.5)\n self.to_init_position()","def _calibrate_measurement(self):\n\n cold_blackbody = bb_radiance(self.cbb.header.cbb_temperature + 273.15,\n self.cbb.data.wavelength)\n warm_blackbody = bb_radiance(self.wbb.header.wbb_temperature + 273.15,\n self.wbb.data.wavelength)\n\n self.wbb.data.average_spectrum[0] = 1\n self.wbb.data.average_spectrum[2047] = 1\n\n calibration_slope = ((warm_blackbody - cold_blackbody) /\n (self.wbb.data.average_spectrum - self.cbb.data.average_spectrum))\n calibration_offset = warm_blackbody - (self.wbb.data.average_spectrum * \n calibration_slope)\n\n self.wbb.calibrate_file(calibration_slope, calibration_offset)\n self.cbb.calibrate_file(calibration_slope, calibration_offset)\n self.sam.calibrate_file(calibration_slope, calibration_offset)\n\n if not self.dwr is None:\n self.dwr.calibrate_file(calibration_slope, calibration_offset)\n\n plate_temperature = self.dwr.header.spare_f[0]\n if (self.plate == -1) :\n plate_emissivity = self.dwr.header.spare_f[1]\n\n plate_blackbody = bb_radiance(plate_temperature + 273.15,\n self.dwr.data.wavelength)\n plate_emission = plate_emissivity * plate_blackbody\n\n self.dwr.data.average_spectrum = ((self.dwr.data.average_spectrum - \n plate_emission) / (1 - plate_emissivity))","def checkselfdual(self):\n\n self.selfdual = True\n for n in range(1,min(8,len(self.dirichlet_coefficients))):\n if abs(imag_part(self.dirichlet_coefficients[n]/self.dirichlet_coefficients[0])) > 0.00001:\n self.selfdual = False","def testset_calibration(self, system_name):\n wdesc = \"Check if Lab Test set calibration is current.\"\n #Resolve system_name and subsystem_list\n system_name, subsystem_list = Utils.data_Utils.resolve_system_subsystem_list(self.datafile, system_name)\n output_dict = {}\n status = True\n attempt = 1 if subsystem_list == None else len(subsystem_list)\n for i in range(attempt):\n Utils.testcase_Utils.pSubStep(wdesc)\n #Get name from the list when it's not 'None', otherwise, set it to 'None'\n subsystem_name = subsystem_list[i] if subsystem_list != None else None\n call_system_name = system_name if subsystem_name is None \\\n else \"{0}[{1}]\".format(system_name, subsystem_name)\n credentials = get_credentials(self.datafile, call_system_name, \\\n ['calibration', 'user', 'location', 'testdata'])\n pNote(\"system={0}\".format(call_system_name))\n #Demo Framework testdata capability\n testdatafile = file_Utils.getAbsPath(credentials[\"testdata\"], os.path.dirname(self.datafile))\n add_info = Utils.xml_Utils.getElementWithTagAttribValueMatch(testdatafile, \\\n 'add_info', 'name', 'testdata')\n if add_info is not None:\n info_text = Utils.xml_Utils.get_text_from_direct_child(add_info, 'info')\n pNote(info_text)\n pNote(testdatafile)\n\n if credentials is not None and credentials is not False:\n calibrated_date = credentials[\"calibration\"]\n num_of_year = 1\n pass_msg = \"Lab Test set {0} calibration is current, \"\\\n \"re-calibration is NOT required.\"\\\n .format(call_system_name)\n fail_msg = \"Lab Test set {0} calibration is NOT current, it's \"\\\n \"more than than 1 year old. Re-calibration is \"\\\n \"required\".format(call_system_name)\n result = Utils.demo_utils.lab_eqpt_status(calibrated_date, num_of_year, pass_msg, fail_msg)\n\n Utils.data_Utils.update_datarepository(output_dict)\n Utils.testcase_Utils.report_substep_status(result)\n status = status and result\n\n return status, output_dict","def arm_calibration(self):\n self.arm_motor.run_forever(speed_sp=self.MAX_SPEED)\n while not self.touch_sensor.is_pressed:\n time.sleep(0.01)\n self.arm_motor.stop()\n ev3.Sound.beep().wait()\n arm_revolutions_for_full_range = 14.2 * 360\n self.arm_motor.run_to_rel_pos(\n position_sp=-arm_revolutions_for_full_range,\n speed_sp=self.MAX_SPEED,\n stop_action=ev3.Motor.STOP_ACTION_BRAKE)\n self.arm_motor.wait_while(ev3.Motor.STATE_RUNNING)\n\n self.arm_motor.position = 0 # Calibrate the down position as 0 (this\n # line is correct as is).","def doRun(run=77):\n r = xanes_analyzeRun.AnalyzeRun(run)\n r.load()\n calibs = list(r.results.keys())\n calibs.sort()\n p2 = [np.nanmedian(r.results[c].p1, axis=0) for c in calibs]\n p2 = np.asarray(p2)\n ref = np.nanmedian(p2, axis=0)\n # normalize p2\n p2 = p2 / ref\n # remove non-flat part\n _x = np.arange(p2.shape[1], dtype=float)\n p2 = [s - mc.poly_approximant(_x, s, order=20)(_x) for s in p2]\n p2 = np.asarray(p2)\n x = np.asarray([_x for _ in p2])\n x[p2 > -0.15] = np.nan\n x[x < 100] = np.nan\n # below pixel 200 is noise\n pos = np.nanmean(x, axis=1)\n fig, ax = plt.subplots(1, 2, sharey=True)\n xshift = 0.2\n pcalib = []\n for icalib, (xi, p2i) in enumerate(zip(x, p2)):\n ppar = dict(color=myc(icalib))\n ax[0].plot(p2i + icalib * xshift, _x, \"--\", lw=1, alpha=0.5, **ppar)\n ax[0].plot(p2i + icalib * xshift, xi, lw=2, **ppar)\n pcalib.append(np.nanmedian(xi))\n ax[1].plot(r.scanpos[icalib], pcalib[icalib], \"o\", **ppar)\n polycal = np.polyfit(pcalib, r.scanpos, 1)\n ax[1].plot(np.polyval(polycal, _x), _x)\n print(\"polynomial calibration\", polycal)","def did_solve(self):\n return self._solution[\"status\"] == \"optimal\"","def objective(trial):\n # The parameters that we will calibrate the model for are shown here.\n # Optuna trial i\n BOD = trial.suggest_uniform(\"BOD\", 0, 1) #Review ranges here\n k_r = trial.suggest_uniform(\"k_r\", 0, 1) #Review Ranges here \n \n def ChLa(t):\n return 1 # Need to link to data\n\n def I(x):\n return 1 # Need to link to data\n\n K_z = 2 * 10**(-5) # p.51\n a = K_z\n k_b = 0.1 # Table 5\n th_b = 1.047 # Table 5\n k_r = 0.1 # Table 5\n YCHO2 = 0.0083 # Table 5\n th_p = 1.036 # Table 5\n th_s = 1.065 # Table 5\n th_r = 1.047 # Table 5\n\n def Temp(t):\n \"\"\"\n Function that maps time to temperature\n \"\"\"\n return 20 # Need to link to data\n\n def P_max(t):\n return 9.6 * 1.036 **(Temp(t) - 20) # Eq. 4\n\n def L_min(t):\n I = 1 # Need to link to PAR data\n K_1 = 0.687 * 1.086**(Temp(t) - 20)\n K_2 = 15\n return I * (1 + 2 * np.sqrt(K_1 / K_2)) / (I + K_1 + I**2 / K_2) # Eq. 5\n \n # f deals with sink and source terms \n def f(x, t):\n return -1 / YCHO2 * k_r * th_r**(Temp(t) - 20) * ChLa(t) + P_max(t) * L_min(t) * ChLa(t) - k_b * th_b**(Temp(t)-20) * BOD \n\n L = 200 # Length of domain\n dt = 1 / 48 # Mesh spacing in t\n F = a * dt # a * dt / dx**2\n T = 100 # Simulation time stop\n\n # Solving the PDE\n DO, x, t, _ = solver_FE_simple(I, a, f, L, dt, F, T)\n \n # Creating some bogus targets while database errors are happening\n DO_data = DO + np.random.random(len(DO))\n\n # Using mean squared error as the measure of fit, where we want\n # to minimize this number\n return ((DO - DO_data)**2).mean()"],"string":"[\n \"def calibration(self) -> int:\",\n \"def _doCalibration(self):\\n self._cmdCalibration(2)\",\n \"def convergence_check(self):\\n air = self.air_alias.val\\n flue_gas = self.fuel_alias.val + '_fg'\\n fuel = self.fuel_alias.val\\n\\n for c in self.outl:\\n if not c.fluid.val_set[air]:\\n if c.fluid.val[air] > 0.95:\\n c.fluid.val[air] = 0.95\\n if c.fluid.val[air] < 0.5:\\n c.fluid.val[air] = 0.5\\n\\n if not c.fluid.val_set[flue_gas]:\\n if c.fluid.val[flue_gas] > 0.5:\\n c.fluid.val[flue_gas] = 0.5\\n if c.fluid.val[flue_gas] < 0.05:\\n c.fluid.val[flue_gas] = 0.05\\n\\n if not c.fluid.val_set[fuel]:\\n if c.fluid.val[fuel] > 0:\\n c.fluid.val[fuel] = 0\\n\\n c.target.propagate_fluid_to_target(c, c.target)\\n\\n for i in self.inl:\\n if i.m.val_SI < 0 and not i.m.val_set:\\n i.m.val_SI = 0.01\\n\\n for c in self.outl:\\n if c.m.val_SI < 0 and not c.m.val_set:\\n c.m.val_SI = 10\\n c.target.propagate_fluid_to_target(c, c.target)\\n\\n if self.lamb.val < 1 and not self.lamb.is_set:\\n self.lamb.val = 2\",\n \"def _check_calibration():\\n image_list = glob.glob(os.path.join(\\\"C:\\\\\\\\Users\\\\\\\\chuyangl\\\\\\\\Desktop\\\\\\\\liushuai\\\\\\\\calibrator\\\\\\\\board\\\\\\\\left\\\", \\\"*.bmp\\\"))\\n for single_img in image_list:\\n image = cv2.imread(single_img)\\n new_image = un_distort_image(image)\\n cv2.imshow('before', cv2.resize(image, (int(image.shape[1] * 0.7), int(image.shape[0] * 0.7))))\\n cv2.imshow('after', cv2.resize(new_image, (int(new_image.shape[1] * 0.7), int(new_image.shape[0] * 0.7))))\\n cv2.waitKey(0)\\n\\n image = cv2.imread(image_list[0])\\n\\n # distortion_points = [ge.Point(110, 437), ge.Point(932, 151), ge.Point(1034, 331)]\\n # calibration_points = [ge.Point(510, 437), ge.Point(832, 151), ge.Point(1134, 331)]\\n\\n distortion_points = [ge.Point(110, 437), ge.Point(632, 151), ge.Point(333, 331)]\\n calibration_points = [ge.Point(510, 437), ge.Point(532, 151), ge.Point(234, 331)]\\n\\n for p in distortion_points:\\n cv2.circle(image, p.tuple(), 23, (0, 0, 255), 2)\\n\\n new_image = un_distort_image(image)\\n\\n for p in calibration_points:\\n cv2.circle(new_image, p.tuple(), 23, (255, 0, 0), 4)\\n p2 = distort_point(p)\\n p3 = un_distort_point(p2)\\n cv2.circle(image, p2.int().tuple(), 23, (0, 255, 255), 4)\\n cv2.circle(new_image, p3.int().tuple(), 23, (0, 0, 255), 4)\\n print(p.int().tuple(), p2.int().tuple(), p3.int().tuple())\\n\\n for p in distortion_points:\\n p2 = un_distort_point(p)\\n p3 = distort_point(p2)\\n cv2.circle(new_image, p2.int().tuple(), 23, (0, 255, 255), 2)\\n cv2.circle(image, p3.int().tuple(), 23, (0, 255, 255), 2)\\n print(p.int().tuple(), p2.int().tuple(), p3.int().tuple())\\n\\n cv2.imshow('before', cv2.resize(image, (int(image.shape[1] * 0.7), int(image.shape[0] * 0.7))))\\n cv2.imshow('after', cv2.resize(new_image, (int(new_image.shape[1] * 0.7), int(new_image.shape[0] * 0.7))))\\n\\n cv2.waitKey(0)\",\n \"def photometric_calibration():\\n pass\",\n \"def calibration(self, cal: int, /) -> None:\",\n \"def solve(self):\",\n \"def run_calib(projector=OPTOMA_HD33()):\\n w, h = (0.2160, 0.2794)\\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\\n [-w/2, 0, 0], [w/2, 0, 0],\\n [-w/2, 0, h/2], [w/2, 0, h/2]])\\n\\n global img_points, going\\n img_points = []\\n\\n try:\\n window = Window()\\n window.MoveXY(1600,0)\\n window.ShowFullScreen(True)\\n going = True\\n\\n @window.eventx\\n def EVT_MOUSE_EVENTS(evt):\\n global going, img_points\\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\\n img_points.append(evt.Position)\\n print('Picked point %d of 6' % (len(img_points)))\\n if len(img_points) == len(obj_points):\\n print \\\"Done\\\"\\n going = False\\n\\n print(\\\"\\\"\\\"[Extrinsic Calibration] \\n\\nThere should be 6 points marked on the table and backdrop. \\nMoving the mouse over the projected display, click each of the points\\nin order:\\n (left top, on the backdrop),\\n (right top, on the backdrop),\\n (left center, on the crease),\\n (right center, on the crease),\\n (left bottom, on the table),\\n (right bottom, on the table)\\n\\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\\n\\nClick the six points:\\n\\\"\\\"\\\")\\n\\n while going: cv.WaitKey(10)\\n\\n finally:\\n window.Close()\\n\\n img_points = np.array(img_points, 'f')\\n projector.calibrate_extrinsic(img_points, obj_points)\\n\\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\\n print('OK')\",\n \"def proz(): \\r\\n print(\\\"processing: \\\",CURDATA()[0]) \\r\\n Check_180turn(left_boundary,right_boundary)\\r\\n EF() #exponential window multiplication + fourier\\r\\n APK0() #1. Phase correction 0th Ordnung\\r\\n APK1() #1. Phase correction 1st Ordnung\\r\\n ABS() #Baseline correction\\r\\n APK()\\r\\n ABS() #Baseline correction\\r\\n Check_180turn(left_boundary,right_boundary)\",\n \"def correct(self):\\n stop_flag = False\\n self.orbit_class.online_calc = False\\n # read orbit devs\\n for elem in self.orbit.corrs:\\n try:\\n elem.kick_mrad = elem.mi.get_value()\\n except Exception as e:\\n stop_flag = True\\n logger.warning(elem.id + \\\" reading error: \\\" + str(e))\\n return stop_flag\\n \\n elem.angle_read = elem.kick_mrad*1e-3\\n elem.i_kick = elem.kick_mrad\\n elem.ui.set_init_value(elem.kick_mrad)\\n elem.ui.set_value(elem.kick_mrad)\\n elem.transfer_map = self.parent.lat.method.create_tm(elem)\\n if elem.ui.alarm:\\n stop_flag = True\\n logger.warning(\\\"correct - STOP: corrector shows alarm: \\\" + elem.id)\\n\\n\\n #self.parent.lat.update_transfer_maps()\\n\\n for elem in self.orbit.bpms:\\n if elem.id not in self.new_ref_orbit.keys():\\n logger.warning(\\\"correct - STOP: BPM is not in new ref orbit: \\\" + elem.id)\\n stop_flag = True\\n return stop_flag\\n elem.x = self.new_ref_orbit[elem.id][0]\\n elem.y = self.new_ref_orbit[elem.id][1]\\n elem.ui.set_value((elem.x*1000., elem.y*1000.))\\n if elem.ui.alarm:\\n logger.warning(\\\"correct - STOP: BPM shows alarm: \\\" + elem.id)\\n stop_flag = True\\n if stop_flag:\\n return stop_flag\\n self.orbit_class.online_calc = True\\n\\n\\n if not self.orbit_class.is_rm_ok(self.orbit):\\n logger.error(\\\" correct: Calculate Response Matrix\\\")\\n self.parent.error_box(\\\"Calculate Response Matrix\\\")\\n return 0\\n\\n self.orbit_class.golden_orbit.dict2golden_orbit()\\n\\n if self.orbit_class.ui.cb_close_orbit.isChecked():\\n self.orbit_class.close_orbit()\\n\\n self.calc_correction = {}\\n for cor in self.orbit.corrs:\\n cor.angle = 0.\\n self.calc_correction[cor.id] = cor.angle\\n\\n alpha = 0.\\n\\n self.orbit.correction(alpha=alpha, p_init=None, beta=0, print_log=False)\\n for cor in self.orbit.corrs:\\n self.calc_correction[cor.id] = cor.angle\\n\\n self.set_values2correctors()\\n return stop_flag\",\n \"def solve_prep(self):\\n\\n par = self.par\\n sol = self.sol\\n\\n # a. retirement\\n sol.m_ret = np.zeros((par.T,par.Nm_ret))\\n sol.c_ret = np.zeros((par.T,par.Nm_ret))\\n sol.a_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_v_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vm_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vn_ret = np.zeros((par.T,par.Nm_ret))\\n\\n # b. working\\n if par.solmethod == 'G2EGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.ucon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.dcon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.acon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.z = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n \\n elif par.solmethod == 'NEGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((0,0,0))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((0,0,0))\\n \\n sol.c_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\\n sol.inv_v_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\",\n \"def solve(self):\\n # check for jacobian and set it if present and to be used\\n if self.use_sparse:\\n if self._use_jac and hasattr(self.problem,'sparse_jac'):\\n jac = self.problem.sparse_jac\\n else:\\n jac = None\\n else:\\n if self._use_jac and hasattr(self.problem,'jac'):\\n jac = self.problem.jac\\n else:\\n jac = None\\n \\n # Initialize solver and solve \\n \\n solved = False\\n local_min = False\\n\\n res = N.zeros(self.x0.__len__())\\n while (not solved) and self.reg_count < 2:\\n try:\\n if self._use_fscale:\\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,self.fscale)\\n else:\\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,None)\\n start = time.clock()\\n res = self.solver.KINSOL_solve(not self._use_ls)\\n stop = time.clock()\\n self.exec_time += (stop - start)\\n solved = True\\n except KINError as error:\\n if error.value == 42:\\n # Try the heuristic\\n if hasattr(self.problem, 'get_heuristic_x0'):\\n print \\\"----------------------------------------------------\\\"\\n print \\\" Solver stuck with zero step-length.\\\"\\n print \\\"----------------------------------------------------\\\"\\n print \\\"The following variables have start value zero\\\"\\n print \\\"and min set to zero causing the zero step-lenght.\\\"\\n print \\\"These settings are either set by default or by user.\\\"\\n print \\\"\\\"\\n\\n self.x0 = self.problem.get_heuristic_x0()\\n self.reg_count += 1\\n \\n print \\\"\\\"\\n print \\\"This setting (start and min to zero) can often\\\"\\n print \\\"cause problem when initializing the system. \\\"\\n print \\\"\\\"\\n print \\\"To avoid this the above variables have\\\"\\n print \\\"their start attributes reset to one.\\\"\\n print \\\"\\\"\\n print \\\"Trying to solve the system again...\\\"\\n else:\\n raise KINSOL_Exception(\\\"Regularization failed due to constraints, tried getting heuristic initial guess but failed.\\\")\\n \\n\\n elif (error.value == 2):\\n print \\\"---------------------------------------------------------\\\"\\n print \\\"\\\"\\n print \\\" !!! WARNING !!!\\\"\\n print \\\"\\\"\\n print \\\" KINSOL has returned a result but the algorithm has converged\\\"\\n print \\\" to a local minima, the initial values are NOT consistant!\\\"\\n print \\\"\\\"\\n print \\\"---------------------------------------------------------\\\"\\n solved = True\\n local_min = True\\n else:\\n # Other error, send onward as exception\\n self.problem.check_constraints(res)\\n raise KINSOL_Exception(error.msg[error.value])\\n \\n if not solved:\\n self.solver.Free_KINSOL()\\n raise KINSOL_Exception(\\\"Algorithm exited solution loop without finding a solution, please contact Assimulo support.\\\")\\n\\n if self.check_with_model:\\n self.problem.check_constraints(res)\\n if not local_min:\\n print \\\"Problem sent to KINSOL solved.\\\"\\n \\n return res\",\n \"def calibrate(self):\\n self.gripper_io.set_signal_value(\\\"calibrate\\\", True)\\n success = intera_dataflow.wait_for(\\n lambda: self.is_calibrated(),\\n timeout=5.0,\\n raise_on_error=False\\n )\\n if not success:\\n rospy.logerr(\\\"({0}) calibration failed.\\\".format(self.name))\\n return success\",\n \"def one_step(self):\\r\\n assert (self.uv_vol is not None)\\r\\n assert (self.guv_vol is not None)\\r\\n assert (self.uv_bound is not None)\\r\\n assert (self.vf_vect_bound is not None)\\r\\n assert (self.vF_vect_vol is not None)\\r\\n # Shape checks\\r\\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\\r\\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\\r\\n assert (self.vF_vect_vol.shape == self.vf_vect_bound.shape)\\r\\n assert (self.uv_vol.shape[0] == self.uv_vol.shape[1])\\r\\n assert (self.uv_vol.shape == self.guv_vol.shape)\\r\\n assert (self.uv_vol.shape == self.uv_bound.shape)\\r\\n assert (self.uv_vol.shape[0] == self.vF_vect_vol.shape[0])\\r\\n \\r\\n if self.step == 0:\\r\\n self.check_k_matrix_stability()\\r\\n # print(\\\"Epsilon is :\\\"+str(self.Epsilon))\\r\\n # print(\\\"Beta is :\\\"+str(self.Beta))\\r\\n\\r\\n # Form \\\"Stiffness\\\" matrix:\\r\\n K = self.make_k_matrix()\\r\\n # Form \\\"Force\\\" vector: \\r\\n f = self.vF_vect_vol + (self.Epsilon / self.Beta) * self.vf_vect_bound\\r\\n\\r\\n # print(\\\"FORCE VECTOR:\\\")\\r\\n # print(f)\\r\\n # print(\\\"STIFFNESS MATRIX\\\")\\r\\n # print(K)\\r\\n # print(\\\"UV_VOL\\\")\\r\\n # print(self.uv_vol)\\r\\n # print(\\\"EPSILON * GUV_VOL\\\")\\r\\n # print(self.Epsilon * self.guv_vol)\\r\\n # print(\\\"UV_BOUND * COEFF\\\")\\r\\n # print((self.Epsilon / self.Beta) * self.uv_bound)\\r\\n sol = scipy_sparse_linsolve(K, f)\\r\\n # print(\\\"SOLUTION\\\")\\r\\n # print(sol)\\r\\n return sol\",\n \"def calcIntrasec(self, gui):\\n count = len(self.points)\\n numpoints = (self.chessSize[0]*self.chessSize[1])\\n\\n #create matrices that are needed to compute calibration\\n mat = cv.CreateMat(3,3,cv.CV_32FC1)\\n distCoeffs = cv.CreateMat(4,1,cv.CV_32FC1)\\n p3d = cv.CreateMat(count,3,cv.CV_32FC1) #compute 3D points\\n p2d = cv.CreateMat(count,2,cv.CV_32FC1) #compute 2D points\\n pointCounts = cv.CreateMat( self.nframe ,1,cv.CV_32SC1) #give numpoints per images\\n cv.Set(pointCounts,numpoints)\\n rvecs = cv.CreateMat(self.nframe,3,cv.CV_32FC1)\\n tvecs = cv.CreateMat(self.nframe,3,cv.CV_32FC1)\\n\\n i = 0\\n row = 0\\n col = 0\\n cv.Set(p3d,0.0) #to set every values to 0.0... and not set Z value\\n\\n #this compute points in row and cols...\\n for p in self.points:\\n p2d[i,0] = p[0]\\n p2d[i,1] = p[1]\\n \\n p3d[i,0] = col\\n p3d[i,1] = row\\n col+=1\\n if col >= self.chessSize[0]: \\n row+=1\\n col=0\\n if row >= self.chessSize[1]:\\n row = 0\\n i+=1\\n\\n #and now, calibrate...\\n cv.CalibrateCamera2(p3d, p2d, pointCounts, self.framesize, mat, distCoeffs, rvecs, tvecs, flags=0)\\n gui.setMessage(\\\"Intrasinc camera parameters checked\\\")\\n\\n return (mat, distCoeffs)\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n return True\",\n \"def _calibrate(self, Otrain, Ftrain, Feval):\\n raise NotImplementedError()\",\n \"def calibrate(self, master):\\n if master.polyorder == 'linear':\\n self.fitfunction = \\\"A0 + A1 * D\\\"\\n self.fit_fkt = self.calc_lin\\n elif master.polyorder == 'quadratic':\\n self.fit_fkt = self.calc_quad\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2\\\"\\n elif master.polyorder == \\\"cubic\\\":\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2 + A3 * D**3\\\"\\n self.fit_fkt = self.calc_cubic\\n else:\\n print(\\\"Polynomgrad nicht definiert\\\")\\n \\n self.mw = np.asarray(self.mw)\\n if master.sensortype == \\\"Druck\\\":\\n self.best, self.covar = curve_fit(self.fit_fkt, self.mw, master.Referencedata.caldat)\\n else:\\n print(\\\"Sensortyp noch nicht Hinterlegt\\\")\",\n \"def solve(self):\\n ...\",\n \"def solve(self):\\n pass\",\n \"def solve(self):\\n pass\",\n \"def do_calibration(self):\\n goal = CalculateParametersGoal()\\n self.calibrate_client.send_goal(goal)\\n self.calibrate_client.wait_for_result()\\n result = self.calibrate_client.get_result()\\n rospy.loginfo('Received the calibration results')\\n if result.number_of_images is 0:\\n rospy.logerr('Failed to calibrate the camera.')\\n else:\\n rospy.loginfo('Number of pictures: {}, error: {}'.format(result.number_of_images, result.error))\\n self.save_calibration_parameters(result.intrinsics, result.error, result.number_of_images)\",\n \"def get_sol(self):\",\n \"def calibrate(self):\\n if self.iCAL_required:\\n logger.info(\\\"iCAL-sensitive registers were modified, performing calibration...\\\")\\n return self._run_ical()\\n else:\\n logger.info(\\\"iCAL-sensitive registers were not modified, skipping calibration...\\\")\\n return 0 # Still success\",\n \"def calibrate(self):\\n\\t\\tLTOGRIGHT = []\\n\\t\\tLTOGUP = []\\n\\t\\tRTOGRIGHT = []\\n\\t\\tRTOGUP = []\\n\\t\\tstart = time.time()\\n\\t\\tcalibration_time = 5.0\\n\\t\\twhile time.time() - start < calibration_time:\\n\\t\\t\\tevents = pygame.event.get()\\n\\t\\t\\tfor event in events:\\n\\t\\t\\t\\tif event.type == pygame.JOYAXISMOTION:\\n\\t\\t\\t\\t\\tLTOGRIGHT.append(self.joystick.get_axis(self.LTOGRIGHT))\\n\\t\\t\\t\\t\\tLTOGUP.append(-self.joystick.get_axis(self.LTOGUP))\\n\\t\\t\\t\\t\\tRTOGRIGHT.append(self.joystick.get_axis(self.RTOGRIGHT))\\n\\t\\t\\t\\t\\tRTOGUP.append(-self.joystick.get_axis(self.RTOGUP))\\n\\n\\t\\t# calibration sets highest value equal to 1.0\\n\\t\\tself.calibration[0] = 1.0/max(LTOGRIGHT)\\n\\t\\tself.calibration[1] = -1.0/min(LTOGRIGHT)\\n\\t\\tself.calibration[2] = -1.0/min(LTOGUP)\\n\\t\\tself.calibration[3] = 1.0/max(LTOGUP)\\n\\t\\tself.calibration[4] = 1.0/max(RTOGRIGHT)\\n\\t\\tself.calibration[5] = -1.0/min(RTOGRIGHT)\\n\\t\\tself.calibration[6] = -1.0/min(RTOGUP)\\n\\t\\tself.calibration[7] = 1.0/max(RTOGUP)\",\n \"def converged(self) -> bool:\",\n \"def converged(self) -> bool:\",\n \"def converged(self) -> bool:\",\n \"def evaluate_solution(still_x, still_y, still_z, still_n, calibration_parameters, still_temperature=None):\\n\\n # Temporarily adjust the channels of still data, which has collapsed x,y,z values\\n do_calibration(still_x, still_y, still_z, still_temperature, calibration_parameters)\\n\\n # Get the VM of the calibrated channel\\n vm = infer_vector_magnitude(still_x, still_y, still_z)\\n\\n # se = sum error\\n se = 0.0\\n\\n for vm_val,n in zip(vm.data, still_n.data):\\n se += (abs(1.0 - vm_val)**2)*n\\n\\n rmse = math.sqrt(se / len(vm.data))\\n\\n # Undo the temporary calibration\\n undo_calibration(still_x, still_y, still_z, still_temperature, calibration_parameters)\\n\\n return rmse\",\n \"def solvate(self):\\n\\n pass\",\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 analyse(self):\\n self.__try_fitting()\\n self.second.rotate()\\n self.__try_fitting()\",\n \"def _advance_settings(self, sol):\\r\\n if self.cond == True:\\r\\n # Save last solution...\\r\\n self.lst_tmp = sol\\r\\n # Check if all timesteps are complete.\\r\\n self.current_T += self.d_T\\r\\n self.step += 1\\r\\n if self.current_T > self.max_T:\\r\\n return False\\r\\n # Set to not be conduction any more\\r\\n self.cond = False\\r\\n if len(self.fq_list) > 0:\\r\\n self.rad = 0\\r\\n else:\\r\\n # There are radiation steps to do.\\r\\n self.cond = True\\r\\n return True\\r\\n\\r\\n # If we're here, we're either not done anything yet or have\\r\\n # just done a radiation step.\\r\\n if self.rad != None:\\r\\n # Save last solution\\r\\n self.lst_rad[self.rad] = sol\\r\\n # Advance to next radiation stage if one exists. Else cond.\\r\\n if self.rad + 1 != len(self.fq_list):\\r\\n self.rad += 1\\r\\n else:\\r\\n self.rad = None\\r\\n self.cond = True\\r\\n return True\\r\\n\\r\\n # If we've made it to here, we must just setting the simulation\\r\\n # going.\\r\\n assert (len(self.fq_list) == len(self.lst_rad))\\r\\n if len(self.lst_rad) > 0:\\r\\n assert (len(self.fq_list) == len(self.absorb_coeffs))\\r\\n assert (self.refr_idx_vol >= 0.0)\\r\\n # Could set to zero, but that might limit restarts. Just check\\r\\n # Validity....\\r\\n assert (self.step != None)\\r\\n assert (self.d_T > 0.0)\\r\\n assert (self.current_T != None)\\r\\n assert (self.max_T != None)\\r\\n assert (self.max_T > self.current_T)\\r\\n assert (self.diff_scale >= 0.0)\\r\\n assert (self.diff_scale <= 1.0)\\r\\n assert (self.thermal_conductivity > 0.0)\\r\\n assert (self.alpha >= 0.0)\\r\\n assert (self.refr_idx_background >= 0.0)\\r\\n # Set the ball rolling:\\r\\n if len(self.fq_list) > 0:\\r\\n # We can set solver for frequencies first...\\r\\n self.rad = 0\\r\\n else:\\r\\n self.cond = True\\r\\n return True\",\n \"def solve(self, regparam):\\n self.regparam = regparam\\n \\n #Some counters for bookkeeping\\n self.stepcounter = 0\\n self.flipcounter = 0\\n self.nochangecounter = 0\\n \\n #Cached results\\n self.evals = np.multiply(self.svals, self.svals)\\n self.newevals = 1. / (self.evals + self.regparam)\\n newevalslamtilde = np.multiply(self.evals, self.newevals)\\n self.D = np.sqrt(newevalslamtilde)\\n #self.D = -newevalslamtilde\\n \\n self.VTY = self.svecs.T * self.Y\\n DVTY = np.multiply(self.D.T, self.svecs.T * self.Y)\\n \\n #Using lists in order to avoid unnecessary matrix slicings\\n self.DVTY_list = []\\n self.YTVDDVTY_list = []\\n self.classFitnessList = []\\n for i in range(self.labelcount):\\n DVTY_i = DVTY[:,i]\\n self.DVTY_list.append(DVTY_i)\\n YTVDDVTY_i = DVTY_i.T * DVTY_i\\n self.YTVDDVTY_list.append(YTVDDVTY_i)\\n fitness_i = self.size - DVTY_i.T * DVTY_i\\n self.classFitnessList.append(fitness_i)\\n \\n self.Dsvecs_list = []\\n self.svecsDDsvecs_list = []\\n for i in range(self.size):\\n Dsvec = np.multiply(self.D.T, self.svecs[i].T)\\n self.Dsvecs_list.append(Dsvec)\\n self.svecsDDsvecs_list.append(Dsvec.T*Dsvec)\\n \\n self.updateA()\\n \\n \\n converged = False\\n print(self.classcounts.T)\\n if self.callbackfun is not None:\\n self.callbackfun.callback(self)\\n while True:\\n \\n converged = self.roundRobin()\\n print(self.classcounts.T)\\n if self.callbackfun is not None:\\n self.callbackfun.callback(self)\\n if converged: break\\n \\n if self.oneclass:\\n self.Y = self.Y[:, 0]\\n self.A = self.A[:, 0]\\n self.results['predicted_clusters_for_training_data'] = self.Y\\n self.predictor = self.svdad.createModel(self)\",\n \"def _calibration_test(self, dataset_name):\\n self.setup_flags()\\n test_setup = self._get_setup(dataset_name)\\n if test_setup[\\\"error_test\\\"]:\\n self._calibration_error_test(dataset_name, \\\"Calibration\\\")\\n else:\\n self.run_app(\\\"Calibration\\\")\\n record = parse_calibration_results(\\n self.io_args.log_dir, bin_name=\\\"Calibration\\\"\\n )\\n self.check_metrics(record, test_setup)\",\n \"def safe_calibrate(self):\\n\\n status = -1\\n while status < 3:\\n ifMutexAcquire(self.use_mutex)\\n try:\\n new_status = self.BNO055.get_calibration_status()[3]\\n except:\\n new_status = -1\\n finally:\\n ifMutexRelease(self.use_mutex)\\n if new_status != status:\\n status = new_status\",\n \"def calibrate(self, x, y) -> None:\\n pass\",\n \"def solve(self):\\n\\n # sanity check\\n if self.G is None or self.curve is None or self.Q is None:\\n print(\\\"Can't solve not all parameters are set\\\")\\n return False # unsuccessful\\n\\n self.count = 1 # initial count\\n self.start = time.time()\\n\\n order = self.curve.order(self.G) # get order of generator\\n\\n ############ POLLARD'S RHO + FLOYD'S EXTENSION ############\\n found = False\\n\\n # will probably find a factor, so need to loop with random numbers until we find it\\n while not found:\\n\\n ############ GENERATE RANDOM FUNCTION POINTS ############\\n points = [] # list of points to inform our random function\\n\\n for _ in range(17):\\n a = secrets.randbelow(order)\\n b = secrets.randbelow(order)\\n P = (self.G * a) + (self.Q * b) # linear combination\\n points.append([P, a, b]) # add to list\\n\\n ############ RANDOM START POINTS ############\\n Y, aY, bY = X, aX, bX = points.pop() # random starting points\\n\\n ############ FLOYD'S CYCLE DETECTION ############\\n while not found:\\n X, aX, bX = g((X, aX, bX), order, points) # first runner\\n Y, aY, bY = g(g((Y,aY,bY),order,points),order,points) # second runner\\n\\n found = X == Y # detect match\\n self.count += 1 # increment count\\n\\n if bX == bY and aX == aY: # if we arrive at identical combinations\\n found = False # reset and try again\\n else:\\n inv = modInverse((bX - bY) % order, order) # get mod inverse\\n\\n if inv == 0: # if no mod inverse exists\\n found = False # need to randomly try again\\n else: # we have found k\\n self.k = ((aY - aX) * inv) % order # so set it\\n\\n if self.G * self.k != self.Q: # not always 100% going to work\\n print(\\\"error\\\")\\n found = True\\n\\n self.time = time.time() - self.start\\n\\n # set space\\n self.space = 18\\n\\n if self.verbose:\\n print(\\\"k:\\\", self.k)\\n print(\\\"Time taken: %.3f s\\\" % (self.time)) # print time taken\\n print(\\\"Space used: %d\\\" % (self.space)) # print space used\\n print(\\\"Numbers checked:\\\", self.count) # print total count\\n\\n return True\",\n \"def method1(self):\\n cres=0. # Variable for storing Chern number.\\n # The U matrices from Fukui's method; storage...\\n Ux=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n Uy=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n \\n # ... and calculation of U matrices\\n for ix in range(self.kS.Nx+1):\\n for iy in range(self.kS.Ny+1):\\n mat1=self.alleigvecs[:,:,ix ,iy ]\\n if ix<self.kS.Nx:\\n mat2=self.alleigvecs[:,:,ix+1,iy ]\\n else:\\n mat2=self.alleigvecs[:,:,1 ,iy ]\\n if iy<self.kS.Ny:\\n mat3=self.alleigvecs[:,:,ix ,iy+1]\\n else:\\n mat3=self.alleigvecs[:,:,ix ,1 ]\\n Ux[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat2)[:self.NL,:self.NL])\\n Uy[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat3)[:self.NL,:self.NL])\\n \\n # Local estimates of Berry curvature; storage ...\\n ftempall=np.zeros((self.kS.Nx,self.kS.Ny),complex)\\n # ... and calculation\\n for ix in range(self.kS.Nx):\\n for iy in range(self.kS.Ny):\\n ftemp=np.log(Ux[ix,iy]*Uy[ix+1,iy]/Ux[ix,iy+1]/Uy[ix,iy])\\n ftempall[ix,iy]=ftemp # ... of local Berry curvature ...\\n cres+=ftemp/2./pi/1j # ... and of Berry phase (Chern number).\\n\\n return cres.real, ftempall\",\n \"def solve_VFI(self):\\r\\n dimC = self.dimA ; dimA = self.dimA ; dimW = self.dimW \\r\\n C = self.c_grid ; A = self.a_grid ; W = self.W_grid\\r\\n tol = self.tol ; Niter = self.Niter ; R = self.R\\r\\n beta = self.beta ; Pi = self.Pi\\r\\n \\r\\n V0 = np.zeros((dimA,dimC,dimW))\\r\\n V1 = np.zeros((dimA,dimC,dimW))\\r\\n Pol = np.zeros((dimA,dimC,dimW))\\r\\n U = np.zeros((dimA,dimC,dimW))\\r\\n \\r\\n t0 = time()\\r\\n diff = 1 ; niter = 0\\r\\n \\r\\n while diff > tol:\\r\\n niter += 1\\r\\n # Value update step\\r\\n for ia in range(dimA):\\r\\n for ic in range(dimC):\\r\\n for iw in range(dimW):\\r\\n c = W[iw] + R*A[ia] - A\\r\\n x = C[ic]\\r\\n \\r\\n c[c < 0] = np.nan \\r\\n if x < 0:\\r\\n x = np.nan\\r\\n \\r\\n u = self.u(c,x) \\r\\n U[:,ic,iw] = u \\r\\n \\r\\n Objective = U + beta * V0 @ Pi.T\\r\\n V1[ia,:,:] = np.nanmax(Objective, axis = 0)\\r\\n Pol[ia,:,:] = np.nanargmax(Objective, axis = 0)\\r\\n \\r\\n # Evaluate distance between the value functions\\r\\n diff = np.max(np.max(np.abs(V1 - V0))) \\r\\n V0[:] = V1\\r\\n \\r\\n # Break the while loop if too many iterations\\r\\n #print(\\\"The current error is \\\"+str(diff))\\r\\n if niter > Niter:\\r\\n print('Ops, no convergence')\\r\\n break\\r\\n \\r\\n t1 = time()\\r\\n #print('VFI algorithm took {0:0d} iterations and {1:.2f} seconds.'.format(niter, t1 - t0))\\r\\n \\r\\n self.V1 = V1 ; self.Pol = Pol\",\n \"def automatic_results(self):\\n self.find_coefficients()\\n self.calculate_numerical_solution()\\n self.plot_solution()\\n self.L2_norm()\",\n \"def checkSolution(self):\\n movesToEndblock = self.gridSize - self.changeable[0] - 2\\n if self.checkMove(0,movesToEndblock) == 0:\\n return 0\\n return 1\",\n \"def run(self):\\n #self.source_fixed = center_of_mass(self.source_mesh.vs)\\n #self.destination_fixed = center_of_mass(self.destination_mesh.vs)\\n\\n source_high_curvature = get_mesh_of_high_curvature(self.source_mesh)\\n destination_high_curvature = get_mesh_of_high_curvature(self.destination_mesh)\\n\\n self.matrix, error = icp(source_high_curvature.vs, \\n destination_high_curvature.vs, \\n self.source_fixed, \\n self.destination_fixed,\\n 300,\\n verbose = self.verbose)\\n\\n self.inverse = np.linalg.inv(self.matrix)\\n self.global_confidence = 1 - error\\n print self.global_confidence\",\n \"def _check_init_solution(self):\\r\\n B = np.array([self._A[:, j] for j in self._basic_vars]).transpose()\\r\\n self._B_inv = np.linalg.inv(B)\\r\\n x_B = self._B_inv @ self._b\\r\\n for x in x_B:\\r\\n if x < 0:\\r\\n raise AssertionError(\\\"Initial solution is not feasible!\\\")\",\n \"def fit(self):\\n self._minuit_problem.migrad() # run optimizer\\n self._status = 0 if self._minuit_problem.migrad_ok() else 1\",\n \"def calibrate(self):\\n\\n self.update_message('Calibrating platform...')\\n\\n self.calibrate_platform()\\n\\n self.update_message('Platform Calibrated.')\\n\\n # calibrate arm x axis\\n self.update_message('Calibrating x axis...')\\n calibrated = self.calibrate_arm(0)\\n\\n if not calibrated:\\n self.update_message('ERROR: Could not calibrate x axis.')\\n return 0\\n else:\\n self.update_message('x axis calibrated.')\\n\\n # calibrate arm y axis\\n self.update_message('Calibrating y axis...')\\n calibrated = self.calibrate_arm(1)\\n\\n if not calibrated:\\n self.update_message('ERROR: Could not calibrate y axis.')\\n return 0\\n else:\\n self.update_message('y axis calibrated.')\\n\\n # calibrate arm z axis\\n self.update_message('Calibrating z axis...')\\n calibrated = self.calibrate_arm(2)\\n\\n if not calibrated:\\n self.update_message('ERROR: Could not calibrate z axis.')\\n return 0\\n else:\\n self.update_message('z axis calibrated.\\\\n'\\n 'Autocalibration done.\\\\n'\\n 'Accuracy: {}'.format(self.matrix_accuracy()))\\n\\n # Getting the direction to withdraw pipette along x axis\\n self.get_withdraw_sign()\\n self.inv_mat = np.linalg.inv(self.mat)\\n self.calibrated = 1\\n self.cam.click_on_window = True\\n self.save_calibration()\\n return 1\",\n \"def calibrate(): \\n \\n # Calibrate of the run using beam data. Creates a folder cal-files/caltag \\n # containing all calibration data. \\n CalObj = Calibration(steerfiles=steerfiles, name=localcaltag + '-cal') \\n\\n # Set Beam energy\\n CalObj.set_beam_momentum(beamenergy)\\n\\n # Get gearfile and set air as DUT material\\n localgearfile = CalObj.get_filename('gear.xml')\\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='thickness', value=0.0001)\\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='radLength', value=304000.0)\\n \\n # Create list of calibration steps \\n calpath = create_calibration_path(CalObj)\\n \\n # Run the calibration steps \\n CalObj.calibrate(path=calpath,ifile=rawfile_air,caltag=localcaltag)\",\n \"def convergence_on_track(self):\\n\\n on_track = True\\n threshold = 5. # used to check condition if at least one of charnge_neutrality, rms-error goes down fast enough\\n\\n # first check if previous calculation was stopped due to reaching the QBOUND limit\\n try:\\n calc_reached_qbound = self.ctx.last_calc.outputs.output_parameters.get_dict(\\n )['convergence_group']['calculation_converged']\\n except AttributeError: # captures error when last_calc dies not have an output node\\n calc_reached_qbound = False\\n except KeyError: # captures\\n calc_reached_qbound = False\\n\\n if self.ctx.kkrimp_step_success and not calc_reached_qbound:\\n first_rms = self.ctx.last_rms_all[0]\\n # skip first if this is the initial LDA+U iteration because there we see the original non-LDAU convergence value\\n if 'settings_LDAU' in self.inputs and self.ctx.loop_count < 2 and len(self.ctx.last_rms_all) > 1:\\n first_rms = self.ctx.last_rms_all[1]\\n last_rms = self.ctx.last_rms_all[-1]\\n # use this trick to avoid division by zero\\n if last_rms == 0:\\n last_rms = 10**-16\\n r = last_rms / first_rms\\n message = f'INFO: convergence check: first/last rms {first_rms}, {last_rms}'\\n self.report(message)\\n if r < 1:\\n message = 'INFO: convergence check: rms goes down'\\n self.report(message)\\n on_track = True\\n elif r > threshold:\\n message = 'INFO: convergence check: rms goes up too fast, convergence is not expected'\\n self.report(message)\\n on_track = False\\n elif len(self.ctx.last_rms_all) == 1:\\n message = 'INFO: convergence check: already converged after single iteration'\\n self.report(message)\\n on_track = True\\n else:\\n message = 'INFO: convergence check: rms does not shrink fast enough, convergence is not expected'\\n self.report(message)\\n on_track = False\\n elif calc_reached_qbound:\\n message = 'INFO: convergence check: calculation reached QBOUND'\\n self.report(message)\\n on_track = True\\n else:\\n message = 'INFO: convergence check: calculation unsuccessful'\\n self.report(message)\\n on_track = False\\n\\n message = f'INFO: convergence check result: {on_track}'\\n self.report(message)\\n\\n return on_track\",\n \"def start_solving(self):\\n self.mesh.output_vtk_mesh(self.model_name + \\\"0\\\", \\n [self.current_pressure, \\n self.mesh.get_cell_domain_all()], \\n [\\\"pressure\\\", \\\"domain\\\"])\\n\\n self.time_step_output(0., 0)\\n\\n for time_step in range(1,self.number_of_time_steps+1):\\n current_time = time_step*self.delta_t\\n print(time_step)\\n\\n self.update_pressure()\\n self.find_upwinding_direction()\\n self.update_concentration()\\n \\n if time_step%self.output_frequency == 0:\\n self.mesh.output_vtk_mesh(self.model_name+str(time_step), \\n [self.current_pressure,\\n self.current_concentration, \\n self.mesh.get_cell_domain_all()],\\n [\\\"pressure\\\", \\\"concentration\\\" , \\\"domain\\\"])\\n\\n self.time_step_output(current_time, time_step)\",\n \"def _calc_corrections(self): \\n searchIter= self._niter-1\\n while searchIter > 0:\\n trySavefilename= self._createSavefilename(searchIter)\\n if os.path.exists(trySavefilename):\\n trySavefile= open(trySavefilename,'rb')\\n corrections= sc.array(pickle.load(trySavefile))\\n trySavefile.close()\\n break\\n else:\\n searchIter-= 1\\n if searchIter == 0:\\n corrections= sc.ones((self._npoints,2))\\n for ii in range(searchIter,self._niter):\\n if ii == 0:\\n currentDF= self._dftype(surfaceSigma=self._surfaceSigmaProfile,\\n beta=self._beta)\\n else:\\n currentDF= self._dftype(surfaceSigma=self._surfaceSigmaProfile,\\n beta=self._beta,\\n corrections=corrections,\\n npoints=self._npoints,\\n rmax=self._rmax,\\n savedir=self._savedir,\\n interp_k=self._interp_k)\\n newcorrections= sc.zeros((self._npoints,2))\\n for jj in range(self._npoints):\\n thisSurface= currentDF.surfacemass(self._rs[jj],\\n use_physical=False)\\n newcorrections[jj,0]= currentDF.targetSurfacemass(self._rs[jj],use_physical=False)/thisSurface\\n newcorrections[jj,1]= currentDF.targetSigma2(self._rs[jj],use_physical=False)*thisSurface\\\\\\n /currentDF.sigma2surfacemass(self._rs[jj],\\n use_physical=False)\\n #print(jj, newcorrections[jj,:])\\n corrections*= newcorrections\\n #Save\\n picklethis= []\\n for arr in list(corrections):\\n picklethis.append([float(a) for a in arr])\\n save_pickles(self._savefilename,picklethis) #We pickle a list for platform-independence)\\n return corrections\",\n \"def calibration(self, pulse_min: int, pulse_max: int, pulse_centre: int, /) -> None:\",\n \"def calibration(N,kb,T,Ekinv,V):\\n lamb = np.sqrt((N-1)*3*kb*T/(Ekinv*2))\\n \\n if lamb < 0.9999:\\n V = lamb*V\\n elif lamb>1.0001:\\n V = lamb*V\\n \\n return V\",\n \"def solve(self):\\n converged = False\\n N = 500\\n x = np.linspace(-100.0, 100.0, N)\\n y = np.linspace(-100.0, 100.0, N)\\n X, Y = np.meshgrid(x,y)\\n Z = function.evaluate(X,Y)\\n fileadd = 0;\\n while not converged:\\n plt.hold(False)\\n plt.contour(X, Y, Z)\\n plt.show()\\n self.update()\\n isconverged = self.checkConvergence(self.iteration)\\n converged = isconverged[0] #set to boolean result\\n self.iteration += 1\\n if self.disp:\\n pylab.savefig('single_plot_%s.jpg' %('0'*(3-len(str(fileadd))) + str(fileadd))) # If display is turned on, save figure for visualization\\n fileadd += 1\\n return [self.overBestPos, self.overBestVal, isconverged[1]]\",\n \"def test_get_solution(self):\\n pass\",\n \"def _compute_results(self):\\n self.Y_best = best_value(self.Y)\\n self.x_opt = self.X[np.argmin(self.Y),:]\\n self.fx_opt = np.min(self.Y)\\n self.distance = self._compute_distance_betw_consecutive_x()\",\n \"def force_calibration_controller_test():\\n print(f\\\"Running {__file__}::{force_calibration_controller_test.__name__}()\\\")\\n arm_state = State()\\n alpha=0.2\\n ctrl = EMAForceCalibrator(Connection(arm_state), alpha=alpha)\\n cmd = Command()\\n state = State()\\n ctrl.execute(cmd, state)\\n assert np.all(ctrl.force_average.array == 0)\\n\\n arm_state.sensor_force()[:] = [2,2,2,2,2,2]\\n ctrl.execute(cmd, state)\\n assert np.all(ctrl.force_average.array != 0)\\n assert state.sensor_force().allclose(np.array([2,2,2,2,2,2])*(1-alpha), 0.001)\\n\\n for i in range(100):\\n ctrl.execute(cmd, state)\\n assert ctrl.force_average.allclose([2,2,2,2,2,2], 0.001)\\n assert state.sensor_force().allclose([0,0,0,0,0,0], 0.001)\\n\\n arm_state.sensor_force()[:] = [0,0,0,0,0,0]\\n ctrl.execute(cmd, state)\\n assert state.sensor_force().allclose(np.array([-2,-2,-2,-2,-2,-2])*(1-alpha), 0.001)\\n\\n for i in range(100):\\n ctrl.execute(cmd, state)\\n assert ctrl.force_average.allclose([0,0,0,0,0,0], 0.001)\\n assert state.sensor_force().allclose([0,0,0,0,0,0], 0.001)\\n\\n print(\\\"Passed.\\\")\",\n \"def _compute_correction(self, initial_state, final_state, a, b, c, s):\\r\\n pertub = self.pertub\\r\\n pertub_s = pertub *10\\r\\n \\r\\n pred_no_pertub = self._motion_update_one_shot(initial_state, a, b, c, s)\\r\\n pred_pertub_a = self._motion_update_one_shot(initial_state, a +pertub, b, c, s)\\r\\n pred_pertub_b = self._motion_update_one_shot(initial_state, a, b +pertub, c, s)\\r\\n # no need to correct C, C is constrained by kappa_final\\r\\n # # pred_pertub_c = self._motion_update_one_shot(initial_state, a, b, c +pertub, s)\\r\\n pred_pertub_s = self._motion_update_one_shot(initial_state, a, b, c, s +pertub_s)\\r\\n\\r\\n d_state = np.zeros((3,1))\\r\\n d_pertub_state = np.zeros((3,3))\\r\\n Jacobian = np.zeros((3,3))\\r\\n for i in range(0, 3):\\r\\n d_pertub_state[i][0] = (final_state[i] - pred_pertub_a[i]) # a\\r\\n d_pertub_state[i][1] = (final_state[i] - pred_pertub_b[i]) # b\\r\\n # d_pertub_state[i][2] = (final_state[i] - pred_pertub_c[i]) # c (no update)\\r\\n d_pertub_state[i][2] = (final_state[i] - pred_pertub_s[i]) # s\\r\\n \\r\\n d_state[i] = final_state[i] - pred_no_pertub[i]\\r\\n \\r\\n Jacobian[i][0] = (d_pertub_state[i][0] - d_state[i])/pertub # a\\r\\n Jacobian[i][1] = (d_pertub_state[i][1] - d_state[i])/pertub # b\\r\\n # Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub # c (no update)\\r\\n Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub_s # s\\r\\n\\r\\n # inv_Jacobian = np.linalg.inv(Jacobian)\\r\\n inv_Jacobian = np.linalg.pinv(Jacobian)\\r\\n correction = np.dot(inv_Jacobian, d_state)\\r\\n # pdb.set_trace()\\r\\n return correction\",\n \"def solve(self):\\n if not self.solvable:\\n print('Suduko not Solvable')\\n return False\\n res=self.back(0, 0)\\n # if self.a[0][0]!=0:\\n # res=self.back(0, 1)\\n # else:\\n # for i in range(1, 10):\\n # self.a[0][0]=i\\n # res=self.back(0, 1)\\n # if res:\\n # break\\n if res:\\n self.check_if_solvable()\\n print(\\\"Sudoku Solved!\\\")\\n print(self.a)\\n return self.a\\n else: print(\\\"Not Solvable\\\")\\n return False\",\n \"def calibration(exp, args):\\n show_text(\\\"Nous allons faire un calibrage\\\", args).present()\\n exp.clock.wait(1500)\\n expyriment.stimuli.FixCross(size=(25, 25),\\n line_width=3,\\n colour=args[\\\"stimuli_color\\\"]).present()\\n exp.clock.wait(2100)\",\n \"def solve(self):\\n for x in range(9):\\n for y in range(9):\\n if self.arr[x][y] == 0:\\n for value in range(1,10):\\n if self.is_possible_value(x,y,value):\\n self.arr[x][y] = value\\n self.solve()\\n self.arr[x][y] = 0 \\n return\\n print(np.matrix(self.arr))\",\n \"def _calibrate_camera():\\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)\\n vertical, horizon = 7, 9 # target corners in vertical and horizontal direction\\n\\n grid = np.zeros((vertical * horizon, 3), np.float32)\\n grid[:, :2] = np.mgrid[:horizon, :vertical].T.reshape(-1, 2)\\n\\n obj_points = [] # 3d point in real world space\\n img_points = [] # 2d points in image plane\\n\\n image_list = glob.glob(os.path.join('C:\\\\\\\\Users\\\\\\\\chuyangl\\\\\\\\Desktop\\\\\\\\liushuai\\\\\\\\calibrator\\\\\\\\board\\\\\\\\right', \\\"*.bmp\\\"))\\n #print(image_list)\\n gray = None\\n for img_name in image_list:\\n print(img_name)\\n image = cv2.imread(img_name)\\n gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\\n\\n # find the chess board corners\\n found, corners = cv2.findChessboardCorners(gray, (horizon, vertical), None)\\n #print(\\\"corner shape\\\",corners.shape,corners)\\n\\n # add object points, image points (after refining them)\\n if found:\\n obj_points.append(grid)\\n corners = cv2.cornerSubPix(gray, corners, (5, 5), (-1, -1), criteria) #corner是像素坐标 refine 坐标\\n img_points.append(corners)\\n #print(\\\"corner shape\\\",corners.shape,corners)\\n else:\\n print('can not find %s corners' % img_name)\\n\\n #print(corners)\\n #print(grid)\\n ret, matrix, distortion, rotation, translation = \\\\\\n cv2.calibrateCamera(obj_points, img_points, gray.shape[::-1], None, None)\\n print(type(img_points[0]),img_points[0].shape,img_points[0])\\n print(type(obj_points[0]),obj_points[0].shape,obj_points[0]) \\n #cv2.calibrateCamera([obj_points[-1]], [img_points[-1]], gray.shape[::-1], None, None)\\n #print(\\\"RT Matrix\\\",np.array(rotation).shape,np.array(translation).shape,rotation)\\n \\n print(\\\"projMtx:\\\\n\\\",getProjMtx(np.array(rotation[0]),np.array(translation[0])))\\n projMtx = getProjMtx(np.array(rotation[0]),np.array(translation[0]))\\n _3d = np.array([8,0,0,1])\\n _2d = np.dot(np.dot(matrix,projMtx,),_3d)\\n _2d = _2d/_2d[2]\\n print(\\\"2d:\\\",_2d,img_points[0][7])\\n mean_error = 0\\n for i in range(len(obj_points)):\\n new_img_points, _ = cv2.projectPoints(obj_points[i], rotation[i], translation[i], matrix, distortion)#3D点投影到平面\\n error = cv2.norm(img_points[i], new_img_points, cv2.NORM_L2) / len(new_img_points)\\n mean_error += error\\n print(\\\"new and old:\\\",new_img_points[1],img_points[i][1])\\n print(\\\"mean error: \\\", mean_error / len(obj_points))\\n\\n return np.array(matrix), np.array(distortion)\",\n \"def run(self):\\n\\n # Initializing required variables for the algorithm\\n start = time.time()\\n i = 0\\n w = self.w\\n k = 99.99\\n\\n #Running the algorithm till tolerance is reached\\n while k > self.tolerance: \\n\\n i = i + 1\\n\\n if self.verbose:\\n print(\\\"Iteration \\\" + str(i),end=\\\"\\\\r\\\")\\n\\n # Following is a gradient descent algorithm\\n # You can find the update step at the following\\n # link, https://raw.githubusercontent.com/mnk400/linearRegression/master/img/EUC.png\\n t_0 = w.T.dot(w)\\n t_1 = self.x.T.dot(self.x).dot(w)\\n gradient = (2/t_0) * (t_1) - (2/t_0**2) * np.transpose(w).dot(t_1) * (w)\\n w_new = w - (1/self.DATAPOINTS) * 0.3 * gradient\\n w_new[-1] = -1\\n l = len(self.x[0]) - 1 \\n y_plt = np.dot(self.x[:,0:l],w_new[:-1]) \\n\\n #tolerance is checked against the root mean square of change in weights\\n k = np.dot(np.transpose(w - w_new),(w - w_new))\\n\\n #Updating the weights \\n w = w_new\\n\\n if self.verbose:\\n print(\\\"Tolerance Reached\\\")\\n timetaken = round(time.time() - start, 3)\\n print(\\\"Ran for \\\" + str(timetaken) + \\\" seconds\\\" + \\\" in \\\" + str(i) + \\\" iterations.\\\")\\n\\n return w_new, y_plt\",\n \"def calibrate(self):\\n\\t\\t\\n\\t\\t# CALIBRATION\\n\\t\\t# determine the calibration points\\n\\t\\tcalibpoints = []\\n\\t\\tfor x in [0.1,0.5,0.9]:\\n\\t\\t\\tfor y in [0.1,0.5,0.9]:\\n\\t\\t\\t\\tcalibpoints.append((int(x*self.dispsize[0]),int(y*self.dispsize[1])))\\n\\t\\trandom.shuffle(calibpoints)\\n\\t\\t\\n\\t\\t# show a message\\n\\t\\tself.screen.clear()\\n\\t\\tself.screen.draw_text(\\n\\t\\t\\ttext=\\\"Press Space to calibrate, S to skip, and Q to quit\\\",\\n\\t\\t\\tfontsize=20)\\n\\t\\tself.disp.fill(self.screen)\\n\\t\\tself.disp.show()\\n\\t\\t\\n\\t\\t# wait for keyboard input\\n\\t\\tkey, keytime = self.kb.get_key(keylist=['q', 's', 'space'],\\n\\t\\t\\ttimeout=None, flush=True)\\n\\t\\tif key == 's':\\n\\t\\t\\treturn True\\n\\t\\tif key == 'q':\\n\\t\\t\\tquited = True\\n\\t\\telse:\\n\\t\\t\\tquited = False\\n\\t\\t\\n\\t\\t# Pause the processing of samples during the calibration.\\n#\\t\\tself.eyetribe._pause_sample_processing()\\n\\t\\t# run until the user is statisfied, or quits\\n\\t\\tcalibrated = False\\n\\t\\tcalibresult = None\\n\\t\\twhile not quited and not calibrated:\\n\\n\\t\\t\\t# Clear the existing calibration.\\n\\t\\t\\tif self.eyetribe._tracker.get_iscalibrated():\\n\\t\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\t\\tself.eyetribe.calibration.clear()\\n\\t\\t\\t\\tself.eyetribe._lock.release()\\n\\t\\t\\t\\n\\t\\t\\t# Wait for a bit.\\n\\t\\t\\tclock.pause(1500)\\n\\n\\t\\t\\t# start a new calibration\\n\\t\\t\\tif not self.eyetribe._tracker.get_iscalibrating():\\n\\t\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\t\\tself.eyetribe.calibration.start(pointcount=len(calibpoints))\\n\\t\\t\\t\\tself.eyetribe._lock.release()\\n\\t\\t\\t\\n\\t\\t\\t# loop through calibration points\\n\\t\\t\\tfor cpos in calibpoints:\\n\\t\\t\\t\\t# Check whether the calibration is already done.\\n\\t\\t\\t\\t# (Not sure how or why, but for some reason some data\\n\\t\\t\\t\\t# can persist between calbrations, and the tracker will\\n\\t\\t\\t\\t# simply stop allowing further pointstart requests.)\\n\\t\\t\\t\\tif self.eyetribe._tracker.get_iscalibrated():\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# Draw a calibration target.\\n\\t\\t\\t\\tself.draw_calibration_target(cpos[0], cpos[1])\\n\\t\\t\\t\\t# wait for a bit to allow participant to start looking at\\n\\t\\t\\t\\t# the calibration point (#TODO: space press?)\\n\\t\\t\\t\\tclock.pause(settings.EYETRIBEPRECALIBDUR)\\n\\t\\t\\t\\t# start calibration of point\\n\\t\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\t\\tself.eyetribe.calibration.pointstart(cpos[0],cpos[1])\\n\\t\\t\\t\\tself.eyetribe._lock.release()\\n\\t\\t\\t\\t# wait for a second\\n\\t\\t\\t\\tclock.pause(settings.EYETRIBECALIBDUR)\\n\\t\\t\\t\\t# stop calibration of this point\\n\\t\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\t\\tself.eyetribe.calibration.pointend()\\n\\t\\t\\t\\tself.eyetribe._lock.release()\\n\\t\\t\\t\\t# check if the Q key has been pressed\\n\\t\\t\\t\\tif self.kb.get_key(keylist=['q'],timeout=10,flush=False)[0] == 'q':\\n\\t\\t\\t\\t\\t# abort calibration\\n\\t\\t\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\t\\t\\tself.eyetribe.calibration.abort()\\n\\t\\t\\t\\t\\tself.eyetribe._lock.release()\\n\\t\\t\\t\\t\\t# set quited variable and break this for loop\\n\\t\\t\\t\\t\\tquited = True\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\n\\t\\t\\t# retry option if the calibration was aborted\\t\\t\\t\\n\\t\\t\\tif quited:\\n\\t\\t\\t\\t# show retry message\\n\\t\\t\\t\\tself.screen.clear()\\n\\t\\t\\t\\tself.screen.draw_text(\\n\\t\\t\\t\\t\\t\\\"Calibration aborted. Press Space to restart or 'Q' to quit\\\",\\n\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\t\\tself.disp.fill(self.screen)\\n\\t\\t\\t\\tself.disp.show()\\n\\t\\t\\t\\t# get input\\n\\t\\t\\t\\tkey, keytime = self.kb.get_key(keylist=['q','space'], timeout=None, flush=True)\\n\\t\\t\\t\\tif key == 'space':\\n\\t\\t\\t\\t\\t# unset quited Boolean\\n\\t\\t\\t\\t\\tquited = False\\n\\t\\t\\t\\t# skip further processing\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t# empty display\\n\\t\\t\\tself.disp.fill()\\n\\t\\t\\tself.disp.show()\\n\\t\\t\\t# allow for a bit of calculation time\\n\\t\\t\\t# (this is waaaaaay too much)\\n\\t\\t\\tclock.pause(1000)\\n\\t\\t\\t# get the calibration result\\n\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\tcalibresult = self.eyetribe._tracker.get_calibresult()\\n\\t\\t\\tself.eyetribe._lock.release()\\n\\n\\t\\t\\t# results\\n\\t\\t\\t# clear the screen\\n\\t\\t\\tself.screen.clear()\\n\\t\\t\\t# draw results for each point\\n\\t\\t\\tif type(calibresult) == dict:\\n\\t\\t\\t\\tfor p in calibresult['calibpoints']:\\n\\t\\t\\t\\t\\t# only draw the point if data was obtained\\n\\t\\t\\t\\t\\tif p['state'] > 0:\\n\\t\\t\\t\\t\\t\\t# draw the mean error\\n\\t\\t\\t\\t\\t\\t# self.screen.draw_circle(colour=(252,233,79),\\n\\t\\t\\t\\t\\t\\t# \\tpos=(p['cpx'],p['cpy']), r=p['mepix'], pw=0,\\n\\t\\t\\t\\t\\t\\t# \\tfill=True)\\n\\t\\t\\t\\t\\t\\tself.screen.draw_line(spos=(p['cpx'],p['cpy']),\\n\\t\\t\\t\\t\\t\\t\\tepos=(p['mecpx'],p['mecpy']), pw=2)\\n\\t\\t\\t\\t\\t\\t# draw the point\\n\\t\\t\\t\\t\\t\\tself.screen.draw_fixation(fixtype='dot',\\n\\t\\t\\t\\t\\t\\t\\tcolour=(115,210,22), pos=(p['cpx'],p['cpy']))\\n\\t\\t\\t\\t\\t\\t# draw the estimated point\\n\\t\\t\\t\\t\\t\\tself.screen.draw_fixation(fixtype='dot',\\n\\t\\t\\t\\t\\t\\t\\tcolour=(32,74,135), pos=(p['mecpx'],p['mecpy']))\\n\\t\\t\\t\\t\\t\\t# annotate accuracy\\n\\t\\t\\t\\t\\t\\tself.screen.draw_text(text='%.2f' % p['acd'],\\n\\t\\t\\t\\t\\t\\t\\tpos=(p['cpx']+10,p['cpy']+10), fontsize=20)\\n\\t\\t\\t\\t\\t# if no data was obtained, draw the point in red\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tself.screen.draw_fixation(fixtype='dot',\\n\\t\\t\\t\\t\\t\\t\\tcolour=(204,0,0), pos=(p['cpx'],p['cpy']))\\n\\t\\t\\t\\t# draw box for averages\\n\\t\\t\\t\\t# self.screen.draw_rect(colour=(238,238,236), x=int(self.dispsize[0]*0.15), y=int(self.dispsize[1]*0.2), w=400, h=200, pw=0, fill=True)\\n\\t\\t\\t\\t# draw result\\n\\t\\t\\t\\tif calibresult['result']:\\n\\t\\t\\t\\t\\tself.screen.draw_text(text=\\\"Calibration successful\\\",\\n\\t\\t\\t\\t\\t\\tcolour='green',\\n\\t\\t\\t\\t\\t\\tpos=(int(self.dispsize[0]*0.5), int(self.dispsize[1]*0.25)), \\n\\t\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tself.screen.draw_text(text=\\\"Calibration failed\\\",\\n\\t\\t\\t\\t\\t\\tcolour='red',\\n\\t\\t\\t\\t\\t\\tpos=(int(self.dispsize[0]*0.5),int(self.dispsize[1]*0.25)),\\n\\t\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\t\\t# draw average accuracy\\n\\t\\t\\t\\tself.screen.draw_text(\\n\\t\\t\\t\\t\\ttext=\\\"Average error = %.2f degrees\\\" % (calibresult['deg']),\\n\\t\\t\\t\\t\\tpos=(int(self.dispsize[0]*0.5),int(self.dispsize[1]*0.25+30)),\\n\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\t\\t# draw input options\\n\\t\\t\\t\\tself.screen.draw_text(\\n\\t\\t\\t\\t\\ttext=\\\"Press Space to continue or 'R' to restart\\\",\\n\\t\\t\\t\\t\\tpos=(int(self.dispsize[0]*0.5),int(self.dispsize[1]*0.25+60)),\\n\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.screen.draw_text(\\n\\t\\t\\t\\t\\ttext=\\\"Calibration failed. Press 'R' to try again.\\\",\\n\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\t# show the results\\n\\t\\t\\tself.disp.fill(self.screen)\\n\\t\\t\\tself.disp.show()\\n\\t\\t\\t# wait for input\\n\\t\\t\\tkey, keytime = self.kb.get_key(keylist=['space','r'], timeout=None,\\n\\t\\t\\t\\tflush=True)\\n\\t\\t\\t# process input\\n\\t\\t\\tif key == 'space':\\n\\t\\t\\t\\tcalibrated = True\\n\\n\\t\\t# Continue the processing of samples after the calibration.\\n#\\t\\tself.eyetribe._unpause_sample_processing()\\n\\n\\t\\t# calibration failed if the user quited\\n\\t\\tif quited:\\n\\t\\t\\treturn False\\n\\n\\t\\t# NOISE CALIBRATION\\n\\t\\t# get all error estimates (pixels)\\n\\t\\tvar = []\\n\\t\\tfor p in calibresult['calibpoints']:\\n\\t\\t\\t# only draw the point if data was obtained\\n\\t\\t\\tif p['state'] > 0:\\n\\t\\t\\t\\tvar.append(p['mepix'])\\n\\t\\tnoise = sum(var) / float(len(var))\\n\\t\\tself.pxdsttresh = (noise, noise)\\n\\t\\t\\t\\t\\n\\t\\t# AFTERMATH\\n\\t\\t# store some variables\\n\\t\\tpixpercm = (self.dispsize[0]/float(self.screensize[0]) + self.dispsize[1]/float(self.screensize[1])) / 2\\n\\t\\tscreendist = settings.SCREENDIST\\n\\t\\t# calculate thresholds based on tracker settings\\n\\t\\tself.accuracy = ((calibresult['Ldeg'],calibresult['Ldeg']), (calibresult['Rdeg'],calibresult['Rdeg'])) \\n\\t\\tself.pxerrdist = deg2pix(screendist, self.errdist, pixpercm)\\n\\t\\tself.pxfixtresh = deg2pix(screendist, self.fixtresh, pixpercm)\\n\\t\\tself.pxaccuracy = ((deg2pix(screendist, self.accuracy[0][0], pixpercm),deg2pix(screendist, self.accuracy[0][1], pixpercm)), (deg2pix(screendist, self.accuracy[1][0], pixpercm),deg2pix(screendist, self.accuracy[1][1], pixpercm)))\\n\\t\\tself.pxspdtresh = deg2pix(screendist, self.spdtresh/1000.0, pixpercm) # in pixels per millisecond\\n\\t\\tself.pxacctresh = deg2pix(screendist, self.accthresh/1000.0, pixpercm) # in pixels per millisecond**2\\n\\n\\t\\t# calibration report\\n\\t\\tself.log(\\\"pygaze calibration report start\\\")\\n\\t\\tself.log(\\\"accuracy (degrees): LX=%s, LY=%s, RX=%s, RY=%s\\\" % (self.accuracy[0][0],self.accuracy[0][1],self.accuracy[1][0],self.accuracy[1][1]))\\n\\t\\tself.log(\\\"accuracy (in pixels): LX=%s, LY=%s, RX=%s, RY=%s\\\" % (self.pxaccuracy[0][0],self.pxaccuracy[0][1],self.pxaccuracy[1][0],self.pxaccuracy[1][1]))\\n\\t\\tself.log(\\\"precision (RMS noise in pixels): X=%s, Y=%s\\\" % (self.pxdsttresh[0],self.pxdsttresh[1]))\\n\\t\\tself.log(\\\"distance between participant and display: %s cm\\\" % screendist)\\n\\t\\tself.log(\\\"fixation threshold: %s pixels\\\" % self.pxfixtresh)\\n\\t\\tself.log(\\\"speed threshold: %s pixels/ms\\\" % self.pxspdtresh)\\n\\t\\tself.log(\\\"acceleration threshold: %s pixels/ms**2\\\" % self.pxacctresh)\\n\\t\\tself.log(\\\"pygaze calibration report end\\\")\\n\\n\\t\\treturn True\",\n \"def has_solution(self) -> bool:\\n pass\",\n \"def solve(self):\\n \\n raise NotImplementedError(\\\"not implemented!\\\")\",\n \"def test_ackley(self):\\n fun = get_problem('ackley', self.dimension)\\n self.assertAlmostEqual(fun(self.array), 0.0, places=10)\",\n \"def steering_calibration(self):\\n\\n # Minimum change of rotary encoder per 100 ms to detect stall\\n min_difference = 5\\n # Calibration motor power in percentage (absolute)\\n calibration_power = 30\\n\\n print('Calibration of steering axis started')\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n last_pos = 99999999 # any super big number\\n # Left turn calibration\\n while abs(current_pos - last_pos) > min_difference:\\n last_pos = current_pos\\n self.brick_pi.set_motor_power(self.motor_steer, calibration_power)\\n time.sleep(0.1)\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n\\n self.brick_pi.set_motor_power(self.motor_steer, 0)\\n time.sleep(0.1)\\n print('Reset motor encoder after left turn: 0')\\n self.brick_pi.reset_motor_encoder(self.motor_steer)\\n\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n last_pos = 99999999 # any super big number\\n # Right turn calibration\\n while abs(current_pos - last_pos) > min_difference:\\n last_pos = current_pos\\n self.brick_pi.set_motor_power(self.motor_steer, -calibration_power)\\n time.sleep(0.1)\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n\\n self.brick_pi.set_motor_power(self.motor_steer, 0)\\n time.sleep(0.1)\\n self.brick_pi.offset_motor_encoder(self.motor_steer, current_pos / 2)\\n self.steering_limit = abs(\\n self.brick_pi.get_motor_encoder(self.motor_steer))\\n print('Offset motor encoder after right turn: ' +\\n str(self.brick_pi.get_motor_encoder(self.motor_steer)))\\n\\n self.brick_pi.set_motor_position(self.motor_steer, 0)\\n print('Calibration of steering axis completed')\",\n \"def solve(self):\\n raise NotImplementedError(\\\"This method needs to be implemented.\\\")\",\n \"def solve(self, solver):\\n solver.solve()\",\n \"def solve(self) -> jnp.ndarray:\\n pass\",\n \"def did_solve(self) -> bool:\\n pass\",\n \"def run(self):\\n cpt = 1\\n while cpt < (self.BOUND):\\n cpt += 1\\n self.incBound()\\n\\n res = self.s.check()\\n if res == sat:\\n m = self.s.model()\\n self.checkModel(m)\\n self.printModel(m)\\n return\\n else:\\n print(\\\"The problem is UNSAT\\\")\",\n \"def __call__(self):\\n self.start()\\n numberOfIterations, stateVectorConv = self.iterations()\\n if numberOfIterations <= 1:\\n self.answer = None\\n raise DidNotConvergeWarning(\\\"Number of iterations <= 1.\\\")\\n result = self.diagnostic(numberOfIterations, stateVectorConv)\\n return result\",\n \"def auto_correction(self):\\n\\n if self.mi_standard_fb is not None:\\n try: \\n is_st_fb_running = self.mi_standard_fb.is_running()\\n except Exception as e:\\n logger.warning(\\\"error during status of st. FB reading: \\\" + str(e))\\n is_st_fb_running = False\\n \\n if self.mi_standard_fb is not None and is_st_fb_running:\\n logger.info(\\\"auto_correction: St.FB is running. Stop Ad. FB\\\")\\n self.stop_feedback()\\n return 0\\n \\n is_nan = self.ref_orbit_calc()\\n if is_nan:\\n logger.warning(\\\"auto_correction: nan in the ref orbit. Pause 1 sec\\\")\\n time.sleep(1)\\n return\\n\\n start = time.time()\\n stop_flag = self.correct()\\n print(\\\"correct: \\\", time.time() - start)\\n time.sleep(0.01)\\n if not stop_flag:\\n start = time.time()\\n self.apply_kicks()\\n print(\\\"apply_kicks: \\\", time.time() - start)\\n self.sase_hist.append(self.target_filtered[-1])\\n self.le_warn.clear()\\n else:\\n logger.warning(\\\"auto_correction: stop_flag = True. Pause 1 sec\\\")\\n self.le_warn.clear()\\n self.le_warn.setText(\\\"Stop flag. Kicks are not applied\\\")\\n self.le_warn.setStyleSheet(\\\"color: red\\\")\\n\\n time.sleep(1)\",\n \"def solve(self):\\n measure = None\\n while not self.step():\\n self._nbSteps += 1\\n measure = self.measure(lastMeasure=measure)\",\n \"def find_reference(self, f, b, x_0, y_0, res=8e-3, calibrate_nr=3, confidence=0.7, plot=False):\\n found = False\\n counter = 0\\n self.PG1['n_pts'] = f + b + 1\\n self.PG2['n_pts'] = f + b + 1\\n\\n self.ref_path_x.append(x_0)\\n self.ref_path_y.append(y_0)\\n\\n while not found:\\n print('\\\\n#####################'\\n '\\\\n Frame nr. {}'.format(counter+1))\\n # update measurement information\\n self.PG1['start'] = self.ref_path_x[-1] + (b + 0.5) * res\\n self.PG1['stop'] = self.ref_path_x[-1] - (f + 0.5) * res\\n self.PG1['mean'] = self.PG1['start'] + (self.PG1['stop'] - self.PG1['start']) / 2.\\n\\n self.PG2['start'] = self.ref_path_y[-1] + (b + 0.5) * res\\n self.PG2['stop'] = self.ref_path_y[-1] - (f + 0.5) * res\\n self.PG2['mean'] = self.PG2['start'] + (self.PG2['stop'] - self.PG2['start']) / 2.\\n\\n # define measurement object\\n output_path = os.path.join(self.path_out, 'reference_' + str(counter))\\n measurement = ScriptTools.MeasurementObject(\\n self.path_in,\\n output_path\\n )\\n\\n # recalibrate QPC every 3 frames\\n if counter % calibrate_nr == 0 or self.sweet_spot is None:\\n calibrate = True\\n gate_config = None\\n\\n else:\\n calibrate = False\\n gate_config = {\\n self.gate_names['QPC_G']: self.sweet_spot\\n }\\n \\n # perform measurement / get data\\n measurement_signal = self.get_data_(measurement, output_path,\\n DQD_log_channel=self.gate_names['I_DQD'],\\n calibrate=calibrate, rescale=False,\\n config=gate_config)\\n self.ref_frames.append(measurement_signal['I_QPC'])\\n I_DQD = measurement_signal['I_DQD']\\n\\n # reshape data in order to make it suitable for classifier\\n reshaped_signal = self.ref_frames[-1].reshape((1, f + b, f + b, 1))\\n\\n # predict occupation state\\n occupation = self.occupation_ref_rec.predict(reshaped_signal)[0]\\n self.ref_classif.append(occupation)\\n print('Classification confidences:\\\\n{}'.format(occupation))\\n print('PG1: {}V\\\\n'\\n 'PG2: {}V'.format(self.ref_path_x[-1], self.ref_path_y[-1]))\\n counter += 1\\n\\n # plot measurement and visualize filters\\n if plot:\\n grid = plt.GridSpec(20, 20)\\n fig = plt.figure()\\n ax = plt.subplot(grid[:20, :20])\\n axins1 = inset_axes(ax,\\n width=\\\"3%\\\",\\n height=\\\"100%\\\",\\n loc='lower left',\\n bbox_to_anchor=(1.01, 0., 1, 1),\\n bbox_transform=ax.transAxes,\\n borderpad=0,\\n )\\n\\n im1 = ax.pcolormesh(self.ref_frames[-1][:, :], linewidth=0, rasterized=True)\\n cbar = fig.colorbar(im1, cax=axins1)\\n ax.axhline(y=16, color='black', linewidth=2)\\n ax.axvline(x=16, color='black', linewidth=2)\\n ax.plot(self.ref_path_x[-1], self.ref_path_y[-1])\\n ax.set_ylim(0, 20)\\n ax.set_xlim(0, 20)\\n plt.title('Reference {}'.format(counter))\\n plt.show()\\n\\n # If confidence that DQD empty is larger than a certain threshold -> terminate\\n # Classification outcome: [1, 0] -> dots occupied, [0, 1] -> dots empty\\n if(occupation[1] > confidence and not self.is_current_(I_DQD, threshold=7e-12)):\\n found = True\\n print(self.ref_path_x[-1])\\n print(self.ref_path_y[-1])\\n self.occupation_1 = 0\\n self.occupation_2 = 0\\n self.trans_path_x.append(self.ref_path_x[-1])\\n self.trans_path_y.append(self.ref_path_y[-1])\\n print('Found a reference point at\\\\n'\\n 'PG1: {}V\\\\n'\\n 'PG2: {}V'.format(self.ref_path_x[-1], self.ref_path_y[-1]))\\n\\n else:\\n self.ref_path_x.append(self.ref_path_x[-1] - f*res/3)\\n self.ref_path_y.append(self.ref_path_y[-1] - f*res/3)\\n\\n return self.ref_path_x[-1], self.ref_path_y[-1]\",\n \"def _RunCalibration(self, graph_key, gdef, input_data, config):\\n return self._RunGraph(graph_key, gdef, input_data, config, 30)\",\n \"def start(self):\\n ### input check ### ? or done automaticly, how optional?\\n self.ctx.last_calc2 = None\\n self.ctx.loop_count2 = 0\\n self.ctx.calcs = []\\n self.ctx.successful2 = False\\n\\n # set values, or defaults, default: always converge charge density, crit < 0.00002, max 4 fleur runs\\n self.ctx.max_number_runs = self.inputs.wf_parameters.get_dict().get('relax_runmax', 4)\\n self.ctx.max_force_cycle = self.inputs.wf_parameters.get_dict().get('max_force_cycle', 4)\\n print 'start'\",\n \"def testoptdone(self):\\r\\n\\r\\n assert self.data.optdone\\r\\n\\r\\n targets = self.data.geotargets\\r\\n values = numpy.abs(self.data.geovalues[-1])\\r\\n\\r\\n target_e = targets[0]\\r\\n target_g = targets[1:3]\\r\\n target_x = targets[3:]\\r\\n value_e = values[0]\\r\\n value_g = values[1:3]\\r\\n value_x = values[3:]\\r\\n\\r\\n conv_all = all(values < targets)\\r\\n conv_e = value_e < 25*target_e and all(value_g < target_g) and all(value_x < target_x)\\r\\n conv_g = value_e < target_e and all(value_g < target_g/3.0) and all(value_x < target_x*3.0)\\r\\n conv_x = value_e < target_e and all(value_g < target_g*3.0) and all(value_x < target_x/3.0)\\r\\n converged = conv_all or conv_e or conv_g or conv_x\\r\\n assert converged\",\n \"def potentialSolver4(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def test_blank(self):\\n self._calibration_test(\\\"blank\\\")\",\n \"def _decisionFunction(self):\\n #THIS IS WHERE THE INTELLIGENT AGENT CODE MAKES DECISION\\n #since this is the hand coded extension, I'm just going to hard code some stuff\\n #q learning and Sarsa should hopefully do better\\n \\n #this is some other hand coded stuff that you read in stone's paper\\n c1 = 64 #c1 = distance in pixels\\n c2 = 2.5#c2 = something to multiply angle by\\n c3 = 77 #c3 is the number of pixels you assume are in 5 meteres\\n #state variable 7 is distance in pixels from K1 to T1\\n if self.stateVariables[7] > c1:\\n self._holdBall()\\n else:\\n passMax = float(\\\"-Inf\\\")\\n passMaxArg = None\\n for i in range(1,3):\\n var = (c2 * arccos(self.stateVariables[10+i])) + (self.stateVariables[8+i] / c3)\\n \\\"\\\"\\\"\\n print(\\\"var = \\\", var)\\n print(\\\"stateVariable[\\\", 10 + i, \\\"]=\\\", self.stateVariables[10+i] )\\n print(\\\"arccos of stateVariable[\\\", 10 + i, \\\"]=\\\", arccos(self.stateVariables[10+i]) )\\n print(\\\"stateVariable[\\\", 8 + i, \\\"]=\\\", self.stateVariables[8+i] )\\n \\\"\\\"\\\"\\n \\n if var > passMax:\\n passMax = var\\n passMaxArg = i\\n self._passBall(passMaxArg)\",\n \"def calibration(self) -> tuple[int, int, int, int, int]:\",\n \"def check_calibrated(self):\\n if not self.is_calibrated():\\n raise NotCalibratedError()\",\n \"def potentialSolver5(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def check_error(self):\\n refine_results = {}\\n for phase_path, phase in self.phases.items():\\n refine_results[phase_path] = {}\\n\\n # Save the original grid to the refine results\\n tx = phase.options['transcription']\\n gd = tx.grid_data\\n num_nodes = gd.subset_num_nodes['all']\\n numseg = gd.num_segments\\n\\n refine_results[phase_path]['num_segments'] = numseg\\n refine_results[phase_path]['order'] = gd.transcription_order\\n refine_results[phase_path]['segment_ends'] = gd.segment_ends\\n refine_results[phase_path]['need_refinement'] = np.zeros(numseg, dtype=bool)\\n refine_results[phase_path]['error'] = np.zeros(numseg, dtype=float)\\n\\n if isinstance(tx, dm.RungeKutta):\\n continue\\n\\n outputs = phase.list_outputs(units=False, out_stream=None)\\n\\n out_values_dict = {k: v['value'] for k, v in outputs}\\n\\n prom_to_abs_map = phase._var_allprocs_prom2abs_list['output']\\n\\n num_scalar_states = 0\\n for state_name, options in phase.state_options.items():\\n shape = options['shape']\\n size = np.prod(shape)\\n num_scalar_states += size\\n\\n x = np.zeros([num_nodes, num_scalar_states])\\n f = np.zeros([num_nodes, num_scalar_states])\\n c = 0\\n\\n # Obtain the solution on the current grid\\n for state_name, options in phase.state_options.items():\\n prom_name = f'timeseries.states:{state_name}'\\n abs_name = prom_to_abs_map[prom_name][0]\\n rate_source_prom_name = f\\\"timeseries.state_rates:{state_name}\\\"\\n rate_abs_name = prom_to_abs_map[rate_source_prom_name][0]\\n x[:, c] = out_values_dict[prom_name].ravel()\\n f[:, c] = out_values_dict[rate_source_prom_name].ravel()\\n c += 1\\n\\n # Obtain the solution on the new grid\\n # interpolate x at t_hat\\n new_order = gd.transcription_order + 1\\n # Gauss-Lobatto does not allow even orders so increase order by 2 instead\\n if gd.transcription == 'gauss-lobatto':\\n new_order += 1\\n new_grid = GridData(numseg, gd.transcription, new_order, gd.segment_ends, gd.compressed)\\n left_end_idxs = new_grid.subset_node_indices['segment_ends'][0::2]\\n left_end_idxs = np.append(left_end_idxs, new_grid.subset_num_nodes['all'] - 1)\\n\\n L = interpolation_lagrange_matrix(gd, new_grid)\\n I = integration_matrix(new_grid)\\n\\n # Call the ODE at all nodes of the new grid\\n x_hat, x_prime = self.eval_ode(phase, new_grid, L, I)\\n E = {}\\n e = {}\\n err_over_states = {}\\n for state_name, options in phase.state_options.items():\\n E[state_name] = np.absolute(x_prime[state_name] - x_hat[state_name])\\n for k in range(0, numseg):\\n e[state_name] = E[state_name]/(1 + np.max(x_hat[state_name][left_end_idxs[k]:left_end_idxs[k + 1]]))\\n err_over_states[state_name] = np.zeros(numseg)\\n\\n for state_name, options in phase.state_options.items():\\n for k in range(0, numseg):\\n err_over_states[state_name][k] = np.max(e[state_name][left_end_idxs[k]:left_end_idxs[k + 1]])\\n\\n self.error[phase_path] = np.zeros(numseg)\\n refine_results[phase_path]['error'] = np.zeros(numseg)\\n refine_results[phase_path]['need_refinement'] = np.zeros(numseg, dtype=bool)\\n\\n # Assess the errors in each state\\n for state_name, options in phase.state_options.items():\\n for k in range(0, numseg):\\n if err_over_states[state_name][k] > self.error[phase_path][k]:\\n self.error[phase_path][k] = err_over_states[state_name][k]\\n refine_results[phase_path]['error'][k] = err_over_states[state_name][k]\\n if self.error[phase_path][k] > phase.refine_options['tolerance']:\\n refine_results[phase_path]['need_refinement'][k] = True\\n\\n return refine_results\",\n \"def solve(self):\\n\\n # Open status display\\n fmtstr, nsep = self.display_start()\\n\\n # Start solve timer\\n self.timer.start(['solve', 'solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n\\n # Main optimisation iterations\\n for self.k in range(self.k, self.k + self.opt['MaxMainIter']):\\n\\n # Update record of X and Y from previous iteration\\n self.on_iteration_start()\\n\\n # Compute backtracking\\n if self.opt['Backtrack'] is not None and self.k >= 0:\\n self.timer.stop('solve_wo_btrack')\\n # Compute backtracking\\n self.backtrack.update(self)\\n self.timer.start('solve_wo_btrack')\\n else:\\n # Compute just proximal step\\n self.xstep()\\n # Update by combining previous iterates\\n self.ystep()\\n\\n # Compute residuals and stopping thresholds\\n self.timer.stop(['solve_wo_rsdl', 'solve_wo_btrack'])\\n if not self.opt['FastSolve']:\\n frcxd, adapt_tol = self.compute_residuals()\\n self.timer.start('solve_wo_rsdl')\\n\\n # Compute and record other iteration statistics and\\n # display iteration stats if Verbose option enabled\\n self.timer.stop(['solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n if not self.opt['FastSolve']:\\n itst = self.iteration_stats(self.k, frcxd)\\n self.itstat.append(itst)\\n self.display_status(fmtstr, itst)\\n self.timer.start(['solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n\\n # Call callback function if defined\\n if self.opt['Callback'] is not None:\\n if self.opt['Callback'](self):\\n break\\n\\n # Stop if residual-based stopping tolerances reached\\n if not self.opt['FastSolve']:\\n if frcxd < adapt_tol:\\n break\\n\\n # Increment iteration count\\n self.k += 1\\n\\n # Record solve time\\n self.timer.stop(['solve', 'solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n\\n # Print final separator string if Verbose option enabled\\n self.display_end(nsep)\\n\\n return self.getmin()\",\n \"def test_defect_calculation():\\n slope1, slope2 = 2., 3.\\n step1, step2 = Fraction(5), Fraction(7)\\n cosim = ramp_cosimulation(slope1, slope2, step1, step2)\\n t_end = Fraction(20)\\n defect = cs.evaluate(cosim, t_end)\\n\\n alpha = Fraction(int(lcm(step1.numerator, step2.numerator)),\\n int(gcd(step1.denominator, step2.denominator)))\\n num1, num2 = tuple(map(int, [alpha / step for step in (step1, step2)]))\\n big = max(num1, num2) + 1\\n small = min(num1, num2) - 1\\n assert defect.connection['Ramp1', 'u'] > small * slope2 * step2\\n assert defect.connection['Ramp1', 'u'] < big * slope2 * step2\\n assert defect.connection['Ramp2', 'u'] > small * slope1 * step1\\n assert defect.connection['Ramp2', 'u'] < big * slope1 * step1\\n\\n assert defect.output['Ramp1', 'y'] == pytest.approx(slope1 * step1)\\n assert defect.output['Ramp2', 'y'] == pytest.approx(slope2 * step2)\",\n \"def did_solve(self):\\n return self._solution.success\",\n \"def calibrate(msname, parset, skymodel, logname_root, use_timecorr=False,\\n time_block=None, ionfactor=0.5, outdir='.', instrument='instrument',\\n solint=None, flag_filler=False, ncores=1):\\n log = logging.getLogger(\\\"Calib\\\")\\n\\n if not use_timecorr:\\n subprocess.call(\\\"calibrate-stand-alone -f {0} {1} {2} > {3}/logs/\\\"\\n \\\"{4}_peeling_calibrate.log 2>&1\\\".format(msname, parset, skymodel,\\n outdir, logname_root), shell=True)\\n subprocess.call(\\\"cp -r {0}/instrument {0}/instrument_out\\\".format(msname),\\n shell=True)\\n else:\\n # Perform a time-correlated solve\\n dataset = msname\\n blockl = time_block\\n anttab = pt.table(dataset + '/ANTENNA', ack=False)\\n antlist = anttab.getcol('NAME')\\n instrument_orig = msname+'/instrument'\\n instrument_out = msname+'/instrument_out'\\n if solint < 1:\\n solint = 1\\n\\n\\n # Get time per sample and number of times\\n t = pt.table(dataset, readonly=True, ack=False)\\n for t2 in t.iter([\\\"ANTENNA1\\\",\\\"ANTENNA2\\\"]):\\n if (t2.getcell('ANTENNA1',0)) < (t2.getcell('ANTENNA2',0)):\\n timepersample = t2[1]['TIME']-t2[0]['TIME'] # sec\\n trows = t2.nrows()\\n t.close()\\n\\n # Calculate various intervals\\n fwhm_min, fwhm_max = modify_weights(msname, ionfactor, dryrun=True) # s\\n if time_block is None:\\n # Set blockl to enclose the max FWHM and be divisible by 2 and by solint\\n blockl = int(np.ceil(fwhm_max / timepersample / 2.0 / solint) * 2 * solint)\\n tdiff = solint * timepersample / 3600. # difference between solutions in hours\\n tlen = timepersample * np.float(blockl) / 3600. # length of block in hours\\n nsols = int(np.ceil(trows / solint)) # number of solutions\\n\\n log.info('Performing time-correlated peeling for {0}...\\\\n'\\n ' Time per sample: {1} (s)\\\\n'\\n ' Samples in total: {2}\\\\n'\\n ' Block size: {3} (samples)\\\\n'\\n ' {4} (s)\\\\n'\\n ' Number of solutions: {5}\\\\n'\\n ' Ionfactor: {6}\\\\n'\\n ' FWHM range: {7} - {8} (s)'.format(msname, timepersample,\\n trows, blockl, tlen*3600.0, nsols, ionfactor, fwhm_min, fwhm_max))\\n\\n # Make a copy of the master parmdb to store time-correlated solutions\\n # in, resetting and flagging as needed\\n os.system('rm -rf ' +instrument_out)\\n clean_and_copy_parmdb(instrument_orig, instrument_out, blockl,\\n flag_filler=flag_filler, msname=msname, timepersample=timepersample)\\n\\n # Calibrate the chunks\\n chunk_list = []\\n tlen_mod = tlen / 2.0 # hours\\n chunk_mid_start = blockl / 2 / solint\\n chunk_mid_end = nsols - blockl / 2 / solint\\n for c in range(nsols):\\n chunk_obj = Chunk(dataset)\\n chunk_obj.chunk = c\\n chunk_obj.outdir = outdir\\n if c < chunk_mid_start:\\n chunk_obj.trim_start = True\\n chunk_obj.t0 = 0.0 # hours\\n chunk_obj.t1 = np.float(chunk_obj.t0) + tlen_mod # hours\\n tlen_mod += tdiff # add one solution interval (in hours)\\n elif c > chunk_mid_end:\\n tlen_mod -= tdiff # subtract one solution interval (in hours)\\n chunk_obj.trim_start = False\\n chunk_obj.t0 = tdiff*float(chunk_obj.chunk - chunk_mid_start) # hours\\n chunk_obj.t1 = np.float(chunk_obj.t0) + tlen_mod # hours\\n else:\\n chunk_obj.trim_start = False\\n chunk_obj.t0 = tdiff*float(chunk_obj.chunk - chunk_mid_start) # hours\\n chunk_obj.t1 = np.float(chunk_obj.t0) + tlen # hours\\n chunk_obj.ionfactor = ionfactor\\n chunk_obj.parset = parset\\n chunk_obj.skymodel = skymodel\\n chunk_obj.logname_root = logname_root + '_part' + str(c)\\n chunk_obj.solnum = chunk_obj.chunk\\n chunk_obj.output = chunk_obj.outdir + '/part' + str(chunk_obj.chunk) + os.path.basename(chunk_obj.dataset)\\n chunk_obj.ntot = nsols\\n chunk_list.append(chunk_obj)\\n\\n # Split the dataset into parts\\n for chunk_obj in chunk_list:\\n split_ms(chunk_obj.dataset, chunk_obj.output, chunk_obj.t0, chunk_obj.t1)\\n\\n # Calibrate in parallel\\n pool = multiprocessing.Pool(ncores)\\n pool.map(calibrate_chunk, chunk_list)\\n pool.close()\\n pool.join()\\n\\n # Copy over the solutions to the final parmdb\\n pdb = lofar.parmdb.parmdb(instrument_out)\\n parms = pdb.getValuesGrid(\\\"*\\\")\\n for chunk_obj in chunk_list:\\n instrument_input = chunk_obj.output + '/instrument'\\n pdb_part = lofar.parmdb.parmdb(instrument_input)\\n parms_part = pdb_part.getValuesGrid(\\\"*\\\")\\n keynames = parms_part.keys()\\n for key in keynames:\\n if 'Phase' in key:\\n tmp1=np.copy(parms[key]['values'][:,0])\\n tmp1[chunk_obj.solnum] = np.copy(parms_part[key]['values'][0,0])\\n parms[key]['values'][:,0] = tmp1\\n os.system('rm -rf ' + instrument_out)\\n lofar.expion.parmdbmain.store_parms(instrument_out, parms, create_new=True)\\n\\n # Clean up\\n for chunk_obj in chunk_list:\\n os.system('rm -rf {0}*'.format(chunk_obj.output))\\n os.system('rm calibrate-stand-alone*.log')\\n\\n # Move the solutions to original parmdb\\n subprocess.call('cp -r {0} {1}'.format(instrument_out, instrument_orig),\\n shell=True)\",\n \"def main_function(self):\\n self.ana_cont_probl = cont.AnalyticContinuationProblem(im_axis=self.input_data.mats,\\n im_data=self.input_data.value.real,\\n re_axis=self.realgrid.grid,\\n kernel_mode='freq_bosonic')\\n model = np.ones_like(self.realgrid.grid)\\n model /= np.trapz(model, self.realgrid.grid)\\n\\n preblur, bw = self.get_preblur()\\n\\n sol = self.ana_cont_probl.solve(method='maxent_svd',\\n optimizer='newton',\\n alpha_determination='chi2kink',\\n model=model,\\n stdev=self.input_data.error,\\n interactive=False, alpha_start=1e10, alpha_end=1e-3,\\n preblur=preblur, blur_width=bw)\\n\\n inp_str = 'atom {}, orb {}, spin {}, blur {}: '.format(self.input_data.atom,\\n self.input_data.orbital,\\n self.input_data.spin,\\n bw)\\n all_chis = np.isfinite(np.array([s.chi2 for s in sol[1]]))\\n res_str = 'alpha_opt={:3.2f}, chi2(alpha_opt)={:3.2f}, min(chi2)={:3.2f}'.format(\\n sol[0].alpha, sol[0].chi2, np.amin(all_chis)\\n )\\n self.text_output.append(inp_str + res_str)\\n alphas = [s.alpha for s in sol[1]]\\n chis = [s.chi2 for s in sol[1]]\\n\\n self.output_data.update(self.realgrid.grid, sol[0].A_opt, self.input_data)\\n\\n fig, ax = plt.subplots(ncols=2, nrows=2, figsize=(11.75, 8.25)) # A4 paper size\\n ax[0, 0].loglog(alphas, chis, marker='s', color='black')\\n ax[0, 0].loglog(sol[0].alpha, sol[0].chi2, marker='*', color='red', markersize=15)\\n ax[0, 0].set_xlabel(r'$\\\\alpha$')\\n ax[0, 0].set_ylabel(r'$\\\\chi^2(\\\\alpha)$')\\n\\n ax[1, 0].plot(self.realgrid.grid, sol[0].A_opt)\\n ax[1, 0].set_xlabel(r'$\\\\omega$')\\n ax[1, 0].set_ylabel('spectrum')\\n\\n ax[0, 1].plot(self.input_data.mats, self.input_data.value.real,\\n color='blue', ls=':', marker='x', markersize=5,\\n label='Re[data]')\\n ax[0, 1].plot(self.input_data.mats, self.input_data.value.imag,\\n color='green', ls=':', marker='+', markersize=5,\\n label='Im[data]')\\n ax[0, 1].plot(self.input_data.mats, sol[0].backtransform.real,\\n ls='--', color='gray', label='Re[fit]')\\n ax[0, 1].plot(self.input_data.mats, sol[0].backtransform.imag,\\n color='gray', label='Im[fit]')\\n ax[0, 1].set_xlabel(r'$\\\\nu_n$')\\n ax[0, 1].set_ylabel(self.input_data.data_type)\\n ax[0, 1].legend()\\n\\n ax[1, 1].plot(self.input_data.mats, (self.input_data.value - sol[0].backtransform).real,\\n ls='--', label='real part')\\n ax[1, 1].plot(self.input_data.mats, (self.input_data.value - sol[0].backtransform).imag,\\n label='imaginary part')\\n ax[1, 1].set_xlabel(r'$\\\\nu_n$')\\n ax[1, 1].set_ylabel('data $-$ fit')\\n ax[1, 1].legend()\\n plt.tight_layout()\\n plt.show()\",\n \"def ekf_algorithm(self, u, y):\\n x_est_before = self.x_estimated_state\\n cov_matrix_before = self.cov_matrix\\n # 1. Prediction\\n # predict the state by integrate the time continuous system numerically\\n sim_state_predict = self.heliSim.calc_step(u[0][0], u[1][0], self.no_disturbance_eval)\\n x_est_predict = np.resize(sim_state_predict, (8, 1))\\n # predict the new covariance by linearizing and discretizing the model\\n Ak, Bk, Ck, Dk = self.get_linear_discrete_matrices(x_est_before, u[0][0], u[1][0])\\n cov_matrix_predict = Ak @ cov_matrix_before @ np.transpose(Ak) + Bk @ self.N @ np.transpose(Bk)\\n # 2. Update\\n # compute kalman gain\\n Kl = cov_matrix_predict @ np.transpose(Ck) @ np.linalg.inv(Ck @ cov_matrix_predict @ np.transpose(Ck) + self.W)\\n # update state\\n y_est = x_est_predict[0:3]\\n x_est_update = x_est_predict + Kl @ (y - y_est)\\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ Ck) @ cov_matrix_predict\\n\\n # check if the update step state needs to be changed because of limit crossing\\n # if that is the case, correct the state and set the state of the simulation accordingly\\n corrected_state = self.heliSim.get_limited_state_and_change_state(x_est_update.reshape((1, 8))[0],\\n ModelType.GYROMOMENT)\\n x_est_update = np.resize(corrected_state, (8, 1))\\n\\n self.x_estimated_state = x_est_update\\n self.cov_matrix = cov_matrix_update\\n # print(\\\"------\\\")\\n # print(cov_matrix_predict)\\n return x_est_update\",\n \"def determine_analytic_solution(self):\\n\\n self._Janalytic = np.where(self.xr <= self.xint, self.S, 0.5 * self.S)\\n self._Hanalytic = np.where(self.xr <= self.xint, 0, 0.25 * self.S)\\n self._Kanalytic = np.where(self.xr <= self.xint, 1./3. * self.S,\\n 1./6. * self.S)\",\n \"def calibrate(self):\\n import time\\n\\n CALIBRATE_SLEEP = 0.75\\n\\n self.change_power(-self._calpow)\\n encprev, encnow = 0, None\\n while encprev != encnow:\\n encprev = encnow\\n time.sleep(CALIBRATE_SLEEP)\\n encnow = self._bp.get_motor_encoder(self._port)\\n self._pmin = encnow\\n self.change_power(0)\\n\\n self.change_power(self._calpow)\\n encprev, encnow = 0, None\\n while encprev != encnow:\\n encprev = encnow\\n time.sleep(CALIBRATE_SLEEP)\\n encnow = self._bp.get_motor_encoder(self._port)\\n self._pmax = encnow\\n self.change_power(0)\\n\\n if self._pmax == self._pmin:\\n raise Exception('motor {} does not move'.format(self._port))\\n\\n self._pinit = (self._pmax + self._pmin) * 0.5\\n time.sleep(0.5)\\n self.to_init_position()\",\n \"def _calibrate_measurement(self):\\n\\n cold_blackbody = bb_radiance(self.cbb.header.cbb_temperature + 273.15,\\n self.cbb.data.wavelength)\\n warm_blackbody = bb_radiance(self.wbb.header.wbb_temperature + 273.15,\\n self.wbb.data.wavelength)\\n\\n self.wbb.data.average_spectrum[0] = 1\\n self.wbb.data.average_spectrum[2047] = 1\\n\\n calibration_slope = ((warm_blackbody - cold_blackbody) /\\n (self.wbb.data.average_spectrum - self.cbb.data.average_spectrum))\\n calibration_offset = warm_blackbody - (self.wbb.data.average_spectrum * \\n calibration_slope)\\n\\n self.wbb.calibrate_file(calibration_slope, calibration_offset)\\n self.cbb.calibrate_file(calibration_slope, calibration_offset)\\n self.sam.calibrate_file(calibration_slope, calibration_offset)\\n\\n if not self.dwr is None:\\n self.dwr.calibrate_file(calibration_slope, calibration_offset)\\n\\n plate_temperature = self.dwr.header.spare_f[0]\\n if (self.plate == -1) :\\n plate_emissivity = self.dwr.header.spare_f[1]\\n\\n plate_blackbody = bb_radiance(plate_temperature + 273.15,\\n self.dwr.data.wavelength)\\n plate_emission = plate_emissivity * plate_blackbody\\n\\n self.dwr.data.average_spectrum = ((self.dwr.data.average_spectrum - \\n plate_emission) / (1 - plate_emissivity))\",\n \"def checkselfdual(self):\\n\\n self.selfdual = True\\n for n in range(1,min(8,len(self.dirichlet_coefficients))):\\n if abs(imag_part(self.dirichlet_coefficients[n]/self.dirichlet_coefficients[0])) > 0.00001:\\n self.selfdual = False\",\n \"def testset_calibration(self, system_name):\\n wdesc = \\\"Check if Lab Test set calibration is current.\\\"\\n #Resolve system_name and subsystem_list\\n system_name, subsystem_list = Utils.data_Utils.resolve_system_subsystem_list(self.datafile, system_name)\\n output_dict = {}\\n status = True\\n attempt = 1 if subsystem_list == None else len(subsystem_list)\\n for i in range(attempt):\\n Utils.testcase_Utils.pSubStep(wdesc)\\n #Get name from the list when it's not 'None', otherwise, set it to 'None'\\n subsystem_name = subsystem_list[i] if subsystem_list != None else None\\n call_system_name = system_name if subsystem_name is None \\\\\\n else \\\"{0}[{1}]\\\".format(system_name, subsystem_name)\\n credentials = get_credentials(self.datafile, call_system_name, \\\\\\n ['calibration', 'user', 'location', 'testdata'])\\n pNote(\\\"system={0}\\\".format(call_system_name))\\n #Demo Framework testdata capability\\n testdatafile = file_Utils.getAbsPath(credentials[\\\"testdata\\\"], os.path.dirname(self.datafile))\\n add_info = Utils.xml_Utils.getElementWithTagAttribValueMatch(testdatafile, \\\\\\n 'add_info', 'name', 'testdata')\\n if add_info is not None:\\n info_text = Utils.xml_Utils.get_text_from_direct_child(add_info, 'info')\\n pNote(info_text)\\n pNote(testdatafile)\\n\\n if credentials is not None and credentials is not False:\\n calibrated_date = credentials[\\\"calibration\\\"]\\n num_of_year = 1\\n pass_msg = \\\"Lab Test set {0} calibration is current, \\\"\\\\\\n \\\"re-calibration is NOT required.\\\"\\\\\\n .format(call_system_name)\\n fail_msg = \\\"Lab Test set {0} calibration is NOT current, it's \\\"\\\\\\n \\\"more than than 1 year old. Re-calibration is \\\"\\\\\\n \\\"required\\\".format(call_system_name)\\n result = Utils.demo_utils.lab_eqpt_status(calibrated_date, num_of_year, pass_msg, fail_msg)\\n\\n Utils.data_Utils.update_datarepository(output_dict)\\n Utils.testcase_Utils.report_substep_status(result)\\n status = status and result\\n\\n return status, output_dict\",\n \"def arm_calibration(self):\\n self.arm_motor.run_forever(speed_sp=self.MAX_SPEED)\\n while not self.touch_sensor.is_pressed:\\n time.sleep(0.01)\\n self.arm_motor.stop()\\n ev3.Sound.beep().wait()\\n arm_revolutions_for_full_range = 14.2 * 360\\n self.arm_motor.run_to_rel_pos(\\n position_sp=-arm_revolutions_for_full_range,\\n speed_sp=self.MAX_SPEED,\\n stop_action=ev3.Motor.STOP_ACTION_BRAKE)\\n self.arm_motor.wait_while(ev3.Motor.STATE_RUNNING)\\n\\n self.arm_motor.position = 0 # Calibrate the down position as 0 (this\\n # line is correct as is).\",\n \"def doRun(run=77):\\n r = xanes_analyzeRun.AnalyzeRun(run)\\n r.load()\\n calibs = list(r.results.keys())\\n calibs.sort()\\n p2 = [np.nanmedian(r.results[c].p1, axis=0) for c in calibs]\\n p2 = np.asarray(p2)\\n ref = np.nanmedian(p2, axis=0)\\n # normalize p2\\n p2 = p2 / ref\\n # remove non-flat part\\n _x = np.arange(p2.shape[1], dtype=float)\\n p2 = [s - mc.poly_approximant(_x, s, order=20)(_x) for s in p2]\\n p2 = np.asarray(p2)\\n x = np.asarray([_x for _ in p2])\\n x[p2 > -0.15] = np.nan\\n x[x < 100] = np.nan\\n # below pixel 200 is noise\\n pos = np.nanmean(x, axis=1)\\n fig, ax = plt.subplots(1, 2, sharey=True)\\n xshift = 0.2\\n pcalib = []\\n for icalib, (xi, p2i) in enumerate(zip(x, p2)):\\n ppar = dict(color=myc(icalib))\\n ax[0].plot(p2i + icalib * xshift, _x, \\\"--\\\", lw=1, alpha=0.5, **ppar)\\n ax[0].plot(p2i + icalib * xshift, xi, lw=2, **ppar)\\n pcalib.append(np.nanmedian(xi))\\n ax[1].plot(r.scanpos[icalib], pcalib[icalib], \\\"o\\\", **ppar)\\n polycal = np.polyfit(pcalib, r.scanpos, 1)\\n ax[1].plot(np.polyval(polycal, _x), _x)\\n print(\\\"polynomial calibration\\\", polycal)\",\n \"def did_solve(self):\\n return self._solution[\\\"status\\\"] == \\\"optimal\\\"\",\n \"def objective(trial):\\n # The parameters that we will calibrate the model for are shown here.\\n # Optuna trial i\\n BOD = trial.suggest_uniform(\\\"BOD\\\", 0, 1) #Review ranges here\\n k_r = trial.suggest_uniform(\\\"k_r\\\", 0, 1) #Review Ranges here \\n \\n def ChLa(t):\\n return 1 # Need to link to data\\n\\n def I(x):\\n return 1 # Need to link to data\\n\\n K_z = 2 * 10**(-5) # p.51\\n a = K_z\\n k_b = 0.1 # Table 5\\n th_b = 1.047 # Table 5\\n k_r = 0.1 # Table 5\\n YCHO2 = 0.0083 # Table 5\\n th_p = 1.036 # Table 5\\n th_s = 1.065 # Table 5\\n th_r = 1.047 # Table 5\\n\\n def Temp(t):\\n \\\"\\\"\\\"\\n Function that maps time to temperature\\n \\\"\\\"\\\"\\n return 20 # Need to link to data\\n\\n def P_max(t):\\n return 9.6 * 1.036 **(Temp(t) - 20) # Eq. 4\\n\\n def L_min(t):\\n I = 1 # Need to link to PAR data\\n K_1 = 0.687 * 1.086**(Temp(t) - 20)\\n K_2 = 15\\n return I * (1 + 2 * np.sqrt(K_1 / K_2)) / (I + K_1 + I**2 / K_2) # Eq. 5\\n \\n # f deals with sink and source terms \\n def f(x, t):\\n return -1 / YCHO2 * k_r * th_r**(Temp(t) - 20) * ChLa(t) + P_max(t) * L_min(t) * ChLa(t) - k_b * th_b**(Temp(t)-20) * BOD \\n\\n L = 200 # Length of domain\\n dt = 1 / 48 # Mesh spacing in t\\n F = a * dt # a * dt / dx**2\\n T = 100 # Simulation time stop\\n\\n # Solving the PDE\\n DO, x, t, _ = solver_FE_simple(I, a, f, L, dt, F, T)\\n \\n # Creating some bogus targets while database errors are happening\\n DO_data = DO + np.random.random(len(DO))\\n\\n # Using mean squared error as the measure of fit, where we want\\n # to minimize this number\\n return ((DO - DO_data)**2).mean()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7105522","0.6993151","0.66071844","0.6589474","0.6569091","0.652657","0.64698505","0.6425824","0.64135945","0.63717103","0.63714695","0.6335183","0.6329859","0.62983537","0.62881285","0.62694263","0.62132275","0.6187541","0.6185712","0.6161007","0.6161007","0.6152027","0.61444217","0.6137007","0.6074687","0.6070307","0.6070307","0.6070307","0.60613656","0.60034716","0.59606135","0.59545195","0.59540755","0.59439015","0.5932949","0.5916544","0.5913441","0.5903105","0.5888419","0.5887076","0.5876408","0.5868455","0.5865001","0.58626467","0.58578116","0.58563775","0.58559346","0.58460134","0.58201057","0.5791803","0.5791271","0.5787797","0.5780924","0.57788485","0.57731575","0.5771175","0.57613987","0.57550764","0.5754298","0.57473457","0.5743888","0.57429105","0.57410616","0.5738082","0.5736671","0.5729481","0.5726345","0.5721461","0.571982","0.57168007","0.57110834","0.5708206","0.5703174","0.570003","0.56997","0.56955737","0.56934446","0.5690182","0.5685176","0.5683358","0.56805617","0.5679379","0.5675977","0.56477475","0.56410664","0.56374687","0.562425","0.5620856","0.56159747","0.56147873","0.5614765","0.5614513","0.56145096","0.56101483","0.5606048","0.56044936","0.56044114","0.56029505","0.5594156","0.5591085","0.55852616"],"string":"[\n \"0.7105522\",\n \"0.6993151\",\n \"0.66071844\",\n \"0.6589474\",\n \"0.6569091\",\n \"0.652657\",\n \"0.64698505\",\n \"0.6425824\",\n \"0.64135945\",\n \"0.63717103\",\n \"0.63714695\",\n \"0.6335183\",\n \"0.6329859\",\n \"0.62983537\",\n \"0.62881285\",\n \"0.62694263\",\n \"0.62132275\",\n \"0.6187541\",\n \"0.6185712\",\n \"0.6161007\",\n \"0.6161007\",\n \"0.6152027\",\n \"0.61444217\",\n \"0.6137007\",\n \"0.6074687\",\n \"0.6070307\",\n \"0.6070307\",\n \"0.6070307\",\n \"0.60613656\",\n \"0.60034716\",\n \"0.59606135\",\n \"0.59545195\",\n \"0.59540755\",\n \"0.59439015\",\n \"0.5932949\",\n \"0.5916544\",\n \"0.5913441\",\n \"0.5903105\",\n \"0.5888419\",\n \"0.5887076\",\n \"0.5876408\",\n \"0.5868455\",\n \"0.5865001\",\n \"0.58626467\",\n \"0.58578116\",\n \"0.58563775\",\n \"0.58559346\",\n \"0.58460134\",\n \"0.58201057\",\n \"0.5791803\",\n \"0.5791271\",\n \"0.5787797\",\n \"0.5780924\",\n \"0.57788485\",\n \"0.57731575\",\n \"0.5771175\",\n \"0.57613987\",\n \"0.57550764\",\n \"0.5754298\",\n \"0.57473457\",\n \"0.5743888\",\n \"0.57429105\",\n \"0.57410616\",\n \"0.5738082\",\n \"0.5736671\",\n \"0.5729481\",\n \"0.5726345\",\n \"0.5721461\",\n \"0.571982\",\n \"0.57168007\",\n \"0.57110834\",\n \"0.5708206\",\n \"0.5703174\",\n \"0.570003\",\n \"0.56997\",\n \"0.56955737\",\n \"0.56934446\",\n \"0.5690182\",\n \"0.5685176\",\n \"0.5683358\",\n \"0.56805617\",\n \"0.5679379\",\n \"0.5675977\",\n \"0.56477475\",\n \"0.56410664\",\n \"0.56374687\",\n \"0.562425\",\n \"0.5620856\",\n \"0.56159747\",\n \"0.56147873\",\n \"0.5614765\",\n \"0.5614513\",\n \"0.56145096\",\n \"0.56101483\",\n \"0.5606048\",\n \"0.56044936\",\n \"0.56044114\",\n \"0.56029505\",\n \"0.5594156\",\n \"0.5591085\",\n \"0.55852616\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93181,"cells":{"query":{"kind":"string","value":"Self Calibration. Apply the calibration from the phase only solution"},"document":{"kind":"string","value":"def selfcal_apcal(imc, trial='1'):\n flagmanager(imc.vislf, mode='restore', versionname='startup')\n applycal(vis=imc.vislf,\n spwmap=np.zeros(54),\n interp='linearPDperobs',\n gaintable=[imc.path_base+'.pcal'+trial],\n calwt=False,\n flagbackup=False)"},"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 _doCalibration(self):\n self._cmdCalibration(2)","def photometric_calibration():\n pass","def calibration(self) -> int:","def calibration_wheel(self):\n self.spectrum = self.spectrum","def calibration(self, cal: int, /) -> None:","def calibrate(self, master):\n if master.polyorder == 'linear':\n self.fitfunction = \"A0 + A1 * D\"\n self.fit_fkt = self.calc_lin\n elif master.polyorder == 'quadratic':\n self.fit_fkt = self.calc_quad\n self.fitfunction = \"A0 + A1 * D + A2 * D**2\"\n elif master.polyorder == \"cubic\":\n self.fitfunction = \"A0 + A1 * D + A2 * D**2 + A3 * D**3\"\n self.fit_fkt = self.calc_cubic\n else:\n print(\"Polynomgrad nicht definiert\")\n \n self.mw = np.asarray(self.mw)\n if master.sensortype == \"Druck\":\n self.best, self.covar = curve_fit(self.fit_fkt, self.mw, master.Referencedata.caldat)\n else:\n print(\"Sensortyp noch nicht Hinterlegt\")","def calibrate(self):\n with completion_context(\"Estimating sensor offset\", color=\"c\", bright=True):\n # Reset calibration\n self._sens_offset = np.zeros(4) # last two entries are never calibrated but useful for broadcasting\n self._wait_for_pole_at_rest()\n\n # Create parts of the calibration controller\n go_right = QQubeGoToLimCtrl(positive=True, cnt_done=int(1.5 / self._dt))\n go_left = QQubeGoToLimCtrl(positive=False, cnt_done=int(1.5 / self._dt))\n go_center = QQubePDCtrl(self.spec)\n\n # Estimate alpha offset. Go to both limits for theta calibration.\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\n while not go_right.done:\n meas = self._qsoc.snd_rcv(go_right(to.from_numpy(meas)))\n while not go_left.done:\n meas = self._qsoc.snd_rcv(go_left(to.from_numpy(meas)))\n self._sens_offset[0] = (go_right.th_lim + go_left.th_lim) / 2\n\n # Estimate alpha offset\n self._wait_for_pole_at_rest()\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\n self._sens_offset[1] = meas[1]\n\n print_cbt(\n f\"Sensor offset: \"\n f\"theta = {self._sens_offset[0]*180/np.pi:.3f} deg, \"\n f\"alpha = {self._sens_offset[1]*180/np.pi:.3f} deg\",\n \"g\",\n )\n\n with completion_context(\"Centering cube\", color=\"c\", bright=True):\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\n while not go_center.done:\n meas = self._qsoc.snd_rcv(go_center(to.from_numpy(meas - self._sens_offset)))","def _calibrate(self, Otrain, Ftrain, Feval):\n raise NotImplementedError()","def arm_calibration(self):\n self.arm_motor.run_forever(speed_sp=self.MAX_SPEED)\n while not self.touch_sensor.is_pressed:\n time.sleep(0.01)\n self.arm_motor.stop()\n ev3.Sound.beep().wait()\n arm_revolutions_for_full_range = 14.2 * 360\n self.arm_motor.run_to_rel_pos(\n position_sp=-arm_revolutions_for_full_range,\n speed_sp=self.MAX_SPEED,\n stop_action=ev3.Motor.STOP_ACTION_BRAKE)\n self.arm_motor.wait_while(ev3.Motor.STATE_RUNNING)\n\n self.arm_motor.position = 0 # Calibrate the down position as 0 (this\n # line is correct as is).","def calibrate(self):\n\t\tLTOGRIGHT = []\n\t\tLTOGUP = []\n\t\tRTOGRIGHT = []\n\t\tRTOGUP = []\n\t\tstart = time.time()\n\t\tcalibration_time = 5.0\n\t\twhile time.time() - start < calibration_time:\n\t\t\tevents = pygame.event.get()\n\t\t\tfor event in events:\n\t\t\t\tif event.type == pygame.JOYAXISMOTION:\n\t\t\t\t\tLTOGRIGHT.append(self.joystick.get_axis(self.LTOGRIGHT))\n\t\t\t\t\tLTOGUP.append(-self.joystick.get_axis(self.LTOGUP))\n\t\t\t\t\tRTOGRIGHT.append(self.joystick.get_axis(self.RTOGRIGHT))\n\t\t\t\t\tRTOGUP.append(-self.joystick.get_axis(self.RTOGUP))\n\n\t\t# calibration sets highest value equal to 1.0\n\t\tself.calibration[0] = 1.0/max(LTOGRIGHT)\n\t\tself.calibration[1] = -1.0/min(LTOGRIGHT)\n\t\tself.calibration[2] = -1.0/min(LTOGUP)\n\t\tself.calibration[3] = 1.0/max(LTOGUP)\n\t\tself.calibration[4] = 1.0/max(RTOGRIGHT)\n\t\tself.calibration[5] = -1.0/min(RTOGRIGHT)\n\t\tself.calibration[6] = -1.0/min(RTOGUP)\n\t\tself.calibration[7] = 1.0/max(RTOGUP)","def do_calibration(self):\n goal = CalculateParametersGoal()\n self.calibrate_client.send_goal(goal)\n self.calibrate_client.wait_for_result()\n result = self.calibrate_client.get_result()\n rospy.loginfo('Received the calibration results')\n if result.number_of_images is 0:\n rospy.logerr('Failed to calibrate the camera.')\n else:\n rospy.loginfo('Number of pictures: {}, error: {}'.format(result.number_of_images, result.error))\n self.save_calibration_parameters(result.intrinsics, result.error, result.number_of_images)","def calibration(self, pulse_min: int, pulse_max: int, pulse_centre: int, /) -> None:","def run_calib(projector=OPTOMA_HD33()):\n w, h = (0.2160, 0.2794)\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\n [-w/2, 0, 0], [w/2, 0, 0],\n [-w/2, 0, h/2], [w/2, 0, h/2]])\n\n global img_points, going\n img_points = []\n\n try:\n window = Window()\n window.MoveXY(1600,0)\n window.ShowFullScreen(True)\n going = True\n\n @window.eventx\n def EVT_MOUSE_EVENTS(evt):\n global going, img_points\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\n img_points.append(evt.Position)\n print('Picked point %d of 6' % (len(img_points)))\n if len(img_points) == len(obj_points):\n print \"Done\"\n going = False\n\n print(\"\"\"[Extrinsic Calibration] \n\nThere should be 6 points marked on the table and backdrop. \nMoving the mouse over the projected display, click each of the points\nin order:\n (left top, on the backdrop),\n (right top, on the backdrop),\n (left center, on the crease),\n (right center, on the crease),\n (left bottom, on the table),\n (right bottom, on the table)\n\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\n\nClick the six points:\n\"\"\")\n\n while going: cv.WaitKey(10)\n\n finally:\n window.Close()\n\n img_points = np.array(img_points, 'f')\n projector.calibrate_extrinsic(img_points, obj_points)\n\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\n print('OK')","def calibrate(): \n \n # Calibrate of the run using beam data. Creates a folder cal-files/caltag \n # containing all calibration data. \n CalObj = Calibration(steerfiles=steerfiles, name=localcaltag + '-cal') \n\n # Set Beam energy\n CalObj.set_beam_momentum(beamenergy)\n\n # Get gearfile and set air as DUT material\n localgearfile = CalObj.get_filename('gear.xml')\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='thickness', value=0.0001)\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='radLength', value=304000.0)\n \n # Create list of calibration steps \n calpath = create_calibration_path(CalObj)\n \n # Run the calibration steps \n CalObj.calibrate(path=calpath,ifile=rawfile_air,caltag=localcaltag)","def steering_calibration(self):\n\n # Minimum change of rotary encoder per 100 ms to detect stall\n min_difference = 5\n # Calibration motor power in percentage (absolute)\n calibration_power = 30\n\n print('Calibration of steering axis started')\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n last_pos = 99999999 # any super big number\n # Left turn calibration\n while abs(current_pos - last_pos) > min_difference:\n last_pos = current_pos\n self.brick_pi.set_motor_power(self.motor_steer, calibration_power)\n time.sleep(0.1)\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n\n self.brick_pi.set_motor_power(self.motor_steer, 0)\n time.sleep(0.1)\n print('Reset motor encoder after left turn: 0')\n self.brick_pi.reset_motor_encoder(self.motor_steer)\n\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n last_pos = 99999999 # any super big number\n # Right turn calibration\n while abs(current_pos - last_pos) > min_difference:\n last_pos = current_pos\n self.brick_pi.set_motor_power(self.motor_steer, -calibration_power)\n time.sleep(0.1)\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n\n self.brick_pi.set_motor_power(self.motor_steer, 0)\n time.sleep(0.1)\n self.brick_pi.offset_motor_encoder(self.motor_steer, current_pos / 2)\n self.steering_limit = abs(\n self.brick_pi.get_motor_encoder(self.motor_steer))\n print('Offset motor encoder after right turn: ' +\n str(self.brick_pi.get_motor_encoder(self.motor_steer)))\n\n self.brick_pi.set_motor_position(self.motor_steer, 0)\n print('Calibration of steering axis completed')","def _applyCalibration(self, ws, detPos):\n alg = self.createChildAlgorithm('ApplyCalibration')\n alg.setProperty('Workspace', ws)\n alg.setProperty('PositionTable', detPos)\n alg.execute()","def arm_calibration(self):\n # DONE: 3. Implement the arm calibration movement by fixing the code below (it has many bugs). It should to this:\n # Command the arm_motor to run forever in the positive direction at max speed.\n # Create an infinite while loop that will block code execution until the touch sensor's is_pressed value is True.\n # Within that loop sleep for 0.01 to avoid running code too fast.\n # Once past the loop the touch sensor must be pressed. So stop the arm motor quickly using the brake stop action.\n # Make a beep sound\n # Now move the arm_motor 14.2 revolutions in the negative direction relative to the current location\n # Note the stop action and speed are already set correctly so we don't need to specify them again\n # Block code execution by waiting for the arm to finish running\n # Make a beep sound\n # Set the arm encoder position to 0 (the last line below is correct to do that, it's new so no bug there)\n\n # Code that attempts to do this task but has MANY bugs (nearly 1 on every line). Fix them!\n self.arm_motor.run_forever(speed_sp=900)\n while not self.touch_sensor.is_pressed:\n time.sleep(0.01)\n self.arm_motor.stop(stop_action='brake')\n ev3.Sound.beep().wait()\n # time.sleep(2)\n # arm_motor.stop(stop_action='brake')\n\n arm_revolutions_for_full_range = 14.2 * 360\n self.arm_motor.run_to_rel_pos(position_sp=-arm_revolutions_for_full_range, speed_sp=900)\n self.arm_motor.wait_while(ev3.Motor.STATE_RUNNING)\n ev3.Sound.beep()\n self.arm_motor.position = 0 # Calibrate the down position as 0 (this line is correct as is).","def calibration(\n self,\n pulse_min: int,\n pulse_max: int,\n pulse_centre: int,\n pulse_angle_90: int,\n pulse_speed_100: int,\n /,\n ) -> None:","def solve_prep(self):\n\n par = self.par\n sol = self.sol\n\n # a. retirement\n sol.m_ret = np.zeros((par.T,par.Nm_ret))\n sol.c_ret = np.zeros((par.T,par.Nm_ret))\n sol.a_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_v_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_vm_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_vn_ret = np.zeros((par.T,par.Nm_ret))\n\n # b. working\n if par.solmethod == 'G2EGM':\n\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vn = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.ucon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.ucon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.ucon_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.dcon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.dcon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.dcon_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.acon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.acon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.acon_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.z = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wb = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n \n elif par.solmethod == 'NEGM':\n\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vn = np.zeros((0,0,0))\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wb = np.zeros((0,0,0))\n \n sol.c_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\n sol.inv_v_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))","def __call__(self, data):\n cal = self.calc()\n assert data.shape == cal.shape, \\\n \"data shape does not match calibration ({} != {})\".format(data.shape, cal.shape)\n return data * cal","def recalibrate_start(self):\n self.epoch += 1\n self.initialize()\n self.recalibration_i = 0\n\n if self.vr_from_epoch is not None and self.epoch >= self.vr_from_epoch:\n for group in self.param_groups:\n for p in group['params']:\n param_state = self.state[p]\n param_state['gavg'].zero_()\n param_state['m2'].zero_()\n\n # xk is changed to the running_x\n p.data.zero_().add_(param_state['running_x'])\n param_state['tilde_x'] = p.data.clone()","def calibrate(self, x, y) -> None:\n pass","def calibrer(self):\n self._angle_courant = self._angle_initial\n self.angle(self._angle_initial)","def calibrate(self):\n\n self.update_message('Calibrating platform...')\n\n self.calibrate_platform()\n\n self.update_message('Platform Calibrated.')\n\n # calibrate arm x axis\n self.update_message('Calibrating x axis...')\n calibrated = self.calibrate_arm(0)\n\n if not calibrated:\n self.update_message('ERROR: Could not calibrate x axis.')\n return 0\n else:\n self.update_message('x axis calibrated.')\n\n # calibrate arm y axis\n self.update_message('Calibrating y axis...')\n calibrated = self.calibrate_arm(1)\n\n if not calibrated:\n self.update_message('ERROR: Could not calibrate y axis.')\n return 0\n else:\n self.update_message('y axis calibrated.')\n\n # calibrate arm z axis\n self.update_message('Calibrating z axis...')\n calibrated = self.calibrate_arm(2)\n\n if not calibrated:\n self.update_message('ERROR: Could not calibrate z axis.')\n return 0\n else:\n self.update_message('z axis calibrated.\\n'\n 'Autocalibration done.\\n'\n 'Accuracy: {}'.format(self.matrix_accuracy()))\n\n # Getting the direction to withdraw pipette along x axis\n self.get_withdraw_sign()\n self.inv_mat = np.linalg.inv(self.mat)\n self.calibrated = 1\n self.cam.click_on_window = True\n self.save_calibration()\n return 1","def _RunCalibration(self, graph_key, gdef, input_data, config):\n return self._RunGraph(graph_key, gdef, input_data, config, 30)","def proz(): \r\n print(\"processing: \",CURDATA()[0]) \r\n Check_180turn(left_boundary,right_boundary)\r\n EF() #exponential window multiplication + fourier\r\n APK0() #1. Phase correction 0th Ordnung\r\n APK1() #1. Phase correction 1st Ordnung\r\n ABS() #Baseline correction\r\n APK()\r\n ABS() #Baseline correction\r\n Check_180turn(left_boundary,right_boundary)","def apply_calibration(self, cal):\n\n n_edges = len(self.channels) + 1\n channel_edges = np.linspace(-0.5, self.channels[-1] + 0.5, num=n_edges)\n self.bin_edges_kev = cal.ch2kev(channel_edges)","def calibrate(self):\n if self.iCAL_required:\n logger.info(\"iCAL-sensitive registers were modified, performing calibration...\")\n return self._run_ical()\n else:\n logger.info(\"iCAL-sensitive registers were not modified, skipping calibration...\")\n return 0 # Still success","def full_calibration(\n cal: Calibration,\n ref_pts: np.ndarray,\n img_pts: TargetArray,\n cparam: ControlPar,\n flags: list = [],\n):\n # cdef:\n # vec3d *ref_coord\n # np.ndarray[ndim=2, dtype=pos_t] ret\n # np.ndarray[ndim=1, dtype=np.int_t] used\n # np.ndarray[ndim=1, dtype=pos_t] err_est\n # orient_par *orip\n # double *residuals\n\n ref_pts = np.ascontiguousarray(ref_pts)\n ref_coord = ref_pts.data\n\n # Load up the orientation parameters. Silly, but saves on defining\n # a whole new class for what is no more than a list.\n\n orip = OrientPar()\n orip.useflag = 0\n orip.ccflag = 1 if \"cc\" in flags else 0\n orip.xhflag = 1 if \"xh\" in flags else 0\n orip.yhflag = 1 if \"yh\" in flags else 0\n orip.k1flag = 1 if \"k1\" in flags else 0\n orip.k2flag = 1 if \"k2\" in flags else 0\n orip.k3flag = 1 if \"k3\" in flags else 0\n orip.p1flag = 1 if \"p1\" in flags else 0\n orip.p2flag = 1 if \"p2\" in flags else 0\n orip.scxflag = 1 if \"scale\" in flags else 0\n orip.sheflag = 1 if \"shear\" in flags else 0\n orip.interfflag = 0 # This also solves for the glass, I'm skipping it.\n\n err_est = np.empty((NPAR + 1), dtype=np.float64)\n residuals = orient(\n cal, cparam, len(ref_pts), ref_coord, img_pts, orip, err_est.data\n )\n\n # free(orip)\n\n if residuals is None:\n # free(residuals)\n raise ValueError(\"Orientation iteration failed, need better setup.\")\n\n ret = np.empty((len(img_pts), 2))\n used = np.empty(len(img_pts), dtype=np.int_)\n\n for ix, img_pt in enumerate(img_pts):\n ret[ix] = (residuals[2 * ix], residuals[2 * ix + 1])\n used[ix] = img_pt.pnr\n\n # free(residuals)\n return ret, used, err_est","def solve_and_apply_ensemble(self, save_datapack, ant_idx, time_idx, dir_idx, freq_idx, iterations,\n interval, shift, init_solutions = None, num_threads=1,verbose=False,\n model_kwargs = {}):\n if init_solutions is not None:\n data = np.load(init_solutions)\n\n kern_ls = data['kern_ls']\n kern_var = data['kern_var']\n kern_times = data['time']\n kern_antenna_labels = data['antenna']\n\n \n datapack = self.datapack\n directions, patch_names = datapack.get_directions(dir_idx)\n times,timestamps = datapack.get_times(time_idx)\n antennas,antenna_labels = datapack.get_antennas(ant_idx)\n freqs = datapack.get_freqs(freq_idx)\n\n if ant_idx is -1:\n ant_idx = range(len(antennas))\n if time_idx is -1:\n time_idx = range(len(times))\n if freq_idx is -1:\n freq_idx = range(len(freqs))\n if dir_idx is -1:\n dir_idx = range(len(directions))\n \n\n phase = datapack.get_phase(ant_idx,time_idx,dir_idx,freq_idx)\n Na,Nt,Nd,Nf = phase.shape\n logging.warning(\"Working on shapes {}\".format(phase.shape))\n \n if interval is None:\n interval = Nt\n\n assert interval <= Nt\n\n variance = datapack.get_variance(ant_idx,time_idx,dir_idx,freq_idx)\n error = np.sqrt(variance)\n data_mask = variance < 0\n error[data_mask] = -1\n logging.warning(\"Total masked phases: {}\".format(np.sum(data_mask)))\n\n enu = ENU(obstime=times[0],location = self.datapack.radio_array.get_center())\n \n ant_enu = antennas.transform_to(enu)\n x = np.array([ant_enu.east.to(au.km).value, ant_enu.north.to(au.km).value]).T\n t = times.mjd*86400.#mjs\n d = np.array([directions.ra.deg, directions.dec.deg]).T\n f = freqs\n \n lock = Lock()\n with futures.ThreadPoolExecutor(max_workers=num_threads) as executor:\n jobs = []\n\n for j,aj in enumerate(time_idx[::shift]):\n start = j*shift\n stop = min(start+interval,Nt)\n time_slice = slice(start,stop,1)\n \n# if init_solutions is not None:\n# ###\n# # interpolate kern_params with this interval/shift\n# mean_time = np.mean(times.gps[time_slice])\n\n# model_kwargs['ls_init'] = (\n# np.interp(mean_time, kern_times, kern_ls[ant_idx,:,1].mean(0)),\n# np.interp(mean_time, kern_times, kern_ls[ant_idx,:,0].mean(0))\n# )\n #logging.warning(model_kwargs['ls_init'])\n \n # initial ls_scale (if they exist)\n\n# (phase, error, coords, lock, error_sigma_clip=4., m_type='sgp', \n# iterations=1000, pargs=None,verbose=False,model_kwargs={}):\n model_file = os.path.join(self.proj_dir,\"model_{}_{}\".format(start,stop))\n\n jobs.append(executor.submit(\n self._solve_interval_full,\n model_file,\n phase[:,time_slice,:,:],\n error[:,time_slice,:,:],\n (x, t[time_slice],d,f),\n lock,\n load_model = model_file,\n error_sigma_clip = None,\n m_type='sgp_full',\n iterations=iterations,\n pargs=\"Working on time chunk ({}) {} to ({}) {}\".format(\n start,timestamps[start],stop-1,timestamps[stop-1]),\n verbose=verbose,\n model_kwargs = model_kwargs\n )\n )\n results = futures.wait(jobs)\n if verbose:\n logging.warning(results)\n results = [j.result() for j in jobs]\n\n phase_mean = np.zeros(phase.shape)\n phase_weights = np.zeros(phase.shape)\n variance_mean = np.zeros(variance.shape)\n res_idx = 0\n for j,aj in enumerate(time_idx[::shift]):\n start = j*interval\n stop = min((j+1)*interval,Nt)\n time_slice = slice(start,stop,1)\n res = results[res_idx]\n p,v = res\n phase_mean[:,time_slice,:,:] += p/(v+1e-6)\n variance_mean[:,time_slice,:,:] += 1.\n phase_weights[:,time_slice,:,:] += 1./(v+1e-6)\n res_idx += 1\n phase_mean /= (phase_weights+1e-6)\n variance_mean /= (phase_weights+1e-6)\n datapack.set_phase(phase_mean, ant_idx=ant_idx,time_idx=time_idx,dir_idx=dir_idx,freq_idx=freq_idx)\n datapack.set_variance(variance_mean, ant_idx=ant_idx,time_idx=time_idx,dir_idx=dir_idx,freq_idx=freq_idx)\n datapack.save(save_datapack)","def calibrate(self):\n import time\n\n CALIBRATE_SLEEP = 0.75\n\n self.change_power(-self._calpow)\n encprev, encnow = 0, None\n while encprev != encnow:\n encprev = encnow\n time.sleep(CALIBRATE_SLEEP)\n encnow = self._bp.get_motor_encoder(self._port)\n self._pmin = encnow\n self.change_power(0)\n\n self.change_power(self._calpow)\n encprev, encnow = 0, None\n while encprev != encnow:\n encprev = encnow\n time.sleep(CALIBRATE_SLEEP)\n encnow = self._bp.get_motor_encoder(self._port)\n self._pmax = encnow\n self.change_power(0)\n\n if self._pmax == self._pmin:\n raise Exception('motor {} does not move'.format(self._port))\n\n self._pinit = (self._pmax + self._pmin) * 0.5\n time.sleep(0.5)\n self.to_init_position()","def calibrate(self):\n self.mode = Mode.calibrating\n yaw_sensor = yaw_button()\n while not yaw_sensor.is_pressed():\n self.move_left()\n for _ in range(75):\n self.move_right()\n\n pitch_sensor = pitch_button()\n while not pitch_sensor.is_pressed():\n self.move_up()\n for _ in range(21):\n self.move_down()\n\n self.pitch = 0.0\n self.yaw = 0.0\n self.mode = Mode.waiting","def optimize_self(self):\n self.compute_predicate_values();\n \"\"\" Firstly,adjust the f(x) into > alpha_0; \"\"\"\n for i in range(len(self.RING_PARA_PAIR_CD)):\n self.adjust_to_excepted_value(self.RING_PARA_PAIR_CD[i]);\n self.RING_PARA_PAIR_CD[i][0].VECTOR = RUNNING_DATA[self.RING_PARA_PAIR_CD[i][0].WORD_ID]; # 更新内部VECTOR;\n self.RING_PARA_PAIR_CD[i][2] = self.RING_PARA_PAIR_CD[i][0].polynomial_func(self.RING_PARA_PAIR_CD[i][1]); # 更新内部ALPHA;\n for i in range(len(self.RING_PARA_PAIR_CC)):\n # ************** BUG 0627 **********************\n # if self.RING_PARA_PAIR_CC[i][2]<41 and self.RING_PARA_PAIR_CC[i][2]>40: # ---------------------------------------------------------------->>>>>\n # print( RUNNING_DATA[self.RING_PARA_PAIR_CC[i][0].WORD_ID] ); # ---------------------------------------------------------------->>>>>\n self.adjust_to_excepted_value(self.RING_PARA_PAIR_CC[i]); \n # ************** BUG 0627 **********************\n # if self.RING_PARA_PAIR_CC[i][2]<41 and self.RING_PARA_PAIR_CC[i][2]>40: # ---------------------------------------------------------------->>>>> \n # print(self.RING_PARA_PAIR_CC[i][0].VECTOR); # ---------------------------------------------------------------->>>>>\n # print(RUNNING_DATA[self.RING_PARA_PAIR_CC[i][0].WORD_ID]); # ---------------------------------------------------------------->>>>>\n # print(self.RING_PARA_PAIR_CC[i][0].polynomial_func(self.RING_PARA_PAIR_CC[i][1])); # ---------------------------------------------------------------->>>>>\n # print( np.cumprod( self.RING_PARA_PAIR_CC[i][1] - self.RING_PARA_PAIR_CC[i][0].VECTOR )[-1] ); # ---------------------------------------------------------------->>>>>\n self.RING_PARA_PAIR_CC[i][0].VECTOR = RUNNING_DATA[self.RING_PARA_PAIR_CC[i][0].WORD_ID]; # 更新内部VECTOR;\n self.RING_PARA_PAIR_CC[i][2] = self.RING_PARA_PAIR_CC[i][0].polynomial_func(self.RING_PARA_PAIR_CC[i][1]); # 更新内部ALPHA;\n \"\"\" Secondly,adjust the alpha_0 < p_min(y_n) < q_min(x_n)\"\"\" \n P_MIN = 99999999.0; Q_MIN = 99999999.0;P_MAX = 0.0;Q_MAX = 0.0;\n CD_ID = 0;CD_MIN=0;\n # 找到结论中谓词的最小多项式值\n for RING_PARA_PAIR in self.RING_PARA_PAIR_CC:\n if Q_MIN>RING_PARA_PAIR[2]: Q_MIN=RING_PARA_PAIR[2];\n # if Q_MAX<RING_PARA_PAIR[2]: Q_MAX=RING_PARA_PAIR[2];\n # 不满足小于结论最小值的那些环的TARGET_ALPHA更新; \n for RING_PARA_PAIR in self.RING_PARA_PAIR_CD:\n if P_MIN>RING_PARA_PAIR[2]: P_MIN=RING_PARA_PAIR[2];CD_MIN=CD_ID;# self.RING_PARA_PAIR_CD[CD_ID][3]=-Q_MIN;\n # if P_MAX<RING_PARA_PAIR[2]: P_MAX=RING_PARA_PAIR[2];self.RING_PARA_PAIR_CD[CD_ID][3]=-Q_MAX;\n CD_ID+=1;\n self.RING_PARA_PAIR_CD[CD_MIN][3]=-Q_MIN; \n # 优化不满足小于结论最小值的那些环 \n for i in range(len(self.RING_PARA_PAIR_CD)): \n if self.RING_PARA_PAIR_CD[i][3]!=ALPHA:\n if P_MIN>Q_MIN:\n self.adjust_to_excepted_value(self.RING_PARA_PAIR_CD[i]); \n self.RING_PARA_PAIR_CD[i][0].VECTOR = RUNNING_DATA[self.RING_PARA_PAIR_CD[i][0].WORD_ID]; # 更新内部VECTOR;\n self.RING_PARA_PAIR_CD[i][2] = self.RING_PARA_PAIR_CD[i][0].polynomial_func(self.RING_PARA_PAIR_CD[i][1]); # 更新内部ALPHA;","def calibrate(self, cal=1.0, pol_eff=1.0):\n \n if self.ncomp == 1:\n self.data *= cal\n else:\n self.data[0] *= cal\n self.data[1] *= cal * pol_eff\n self.data[2] *= cal * pol_eff\n\n return self","def _advance_settings(self, sol):\r\n if self.cond == True:\r\n # Save last solution...\r\n self.lst_tmp = sol\r\n # Check if all timesteps are complete.\r\n self.current_T += self.d_T\r\n self.step += 1\r\n if self.current_T > self.max_T:\r\n return False\r\n # Set to not be conduction any more\r\n self.cond = False\r\n if len(self.fq_list) > 0:\r\n self.rad = 0\r\n else:\r\n # There are radiation steps to do.\r\n self.cond = True\r\n return True\r\n\r\n # If we're here, we're either not done anything yet or have\r\n # just done a radiation step.\r\n if self.rad != None:\r\n # Save last solution\r\n self.lst_rad[self.rad] = sol\r\n # Advance to next radiation stage if one exists. Else cond.\r\n if self.rad + 1 != len(self.fq_list):\r\n self.rad += 1\r\n else:\r\n self.rad = None\r\n self.cond = True\r\n return True\r\n\r\n # If we've made it to here, we must just setting the simulation\r\n # going.\r\n assert (len(self.fq_list) == len(self.lst_rad))\r\n if len(self.lst_rad) > 0:\r\n assert (len(self.fq_list) == len(self.absorb_coeffs))\r\n assert (self.refr_idx_vol >= 0.0)\r\n # Could set to zero, but that might limit restarts. Just check\r\n # Validity....\r\n assert (self.step != None)\r\n assert (self.d_T > 0.0)\r\n assert (self.current_T != None)\r\n assert (self.max_T != None)\r\n assert (self.max_T > self.current_T)\r\n assert (self.diff_scale >= 0.0)\r\n assert (self.diff_scale <= 1.0)\r\n assert (self.thermal_conductivity > 0.0)\r\n assert (self.alpha >= 0.0)\r\n assert (self.refr_idx_background >= 0.0)\r\n # Set the ball rolling:\r\n if len(self.fq_list) > 0:\r\n # We can set solver for frequencies first...\r\n self.rad = 0\r\n else:\r\n self.cond = True\r\n return True","def _calibrate_without_loss(self, calib_dataset, calib_batch_size,\n calib_steps):\n # Create quantize calibration model\n if not self._optimized_model:\n logger.error(\n 'Should call `optimize_model()` before `_calibrate_without_loss`.')\n self._qcb_model, self._layer_metadata = self._quantizer.create_quantize_model(\n self._optimized_model,\n candidate_layers=self._candidate_layers,\n layer_metadata=self._layer_metadata,\n quantize_strategy=self._quantize_strategy,\n mode='QCB',\n target=self._target,\n dataset=calib_dataset,\n batch_size=calib_batch_size,\n steps=calib_steps,\n specific_layers=self._specific_layers)\n\n if calib_dataset is not None:\n logger.info(\"Start Quantize Calibration...\")\n collector = self._run_model_with_collector(self._qcb_model, calib_dataset,\n calib_batch_size, calib_steps)\n\n # Create quantize calibration evaluation model\n self._qcbev_model = model_utils.clone_model_with_weights(self._qcb_model)\n model_utils.set_layer_mode(self._qcbev_model, 'QCBEV')\n\n if type(self._quantize_strategy\n ) == vitis_pof2s_quantize_strategy.VitisPof2SQuantizeStrategy:\n # Freeze the quantize info into the model, now using most_common_quantize_info\n # last_quantize_info = collector.get_last_quantize_info()\n common_quantize_info = collector.get_most_common_quantize_info()\n self._freeze_quantize_info(common_quantize_info)\n elif type(self._quantize_strategy) in [\n vitis_fs_quantize_strategy.VitisFSQuantizeStrategy,\n vitis_fsx_quantize_strategy.VitisFSXQuantizeStrategy,\n vitis_gpu_quantize_strategy.VitisGPUQuantizeStrategy\n ]:\n # Freeze the quantize info into the model, now using most_common_quantize_info\n # last_quantize_info = collector.get_last_quantize_info()\n common_quantize_info = collector.get_entropy_percentile_amax(\n self._qcb_model)\n self._freeze_quantize_info(common_quantize_info)\n\n logger.info(\"Quantize Calibration Done.\")","def calibrate_arm(self, axis):\n\n while self.arm.position(axis) < self.maxdist:\n\n # calibrate arm axis using exponential moves:\n # moves the arm, recenter the tip and refocus.\n try:\n self.exp_focus_track(axis)\n except EnvironmentError:\n self.update_message('Could not track the tip.')\n return 0\n\n # When calibration is finished:\n\n # Resetting position of arm and microscope so no error gets to the next axis calibration\n self.go_to_zero()\n time.sleep(2)\n\n return 1","def _calibrate_measurement(self):\n\n cold_blackbody = bb_radiance(self.cbb.header.cbb_temperature + 273.15,\n self.cbb.data.wavelength)\n warm_blackbody = bb_radiance(self.wbb.header.wbb_temperature + 273.15,\n self.wbb.data.wavelength)\n\n self.wbb.data.average_spectrum[0] = 1\n self.wbb.data.average_spectrum[2047] = 1\n\n calibration_slope = ((warm_blackbody - cold_blackbody) /\n (self.wbb.data.average_spectrum - self.cbb.data.average_spectrum))\n calibration_offset = warm_blackbody - (self.wbb.data.average_spectrum * \n calibration_slope)\n\n self.wbb.calibrate_file(calibration_slope, calibration_offset)\n self.cbb.calibrate_file(calibration_slope, calibration_offset)\n self.sam.calibrate_file(calibration_slope, calibration_offset)\n\n if not self.dwr is None:\n self.dwr.calibrate_file(calibration_slope, calibration_offset)\n\n plate_temperature = self.dwr.header.spare_f[0]\n if (self.plate == -1) :\n plate_emissivity = self.dwr.header.spare_f[1]\n\n plate_blackbody = bb_radiance(plate_temperature + 273.15,\n self.dwr.data.wavelength)\n plate_emission = plate_emissivity * plate_blackbody\n\n self.dwr.data.average_spectrum = ((self.dwr.data.average_spectrum - \n plate_emission) / (1 - plate_emissivity))","def _set_phase(self):\n self.phase = np.sign(self._model())","def one_step(self):\r\n assert (self.uv_vol is not None)\r\n assert (self.guv_vol is not None)\r\n assert (self.uv_bound is not None)\r\n assert (self.vf_vect_bound is not None)\r\n assert (self.vF_vect_vol is not None)\r\n # Shape checks\r\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\r\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\r\n assert (self.vF_vect_vol.shape == self.vf_vect_bound.shape)\r\n assert (self.uv_vol.shape[0] == self.uv_vol.shape[1])\r\n assert (self.uv_vol.shape == self.guv_vol.shape)\r\n assert (self.uv_vol.shape == self.uv_bound.shape)\r\n assert (self.uv_vol.shape[0] == self.vF_vect_vol.shape[0])\r\n \r\n if self.step == 0:\r\n self.check_k_matrix_stability()\r\n # print(\"Epsilon is :\"+str(self.Epsilon))\r\n # print(\"Beta is :\"+str(self.Beta))\r\n\r\n # Form \"Stiffness\" matrix:\r\n K = self.make_k_matrix()\r\n # Form \"Force\" vector: \r\n f = self.vF_vect_vol + (self.Epsilon / self.Beta) * self.vf_vect_bound\r\n\r\n # print(\"FORCE VECTOR:\")\r\n # print(f)\r\n # print(\"STIFFNESS MATRIX\")\r\n # print(K)\r\n # print(\"UV_VOL\")\r\n # print(self.uv_vol)\r\n # print(\"EPSILON * GUV_VOL\")\r\n # print(self.Epsilon * self.guv_vol)\r\n # print(\"UV_BOUND * COEFF\")\r\n # print((self.Epsilon / self.Beta) * self.uv_bound)\r\n sol = scipy_sparse_linsolve(K, f)\r\n # print(\"SOLUTION\")\r\n # print(sol)\r\n return sol","def solve(self):\n # check for jacobian and set it if present and to be used\n if self.use_sparse:\n if self._use_jac and hasattr(self.problem,'sparse_jac'):\n jac = self.problem.sparse_jac\n else:\n jac = None\n else:\n if self._use_jac and hasattr(self.problem,'jac'):\n jac = self.problem.jac\n else:\n jac = None\n \n # Initialize solver and solve \n \n solved = False\n local_min = False\n\n res = N.zeros(self.x0.__len__())\n while (not solved) and self.reg_count < 2:\n try:\n if self._use_fscale:\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,self.fscale)\n else:\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,None)\n start = time.clock()\n res = self.solver.KINSOL_solve(not self._use_ls)\n stop = time.clock()\n self.exec_time += (stop - start)\n solved = True\n except KINError as error:\n if error.value == 42:\n # Try the heuristic\n if hasattr(self.problem, 'get_heuristic_x0'):\n print \"----------------------------------------------------\"\n print \" Solver stuck with zero step-length.\"\n print \"----------------------------------------------------\"\n print \"The following variables have start value zero\"\n print \"and min set to zero causing the zero step-lenght.\"\n print \"These settings are either set by default or by user.\"\n print \"\"\n\n self.x0 = self.problem.get_heuristic_x0()\n self.reg_count += 1\n \n print \"\"\n print \"This setting (start and min to zero) can often\"\n print \"cause problem when initializing the system. \"\n print \"\"\n print \"To avoid this the above variables have\"\n print \"their start attributes reset to one.\"\n print \"\"\n print \"Trying to solve the system again...\"\n else:\n raise KINSOL_Exception(\"Regularization failed due to constraints, tried getting heuristic initial guess but failed.\")\n \n\n elif (error.value == 2):\n print \"---------------------------------------------------------\"\n print \"\"\n print \" !!! WARNING !!!\"\n print \"\"\n print \" KINSOL has returned a result but the algorithm has converged\"\n print \" to a local minima, the initial values are NOT consistant!\"\n print \"\"\n print \"---------------------------------------------------------\"\n solved = True\n local_min = True\n else:\n # Other error, send onward as exception\n self.problem.check_constraints(res)\n raise KINSOL_Exception(error.msg[error.value])\n \n if not solved:\n self.solver.Free_KINSOL()\n raise KINSOL_Exception(\"Algorithm exited solution loop without finding a solution, please contact Assimulo support.\")\n\n if self.check_with_model:\n self.problem.check_constraints(res)\n if not local_min:\n print \"Problem sent to KINSOL solved.\"\n \n return res","def calibrate(self):\n if not self._calibrate:\n raise ValueError(\"calibrate parameter must be set\")\n\n if self.calibration_samples >= self._max_samples:\n return self._camera\n\n frame = self.capture()\n left = frame.images[0]\n right = frame.images[1]\n\n ret_l, corners_l = left.features\n ret_r, corners_r = right.features\n\n if self._last_timestamp is None:\n self._last_timestamp = frame.timestamp\n\n if ret_l is True and ret_r is True and (frame.timestamp - self._last_timestamp).total_seconds() > self._frame_delay:\n self.objpoints.append(self.objp)\n self.imgpoints_l.append(corners_l)\n self.imgpoints_r.append(corners_r)\n\n self.calibration_samples += 1\n self._last_timestamp = frame.timestamp\n\n if self.calibration_samples >= self._max_samples:\n img_shape = left.image.shape[::-1]\n self._camera = self._finish_calibration(self.objpoints, self.imgpoints_l, self.imgpoints_r, img_shape)\n return self._camera","def calc(self):\n\n # the following if query ensures that volume- and interaction-terms\n # are only calculated if tau > 0.\n # (to avoid nan-values from invalid function-evaluations)\n\n if self.V.tau.shape == (1,):\n Isurf = self.surface()\n # differentiation for non-existing canopy, as otherwise NAN values\n if self.V.tau > 0.:\n Ivol = self.volume()\n if self.int_Q is True:\n Iint = self.interaction()\n else:\n Iint = np.array([0.])\n else:\n Ivol = np.array([0.])\n Iint = np.array([0.])\n else:\n # calculate surface-term (valid for any tau-value)\n Isurf = self.surface()\n\n # store initial parameter-values\n old_t_0 = self.t_0\n old_p_0 = self.p_0\n old_t_ex = self.t_ex\n old_p_ex = self.p_ex\n\n old_tau = self.V._get_tau()\n old_omega = self.V._get_omega()\n old_NN = self.SRF._get_NormBRDF()\n\n # set mask for tau > 0.\n mask = old_tau > 0.\n valid_index = np.where(mask)\n inval_index = np.where(~mask)\n\n # set parameter-values to valid values for calculation\n self.t_0 = old_t_0[valid_index[0]]\n self.p_0 = old_p_0[valid_index[0]]\n self.t_ex = old_t_ex[valid_index[0]]\n self.p_ex = old_p_ex[valid_index[0]]\n\n # squeezing the arrays is necessary since the setter-function for\n # tau, omega and NormBRDF automatically adds an axis to the arrays!\n self.V.tau = np.squeeze(old_tau[valid_index[0]])\n if np.array(self.V.omega).size != 1:\n self.V.omega = np.squeeze(old_omega[valid_index[0]])\n if np.array(self.SRF.NormBRDF).size != 1:\n self.SRF.NormBRDF = np.squeeze(old_NN[valid_index[0]])\n\n # calculate volume and interaction term where tau-values are valid\n _Ivol = self.volume()\n if self.int_Q is True:\n _Iint = self.interaction()\n else:\n _Iint = np.full_like(self.t_0, 0.)\n\n # reset parameter values to old values\n self.t_0 = old_t_0\n self.p_0 = old_p_0\n self.t_ex = old_t_ex\n self.p_ex = old_p_ex\n\n # squeezing the arrays is necessary since the setter-function for\n # tau, omega and NormBRDF automatically add an axis to the arrays!\n self.V.tau = np.squeeze(old_tau)\n self.V.omega = np.squeeze(old_omega)\n self.SRF.NormBRDF = np.squeeze(old_NN)\n\n # combine calculated volume-contributions for valid tau-values\n # with zero-arrays for invalid tau-values\n Ivol = np.ones_like(self.t_0)\n Ivol[valid_index[0]] = _Ivol\n Ivol[inval_index[0]] = np.ones_like(Ivol[inval_index[0]]) * 0.\n\n # combine calculated interaction-contributions for valid tau-values\n # with zero-arrays for invalid tau-values\n if self.int_Q is True:\n Iint = np.ones_like(self.t_0)\n Iint[valid_index[0]] = _Iint\n Iint[inval_index[0]] = np.ones_like(Iint[inval_index[0]]) * 0.\n else:\n Iint = np.full_like(self.t_0, 0.)\n\n return Isurf + Ivol + Iint, Isurf, Ivol, Iint","def _solve(self):\n B = sp.linalg.solve(self._XtX, self._XtY, assume_a='pos', overwrite_a=False, overwrite_b=False)\n self.coef_ = B[1:]\n self.intercept_ = B[0]\n self.is_fitted_ = True","def force_calibration_controller_test():\n print(f\"Running {__file__}::{force_calibration_controller_test.__name__}()\")\n arm_state = State()\n alpha=0.2\n ctrl = EMAForceCalibrator(Connection(arm_state), alpha=alpha)\n cmd = Command()\n state = State()\n ctrl.execute(cmd, state)\n assert np.all(ctrl.force_average.array == 0)\n\n arm_state.sensor_force()[:] = [2,2,2,2,2,2]\n ctrl.execute(cmd, state)\n assert np.all(ctrl.force_average.array != 0)\n assert state.sensor_force().allclose(np.array([2,2,2,2,2,2])*(1-alpha), 0.001)\n\n for i in range(100):\n ctrl.execute(cmd, state)\n assert ctrl.force_average.allclose([2,2,2,2,2,2], 0.001)\n assert state.sensor_force().allclose([0,0,0,0,0,0], 0.001)\n\n arm_state.sensor_force()[:] = [0,0,0,0,0,0]\n ctrl.execute(cmd, state)\n assert state.sensor_force().allclose(np.array([-2,-2,-2,-2,-2,-2])*(1-alpha), 0.001)\n\n for i in range(100):\n ctrl.execute(cmd, state)\n assert ctrl.force_average.allclose([0,0,0,0,0,0], 0.001)\n assert state.sensor_force().allclose([0,0,0,0,0,0], 0.001)\n\n print(\"Passed.\")","def start_uncorrelated_self_optimizer_strategy(wf):\n\n optimizer_method = wf.execution_strategy[\"optimizer_method\"]\n info(\"> ExecStrategy | UncorrelatedSelfOptimizer\", Fore.CYAN)\n info(\"> Optimizer | \" + optimizer_method, Fore.CYAN)\n\n knobs = wf.execution_strategy[\"knobs\"]\n wf.totalExperiments = len(knobs) * wf.execution_strategy[\"optimizer_iterations\"]\n\n total_result = dict()\n # we fill the arrays and use the index to map from gauss-optimizer-value to variable\n for key in knobs:\n optimal_knob_value = optimizeOneVariable(wf, wf.execution_strategy[\"optimizer_iterations\"], key,\n (knobs[key][0], knobs[key][1]))\n total_result[key] = optimal_knob_value\n wf.change_provider[\"instance\"].applyChange(total_result)\n info(\">\")\n info(\"> FinalResult | Best Values: \" + str(total_result))","def calibrate(self):\n\t\twl = BLi.getWavelength()\n\t\tif abs(self.stokes()) <= .5:\n\t\t\txxx=self.sign()*180/pi*asin( wl/(2*self.dspace)) - (self.thp())\n\t\t\tself.offset2(-xxx)\n\t\t\tyyy=self.tthp()-self.sign()*2*180/pi*asin(wl/(2*self.dspace))-self.offset5()\n\t\t\tself.offset4(yyy)\n\t\t\tself.offset9(self.dettrans())\n\t\telif abs(self.stokes()-90.) <= .5:\n\t\t\txxx=self.sign()*180/pi*asin( wl/(2*self.dspace)) - (self.thp())\n\t\t\tself.offset3(-xxx)\n\t\t\tyyy=self.tthp()-self.sign()*2*180/pi*asin(wl/(2*self.dspace))-self.offset5()\n\t\t\tself.offset8(yyy)\n\t\t\tself.offset10(self.dettrans())\n\t\telse:\n\t\t\tprint \"Can't calibrate at stokes=\",self.stokes()\n\t\treturn [self.sign(),self.offset2(), self.offset3(),self.offset4(),self.offset5(),self.offset8(),self.offset9(),self.offset10()]","def analyze_orbit_corrector(OC1, OC2, beamline, phase_beg):\n\n M = np.identity(4)\n OC_parameters = np.zeros(4)\n\n for element in beamline:\n M = np.dot(element.M1, M)\n\n # Since the X and Y are decoupled, we can treat them separately.\n M_x = M[0:2, 0:2]\n M_y = M[2:4, 2:4]\n\n L1 = [[OC1.length/2], [1]]\n L2 = [[OC2.length/2], [1]]\n\n M_OC1 = np.array(OC1.M1)[0:2, 0:2]\n M_OC2 = np.array(OC2.M1)[0:2, 0:2]\n\n # The following part solve the cx_1 and cx_2\n M1_x = np.linalg.multi_dot([M_OC2, M_x, L1])\n M2_x = np.linalg.multi_dot([M_OC2, M_x, M_OC1])\n M_OC_x = np.hstack((M1_x, L2))\n\n OC_parameters[0:2] = -np.linalg.multi_dot([np.linalg.inv(M_OC_x), M2_x, phase_beg[0:2]])\n # The end of the X-part\n\n # The following part solve the cy_1 and cy_2\n M1_y = np.linalg.multi_dot([M_OC2, M_y, L1])\n M2_y = np.linalg.multi_dot([M_OC2, M_y, M_OC1])\n M_OC_y = np.hstack((M1_y, L2))\n\n OC_parameters[2:4] = -np.linalg.multi_dot([np.linalg.inv(M_OC_y), M2_y, phase_beg[2:4]])\n # The end of the Y-part\n\n\n return OC_parameters","def control(self, arm, x_des=None):\n if self.u is None:\n self.u = np.zeros(arm.DOF)\n\n self.Q = np.zeros((arm.DOF*2, arm.DOF*2))\n self.Q[:arm.DOF, :arm.DOF] = np.eye(arm.DOF) * 1000.0 \n self.R = np.eye(arm.DOF) * 0.001 \n\n # calculate desired end-effector acceleration\n if x_des is None:\n self.x = arm.x \n x_des = self.x - self.target \n\n self.arm, state = self.copy_arm(arm)\n A, B = self.calc_derivs(state, self.u)\n\n if self.solve_continuous is True:\n X = sp_linalg.solve_continuous_are(A, B, self.Q, self.R)\n K = np.dot(np.linalg.pinv(self.R), np.dot(B.T, X))\n else: \n X = sp_linalg.solve_discrete_are(A, B, self.Q, self.R)\n K = np.dot(np.linalg.pinv(self.R + np.dot(B.T, np.dot(X, B))), np.dot(B.T, np.dot(X, A)))\n\n # transform the command from end-effector space to joint space\n J = self.arm.gen_jacEE()\n\n u = np.hstack([np.dot(J.T, x_des), arm.dq])\n\n self.u = -np.dot(K, u)\n\n if self.write_to_file is True:\n # feed recorders their signals\n self.u_recorder.record(0.0, self.u)\n self.xy_recorder.record(0.0, self.x)\n self.dist_recorder.record(0.0, self.target - self.x)\n\n # add in any additional signals \n for addition in self.additions:\n self.u += addition.generate(self.u, arm)\n\n return self.u","def method1(self):\n cres=0. # Variable for storing Chern number.\n # The U matrices from Fukui's method; storage...\n Ux=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n Uy=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n \n # ... and calculation of U matrices\n for ix in range(self.kS.Nx+1):\n for iy in range(self.kS.Ny+1):\n mat1=self.alleigvecs[:,:,ix ,iy ]\n if ix<self.kS.Nx:\n mat2=self.alleigvecs[:,:,ix+1,iy ]\n else:\n mat2=self.alleigvecs[:,:,1 ,iy ]\n if iy<self.kS.Ny:\n mat3=self.alleigvecs[:,:,ix ,iy+1]\n else:\n mat3=self.alleigvecs[:,:,ix ,1 ]\n Ux[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat2)[:self.NL,:self.NL])\n Uy[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat3)[:self.NL,:self.NL])\n \n # Local estimates of Berry curvature; storage ...\n ftempall=np.zeros((self.kS.Nx,self.kS.Ny),complex)\n # ... and calculation\n for ix in range(self.kS.Nx):\n for iy in range(self.kS.Ny):\n ftemp=np.log(Ux[ix,iy]*Uy[ix+1,iy]/Ux[ix,iy+1]/Uy[ix,iy])\n ftempall[ix,iy]=ftemp # ... of local Berry curvature ...\n cres+=ftemp/2./pi/1j # ... and of Berry phase (Chern number).\n\n return cres.real, ftempall","def calibrate(self):\n self.gripper_io.set_signal_value(\"calibrate\", True)\n success = intera_dataflow.wait_for(\n lambda: self.is_calibrated(),\n timeout=5.0,\n raise_on_error=False\n )\n if not success:\n rospy.logerr(\"({0}) calibration failed.\".format(self.name))\n return success","def apply_calib(fix_dir, tprobs, run, hour, exper=1, smooth=1, wd=''):\n\n # Apply smoothing\n calib_probs = gaussian_filter(tprobs, smooth, mode='constant')\n\n # Apply calibration\n run_str = str(run).zfill(2)\n in_dir = f'{fix_dir}/calib_files/{exper}/{run_str}_{hour}.pkl'\n\n with open(in_dir, 'rb') as f:\n corr_data = pickle.load(f, encoding='latin1')\n\n for index in np.ndindex(calib_probs.shape):\n this_forecast = calib_probs * 100\n if this_forecast[index] < 5:\n bin = 0\n elif this_forecast[index] >= 5 and this_forecast[index] < 15:\n bin = 10\n elif this_forecast[index] >= 15 and this_forecast[index] < 25:\n bin = 20\n elif this_forecast[index] >= 25 and this_forecast[index] < 35:\n bin = 30\n elif this_forecast[index] >= 35 and this_forecast[index] < 45:\n bin = 40\n elif this_forecast[index] >= 45 and this_forecast[index] < 55:\n bin = 50\n elif this_forecast[index] >= 55 and this_forecast[index] < 65:\n bin = 60\n elif this_forecast[index] >= 65 and this_forecast[index] < 75:\n bin = 70\n elif this_forecast[index] >= 75 and this_forecast[index] < 85:\n bin = 80\n elif this_forecast[index] >= 85:\n bin = 90\n\n calib_probs[index] = calib_probs[index] + (corr_data[index][bin] / 100.)\n calib_probs = calib_probs.astype(float)\n \n # Set anything less than 0 after calibration to 0\n calib_probs[calib_probs < 0] = 0\n \n return calib_probs","def platform_auto_calibrate(self):\n self.platform_auto_calibrate_servos()\n self.platform_auto_calibrate_imu()","def run(self):\n is_spsa = True\n is_steep_descent = False\n is_rprop = False\n\n k = 0\n theta = self.theta0\n\n while True:\n k = k + 1\n\n self.iter = k\n print(f'starting iter {k} ...')\n\n if self.constraints is not None:\n theta = self.constraints(theta)\n\n print('current param:')\n for name, value in utils.true_param(theta).items():\n print(f' {name}: {value[\"value\"]}')\n\n c_k = self.c / (k ** self.gamma)\n a_k = self.a / ((k + self.A) ** self.alpha)\n\n # print(f' ck: {c_k:0.5f}')\n # print(f' ak: {a_k:0.5f}')\n\n # Run the engine match here to get the gradient\n print('Run engine match ...')\n gradient = self.approximate_gradient(theta, c_k, k)\n\n # For SPSA we update with a small step (theta = theta - a_k * gradient)\n if is_spsa:\n theta = utils.linear_combinaison(1.0, theta, -a_k, gradient)\n logging.info(f'{__file__} > theta from spsa: {theta}')\n # print(f'new param after application of gradient:')\n # for n, v in theta.items():\n # print(f' {n}: {int(v[\"value\"] * v[\"factor\"])}')\n\n # For steepest descent we update via a constant small step in the gradient direction\n elif is_steep_descent:\n mu = -0.01 / max(1.0, utils.norm2(gradient))\n theta = utils.linear_combinaison(1.0, theta, mu, gradient)\n\n # For RPROP, we update with information about the sign of the gradients\n elif is_rprop:\n theta = utils.linear_combinaison(1.0, theta, -0.01, self.rprop(theta, gradient))\n\n # Apply parameter limits\n theta = utils.apply_limits(theta)\n logging.info(f'{__file__} > theta with limits: {theta}')\n # print(f'new param after application of limits:')\n # for n, v in theta.items():\n # print(f' {n}: {int(v[\"value\"] * v[\"factor\"])}')\n\n # We then move to the point which gives the best average of goal\n (avg_goal, avg_theta) = self.average_best_evals(30)\n logging.info(f'{__file__} > avg_theta from average_best_evals: {avg_theta}')\n\n theta = utils.linear_combinaison(0.98, theta, 0.02, avg_theta)\n logging.info(f'{__file__} > theta with avg_theta: {theta}')\n # print(f'new param after application of best average param:')\n # for n, v in theta.items():\n # print(f' {n}: {int(v[\"value\"] * v[\"factor\"])}')\n\n # Apply parameter limits\n theta = utils.apply_limits(theta) # This is the best param.\n logging.info(f'{__file__} > best param: {theta}')\n # print(f'new param after application of limits:')\n # for n, v in theta.items():\n # print(f' {n}: {int(v[\"value\"] * v[\"factor\"])}')\n\n # Log best param values\n for kv, vv in theta.items():\n logging.info(f'<best> iter: {k}, param: {kv}, value: {int(vv[\"value\"]*vv[\"factor\"])}')\n print('best param:')\n for n, v in theta.items():\n print(f' {n}: {int(v[\"value\"] * v[\"factor\"])}')\n\n mean_all_goal, _ = self.average_evaluations(30)\n print(f'mean all goal: {mean_all_goal}')\n\n mean_best_goal, _ = self.average_best_evals(30)\n print(f'mean best goal: {mean_best_goal}')\n\n # Save data in csv for plotting.\n plot_data = {}\n plot_data.update({'iter': k})\n plot_data.update({'meanbestgoal': mean_best_goal})\n plot_data.update({'meanallgoal': mean_all_goal})\n plot_theta = utils.true_param(theta)\n for name, value in plot_theta.items():\n plot_data.update({name: value[\"value\"]})\n\n with open(self.plot_data_file, 'a') as f:\n cnt = 0\n for name, value in plot_data.items():\n cnt += 1\n if cnt == len(plot_data):\n f.write(f'{value}\\n')\n else:\n f.write(f'{value},')\n\n print(f'done iter {k} / {self.max_iter}')\n logging.info(f'{__file__} > done iter {k} / {self.max_iter}')\n print('=========================================')\n\n # Stopping rule 1: Average goal and iteration meet the\n # stop_all_mean_goal and stop_min_iter criteria.\n if k >= self.stop_min_iter and mean_all_goal <= self.stop_all_mean_goal:\n print('Stop opimization due to good average all goal!')\n break\n\n # Stopping rule 2: Average best goal and iteration meet the\n # stop_best_mean_goal and stop_min_iter criteria.\n if k >= self.stop_min_iter and mean_best_goal <= self.stop_best_mean_goal:\n print('Stop opimization due to good average best goal!')\n break\n\n # Stopping rule 3: Max iteration is reached.\n if k >= self.max_iter:\n print('Stop opimization due to max iteration!')\n break\n\n return utils.true_param(theta)","def __call__(self):\n\n if self.indices is []:\n return\n\n\n #-----------------------------------------\n # Here is where the important formula is applied\n #----------------------------------------\n if self.indices is None:\n height = self.stage_c - self.elev_c\n self.friction_c[:] = self.friction(height)\n else:\n ind = self.indices\n height = self.stage_c[ind] - self.elev_c[ind]\n self.friction_c[ind] = self.friction(height)","def __solve(self) -> None:\n pyo.TransformationFactory(\"contrib.detect_fixed_vars\").apply_to(self.model) # type: ignore\n pyo.TransformationFactory(\"contrib.deactivate_trivial_constraints\").apply_to(self.model) # type: ignore\n\n # initialise the solver object\n self._logger.debug(\"[ModelSolver] Solver object initiated...\")\n solver = Config.OPTIMISATION_MODEL_CONFIG['SOLVER_TYPE']\n opt = pyo.SolverFactory(solver)\n if Config.OPTIMISATION_MODEL_CONFIG['SOLVER_OPTION'].get(solver) is not None:\n for k, v in Config.OPTIMISATION_MODEL_CONFIG['SOLVER_OPTION'].get(solver).items():\n opt.options[k] = v\n\n try:\n start_time = datetime.now()\n self._logger.debug(\"[ModelSolver] Solver starting...\")\n results = opt.solve(self.model, tee=True)\n self.results = results\n end_time = datetime.now()\n self._logger.info(f\"[ModelSolver] Solver completed in {end_time - start_time}.\")\n except Exception as e:\n raise Exception(f\"Model optimisation failed with {solver} with error message {e}.\")\n\n if (results.solver.status == SolverStatus.ok) and (results.solver.termination_condition == TerminationCondition.optimal):\n self._logger.info(\"Solution is feasible and optimal\")\n results.write()\n elif results.solver.termination_condition == TerminationCondition.infeasible:\n raise ValueError(\"Model optimisation resulted into an infeasible solution\")\n\n self.model.optimised = True","def calcIntrasec(self, gui):\n count = len(self.points)\n numpoints = (self.chessSize[0]*self.chessSize[1])\n\n #create matrices that are needed to compute calibration\n mat = cv.CreateMat(3,3,cv.CV_32FC1)\n distCoeffs = cv.CreateMat(4,1,cv.CV_32FC1)\n p3d = cv.CreateMat(count,3,cv.CV_32FC1) #compute 3D points\n p2d = cv.CreateMat(count,2,cv.CV_32FC1) #compute 2D points\n pointCounts = cv.CreateMat( self.nframe ,1,cv.CV_32SC1) #give numpoints per images\n cv.Set(pointCounts,numpoints)\n rvecs = cv.CreateMat(self.nframe,3,cv.CV_32FC1)\n tvecs = cv.CreateMat(self.nframe,3,cv.CV_32FC1)\n\n i = 0\n row = 0\n col = 0\n cv.Set(p3d,0.0) #to set every values to 0.0... and not set Z value\n\n #this compute points in row and cols...\n for p in self.points:\n p2d[i,0] = p[0]\n p2d[i,1] = p[1]\n \n p3d[i,0] = col\n p3d[i,1] = row\n col+=1\n if col >= self.chessSize[0]: \n row+=1\n col=0\n if row >= self.chessSize[1]:\n row = 0\n i+=1\n\n #and now, calibrate...\n cv.CalibrateCamera2(p3d, p2d, pointCounts, self.framesize, mat, distCoeffs, rvecs, tvecs, flags=0)\n gui.setMessage(\"Intrasinc camera parameters checked\")\n\n return (mat, distCoeffs)","def cam_calibration():\n # read all calibration images in a folder with similar names\n images = glob.glob('./camera_cal/calibration*.jpg')\n\n # calibrate camera and read object-points (3D), image points (2D) and image shape\n objpoints, imgpoints, img_shape = calibrate_camera(images)\n print(\"DONE: Camera calibration\")\n # save calibration parameters' pickle file\n save_calib_params(objpoints, imgpoints, img_shape)\n print(\"Calibration parameters pickle file saved \")","def advance(self):\n\n f, n, rtol, atol, neq = \\\n self.f, self.n, self.rtol, self.atol, self.neq\n u_n, t_n, t_next = self.u[n], self.t[n], self.t[n+1]\n dt = t_next - t_n\n\n first_step = dt # try one big step to next desired level\n\n def middle(x,y,z): # Auxilary function\n return sorted([x,y,z])[1]\n\n # Extract coefficients from Butcher-tableau\n table = self._butcher_tableau\n k_len = table.shape[1] - 1 # number of internal stages\n\n # coefficients for internal stages\n factors_u = np.asarray(table[:k_len, 1:])\n # coefficients for t\n factors_t = table[:k_len, 0]\n # coefficients for u_new\n factors_u_new = table[k_len, 1:]\n\n # coefficients for local error between 2 levels\n factors_error = table[k_len+1, 1:] - factors_u_new\n\n u_intermediate = [u_n,]\n t_intermediate = [t_n,]\n u, t, h = u_n, t_n, first_step # initial values\n k = np.zeros((k_len, self.neq), self.dtype) # intern stages\n\n if self.verbose > 0:\n print 'advance solution in [%s, %s], h=%g' % (t_n, t_next, h)\n\n # Loop until next time point is reached\n while (abs(t - t_n) < abs(t_next - t_n)):\n u, t = u_intermediate[-1], t_intermediate[-1]\n\n # Internal steps\n k[:, :] = 0. # initialization for next step\n for m in range(k_len):\n k_factors = (np.dot(factors_u, k))[m]\n #print u, u+h*k_factors, f(u+h*k_factor, 0.5), self.dtype\n k[m] = f(u+h*k_factors, t+h*factors_t[m])\n u_new = u + h*(np.dot(factors_u_new, k))\n\n self.info['rejected'] += 1 # reduced below if accepted\n if self.verbose > 0:\n print ' u(t=%g)=%g: ' % (t+h, u_new),\n\n # local error between 2 levels\n error = h*np.abs(np.dot(factors_error, k))\n # Acceptable error tolerance\n tol = rtol*np.abs(u_new) + atol\n\n accurate = (error <= tol).all()\n\n if accurate or h <= self.min_step or h >= self.max_step:\n # Accurate enough,\n # or the step size exceeds valid range,\n # must accept this solution\n u_intermediate.append(u_new)\n t_intermediate.append(t+h)\n if not self.disk_storage:\n self.u_all.append(u_new)\n self.t_all.append(t+h)\n self.info['rejected'] -= 1\n\n if self.verbose > 0:\n print 'accepted, ',\n else:\n if self.verbose > 0:\n print 'rejected, ',\n\n if self.verbose > 0:\n print 'err=%s, ' % str(error),\n if hasattr(self, 'u_exact') and callable(self.u_exact):\n print 'exact-err=%s, ' % \\\n (np.asarray(self.u_exact(t+h))-u_new),\n if h <= self.min_step:\n print 'h=min_step!! ',\n\n\n # Replace 0 values by 1e-16 since we will divide by error\n error = np.asarray([(1e-16 if x == 0. else x) \\\n for x in error])\n\n # Normarized error rate\n rms = error/tol\n rms_norm = np.sqrt(np.sum(rms*rms)/self.neq)\n\n order = float(self._method_order[0])\n # factor to adjust the size of next step\n # Formula is from <Numerical Methods for Engineers,\n # Chappra & Cannle>\n s = .8 *((1./rms_norm)**(1/order))\n # scalar should be in range(0.1, 4.)\n # for better accuracy and smoothness\n s = middle(s, 0.1, 4.0)\n h *= s\n\n # step size should be in range [min_step, max_step]\n h = middle(h, self.min_step, self.max_step)\n # adjust h to fit the last step\n h = min(h, t_next - t_intermediate[-1])\n\n if self.verbose > 0:\n print 'new h=%g' % h\n\n if h == 0:\n break\n\n return u_new","def ekf_algorithm(self, u, y):\n x_est_before = self.x_estimated_state\n cov_matrix_before = self.cov_matrix\n # 1. Prediction\n # predict the state by integrate the time continuous system numerically\n sim_state_predict = self.heliSim.calc_step(u[0][0], u[1][0], self.no_disturbance_eval)\n x_est_predict = np.resize(sim_state_predict, (8, 1))\n # predict the new covariance by linearizing and discretizing the model\n Ak, Bk, Ck, Dk = self.get_linear_discrete_matrices(x_est_before, u[0][0], u[1][0])\n cov_matrix_predict = Ak @ cov_matrix_before @ np.transpose(Ak) + Bk @ self.N @ np.transpose(Bk)\n # 2. Update\n # compute kalman gain\n Kl = cov_matrix_predict @ np.transpose(Ck) @ np.linalg.inv(Ck @ cov_matrix_predict @ np.transpose(Ck) + self.W)\n # update state\n y_est = x_est_predict[0:3]\n x_est_update = x_est_predict + Kl @ (y - y_est)\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ Ck) @ cov_matrix_predict\n\n # check if the update step state needs to be changed because of limit crossing\n # if that is the case, correct the state and set the state of the simulation accordingly\n corrected_state = self.heliSim.get_limited_state_and_change_state(x_est_update.reshape((1, 8))[0],\n ModelType.GYROMOMENT)\n x_est_update = np.resize(corrected_state, (8, 1))\n\n self.x_estimated_state = x_est_update\n self.cov_matrix = cov_matrix_update\n # print(\"------\")\n # print(cov_matrix_predict)\n return x_est_update","def __update(self):\n\n # Make sure loads have been assigned to group\n if type(self.appliedLoad) == Load:\n self.appliedLoad = LoadSet(self.appliedLoad)\n elif type(self.appliedLoad) != LoadSet:\n raise TypeError(\"Applied load must be a Load or LoadSet\")\n\n # Begin Calculations\n _cg = self.cg # calculate the cg once to save computation time\n _appLoad = self.appliedLoad.totalForce\n _appMoment = self.appliedLoad.totalMoment\n\n coef_mat = np.zeros((len(self) * 3, len(self) * 3)) # coeff matrix\n soln_mat = np.zeros(len(self) * 3) # solution matrix\n\n cSet = [[i, i+1, i+2] for i in range(0, 3 * len(self), 3)]\n rSet = [[i+6, i+7, i+8] for i in range(0, 3 * (len(self) - 2), 3)]\n\n for i, j in enumerate(cSet):\n # i = column fastener ID\n # j = column fastener set\n # Mx = yFz - zFy\n # My = zFx - xFz\n # Mz = xFy - yFx\n\n Fx = j[0]\n Fy = j[1]\n Fz = j[2]\n\n # fill in first three rows\n coef_mat[0][Fx] = 1 # sum of Fx\n coef_mat[1][Fy] = 1 # sum of Fy\n coef_mat[2][Fz] = 1 # sum of Fz\n\n # fill in fourth row (sum of Mx at CG)\n coef_mat[3][Fy] = -(F[i].xyz[2] - _cg[2]) # -zFy\n coef_mat[3][Fz] = +(F[i].xyz[1] - _cg[1]) # +yFz\n\n # fill in fifth row (sum of My at CG)\n coef_mat[4][Fx] = +(F[i].xyz[2] - _cg[2]) # +zFx\n coef_mat[4][Fz] = -(F[i].xyz[0] - _cg[0]) # -xFz\n\n # fill in sixth row (sum of Mz at CG)\n coef_mat[5][Fx] = -(F[i].xyz[1] - _cg[1]) # -yFx\n coef_mat[5][Fy] = +(F[i].xyz[0] - _cg[0]) # +xFy\n\n for u, w in enumerate(rSet):\n # u = row fastener ID\n # w = row fastener set\n\n rX = w[0]\n rY = w[1]\n rZ = w[2]\n\n coef_mat[rX][Fy] = -(F[i].xyz[2] - F[u].xyz[2]) # -zFy\n coef_mat[rX][Fz] = +(F[i].xyz[1] - F[u].xyz[1]) # +yFz\n\n coef_mat[rY][Fx] = +(F[i].xyz[2] - F[u].xyz[2]) # +zFx\n coef_mat[rY][Fz] = -(F[i].xyz[0] - F[u].xyz[0]) # -xFz\n\n coef_mat[rZ][Fx] = -(F[i].xyz[1] - F[u].xyz[1]) # -yFx\n coef_mat[rZ][Fy] = +(F[i].xyz[0] - F[u].xyz[0]) # +xFy\n\n # fill in the solution matrix (soln_mat)\n for i in range(3):\n soln_mat[i] = -_netLoad.force[i]\n soln_mat[i+3] = -_netLoad.moment[i]\n\n # fill in the remaining rows\n for i, j in enumerate(rSet):\n # i = fastener\n # j = row\n\n rX = j[0]\n rY = j[1]\n rZ = j[2]\n\n # Mx = (y_cg - y_i)F_znet - (z_cg - z_i)F_ynet + M_xnet\n soln_mat[rX] = - ((_cg[1] - F[i].xyz[1]) * _netLoad.force[2]\n - (_cg[2] - F[i].xyz[2]) * _netLoad.force[1]\n + _netLoad.moment[0])\n\n # My = (z_cg - z_i)F_xnet - (x_cg - x_i)F_znet + M_ynet\n soln_mat[rY] = -((_cg[2] - F[i].xyz[2]) * _netLoad.force[0]\n - (_cg[0] - F[i].xyz[0]) * _netLoad.force[2]\n + _netLoad.moment[1])\n\n # Mz = (x_cg - x_i)F_ynet - (y_cg - y_i)F_xnet + M_znet\n soln_mat[rZ] = -((_cg[0] - F[i].xyz[0]) * _netLoad.force[1]\n - (_cg[1] - F[i].xyz[1]) * _netLoad.force[0]\n + _netLoad.moment[2])\n\n # Solve system of equations\n matSol = np.linalg.lstsq(coef_mat, soln_mat)[0]\n\n # Add resulting fastener loads to fastener objects\n for i, j in enumerate(cSet):\n rX = j[0]\n rY = j[1]\n rZ = j[2]\n\n F[i].force[0] = matSol[rX]\n F[i].force[1] = matSol[rY]\n F[i].force[2] = matSol[rZ]","def step(self):\n # A = self.array\n # B = self.array2\n # ra, rb, f, k = self.params\n H = self.array\n L = self.array2\n birth_rate, death_rate, a, c = self.params\n \n # cA = correlate2d(A, self.kernel, **self.options)\n # cB = correlate2d(B, self.kernel, **self.options)\n cH = correlate2d(H, self.kernel,**self.options)\n cL = correlate2d(L, self.kernel, **self.options)\n\n # reaction = A * B**2\n\n # self.array += ra * cA - reaction + f * (1-A) \n # self.array2 += rb * cB + reaction - (f+k) * B\n self.array += birth_rate*cH - a*L*H\n self.array2 += c*cL*cH - death_rate*L","def efSolver2(self):\n dx = self.dh[0] # dx\n dy = self.dh[1] # dy\n dz = self.dh[2] # dz\n \n \"\"\"\n for i in np.arange(0, self.ni):\n for j in np.arange(0, self.nj):\n for k in np.arange(0, self.nk):\n \"\"\"\n\n ##x-component#\n #if i==0: \n #x-component#\n \"\"\"\n if i==0: \n # forward\n self.ef[i][j][k][0] = -(-3*self.phi[i][j][k]+\\\n 4*self.phi[i+1][j][k]-\\\n self.phi[i+2][j][k])/(2*dx)\n \"\"\"\n \n # forward\n self.ef[0,0:self.nj,0:self.nk,0] = -(-3*self.phi[0,0:self.nj,0:self.nk]+\\\n 4*self.phi[1,0:self.nj,0:self.nk]-\\\n self.phi[2,0:self.nj,0:self.nk])/(2*dx)\n \n #elif i==self.ni-1: \n \"\"\"\n elif i==self.ni-1: \n # backward\n self.ef[i][j][k][0] = -(self.phi[i-2][j][k]-\\\n 4*self.phi[i-1][j][k]+\\\n 3*self.phi[i][j][k])/(2*dx)\n \"\"\" \n # backward\n self.ef[self.ni-1,0:self.nj,0:self.nk,0] = -(self.phi[self.ni-3,0:self.nj,0:self.nk]-\\\n 4*self.phi[self.ni-2,0:self.nj,0:self.nk]+\\\n 3*self.phi[self.ni-1,0:self.nj,0:self.nk])/(2*dx)\n \"\"\"\n else: \n #central\n self.ef[i][j][k][0] = -(self.phi[i+1][j][k] - \\\n self.phi[i-1][j][k])/(2*dx)\n \"\"\" \n #central\n self.ef[1:self.ni-1,0:self.nj,0:self.nk,0] = -(self.phi[2:self.ni,0:self.nj,0:self.nk] - \\\n self.phi[0:self.ni-2,0:self.nj,0:self.nk])/(2*dx)\n\n\n #y-component\n #if j==0:\n \"\"\"\n if j==0:\n self.ef[i][j][k][1] = -(-3*self.phi[i][j][k] + \\\n 4*self.phi[i][j+1][k]-\\\n self.phi[i][j+2][k])/(2*dy)\n \n \"\"\"\n self.ef[0:self.ni,0,0:self.nk,1] = -(-3*self.phi[0:self.ni,0,0:self.nk] + \\\n 4*self.phi[0:self.ni,1,0:self.nk]-\\\n self.phi[0:self.ni,2,0:self.nk])/(2*dy)\n #elif j==self.nj-1:\n \"\"\"\n elif j==self.nj-1:\n self.ef[i][j][k][1] = -(self.phi[i][j-2][k] - \\\n 4*self.phi[i][j-1][k] +\\\n 3*self.phi[i][j][k])/(2*dy)\n \n \"\"\"\n self.ef[0:self.ni,self.nj-1,0:self.nk,1] = -(self.phi[0:self.ni,self.nj-3,0:self.nk] - \\\n 4*self.phi[0:self.ni,self.nj-2,0:self.nk] +\\\n 3*self.phi[0:self.ni,self.nj-1,0:self.nk])/(2*dy)\n #else:\n \"\"\"\n else:\n self.ef[i][j][k][1] = -(self.phi[i][j+1][k] - \\\n self.phi[i][j-1][k])/(2*dy)\n\n \"\"\"\n self.ef[0:self.ni,1:self.nj-1,0:self.nk,1] = -(self.phi[0:self.ni,2:self.nj,0:self.nk] - \\\n self.phi[0:self.ni,0:self.nj-2,0:self.nk])/(2*dy)\n\n #z-component\n '''\n if k==0:\n self.ef[i][j][k][2] = -(-3*self.phi[i][j][k] + \\\n 4*self.phi[i][j][k+1]-\n self.phi[i][j][k+2])/(2*dz)\n \n '''\n #z-component\n #if k==0:\n self.ef[0:self.ni,0:self.nj,0,2] = -(-3*self.phi[0:self.ni,0:self.nj,0] + \\\n 4*self.phi[0:self.ni,0:self.nj,1]-\n self.phi[0:self.ni,0:self.nj,2])/(2*dz)\n\n \"\"\"\n elif k==self.nk-1:\n self.ef[i][j][k][2] = -(self.phi[i][j][k-2] - \\\n 4*self.phi[i][j][k-1] + \\\n 3*self.phi[i][j][k])/(2*dz)\n \"\"\"\n \n #elif k==self.nk-1:\n self.ef[0:self.ni,0:self.nj,self.nk-1,2] = -(self.phi[0:self.ni,0:self.nj,self.nk-3] - \\\n 4*self.phi[0:self.ni,0:self.nj,self.nk-2] + \\\n 3*self.phi[0:self.ni,0:self.nj,self.nk-1])/(2*dz) \n \"\"\"\n else:\n self.ef[i][j][k][2] = -(self.phi[i][j][k+1] - \\\n self.phi[i][j][k-1])/(2*dz)\n \"\"\"\n #else:\n self.ef[0:self.ni,0:self.nj,1:self.nk-1,2] = -(self.phi[0:self.ni,0:self.nj,2:self.nk] - \\\n self.phi[0:self.ni,0:self.nj,0:self.nk-2])/(2*dz)","def findphase(self):\n debug('ControllerStartup.findphase()')\n if not self.pidevice.HasFPH() or self.prop['skipfph']:\n return\n if not self._databuf['cstdone']:\n debug('no need to do find phase for axes %r', self.pidevice.axes)\n return\n for axis in self._databuf['cstdone']:\n if self.pidevice.qFRF(axis)[axis]:\n self.pidevice.FPH(axis)\n waitonphase(self.pidevice, **self._kwargs)\n self.pidevice.WPA()\n else:\n info('skip find phase for axis while axis %s is not referenced' % axis)","def applyCal(beam, row, freqs, freqs_cal, cf, T_d_x, T_d_y):\n \n P_sys_xx = beam.cols.xx[row].astype('float')\n xx_on = beam.cols.xx_cal_on[row].astype('float')\n xx_off = beam.cols.xx_cal_off[row].astype('float')\n P_on_xx = np.average(extractMid(xx_on))\n P_off_xx = np.average(extractMid(xx_off))\n \n #P_on_xx = fitLine(freqs_cal, xx_on, len(freqs))\n #P_off_xx = fitLine(freqs_cal, xx_off, len(freqs))\n\n P_sys_yy = beam.cols.yy[row].astype('float')\n yy_on = beam.cols.yy_cal_on[row].astype('float')\n yy_off = beam.cols.yy_cal_off[row].astype('float')\n P_on_yy = np.average(extractMid(yy_on))\n P_off_yy = np.average(extractMid(yy_off))\n \n #P_on_yy = fitLine(freqs_cal, yy_on, len(freqs))\n #P_off_yy = fitLine(freqs_cal, yy_off, len(freqs))\n\n \n T_sys_xx = P_sys_xx / (cf*P_on_xx - cf*P_off_xx) * T_d_x\n T_sys_yy = P_sys_yy / (cf*P_on_yy - cf*P_off_yy) * T_d_y\n \n return T_sys_xx, T_sys_yy","def do_calibration(x,y,z,temperature,cp, optimal_t=25):\n # if temperature is used for calibration:\n if temperature is not None:\n # create an array of T - optimal_T (temperature minus the optimal temperature) i.e. the deviation in T from the optimum\n temp_dev = np.empty(len(temperature.data))\n for i in range(len(temperature.data)):\n temp_dev[i] = temperature.data[i] - optimal_t\n\n x.data = cp[\"x_offset\"] + (temp_dev * cp[\"x_temp_offset\"]) + (x.data * cp[\"x_scale\"])\n y.data = cp[\"y_offset\"] + (temp_dev * cp[\"y_temp_offset\"]) + (y.data * cp[\"y_scale\"])\n z.data = cp[\"z_offset\"] + (temp_dev * cp[\"z_temp_offset\"]) + (z.data * cp[\"z_scale\"])\n\n x.temp_offset = cp[\"x_temp_offset\"]\n y.temp_offset = cp[\"y_temp_offset\"]\n z.temp_offset = cp[\"z_temp_offset\"]\n\n # if temperature is not used for calibration:\n else:\n x.data = cp[\"x_offset\"] + (x.data * cp[\"x_scale\"])\n y.data = cp[\"y_offset\"] + (y.data * cp[\"y_scale\"])\n z.data = cp[\"z_offset\"] + (z.data * cp[\"z_scale\"])\n\n x.offset = cp[\"x_offset\"]\n x.scale = cp[\"x_scale\"]\n x.calibrated = True\n\n y.offset = cp[\"y_offset\"]\n y.scale = cp[\"y_scale\"]\n y.calibrated = True\n\n z.offset = cp[\"z_offset\"]\n z.scale = cp[\"z_scale\"]\n z.calibrated = True","def solve(self, F, u0=None, maxiter=100, rtol=1.e-6, rtol2=1.e-6 \\\n , verbose=False, update=False):\n # assembly the stifness matrix and bc terms\n poisson.assembly(self, update=update)\n\n # project u0 onto the discrete vectorial space\n self.initialize(u0=u0)\n\n # ...\n PDE = self\n V = PDE.space\n un = PDE.unknown\n rhs = self.rhs\n # ...\n\n rhs.func = F\n\n # ...\n from time import time\n list_Err = [1.e6]\n list_ErrH1 = [1.e6]\n un_values = un.get()\n normH1_old = np.dot(PDE.dot(un.get()), un.get())\n i = 0\n if verbose:\n tb = time()\n while (list_Err[-1] > rtol) and (list_ErrH1[-1] > rtol2) and (i < maxiter):\n U_old_values = un.get()\n# print \"-------\"\n# print \"solve\"\n# import matplotlib.pyplot as plt\n## Phi = PDE.G_W\n# Phi = PDE.unknown_dirichlet\n## Phi.plot(withpcolor=True) ; plt.colorbar() ; plt.show()\n# Phi.fast_plot() ; plt.colorbar() ; plt.show()\n# print \"-------\"\n\n # assembly the right hand side\n rhs.reset()\n self.update()\n # solve and update unew\n poisson.solve(self, rhs)\n\n U_values = un.get()\n err = np.linalg.norm(U_values-U_old_values)\n list_Err.append(err)\n\n normH1 = np.dot(PDE.dot(un.get()), un.get())\n list_ErrH1.append(np.abs(normH1-normH1_old))\n\n normH1_old = normH1\n\n i += 1\n if verbose:\n print(i, \": \",\" |F(x)| = \", list_Err[-1],\" |DF(x)| = \", list_ErrH1[-1])\n if verbose:\n te = time()\n print(\">> Elapsed time \", te-tb)\n\n list_Err = np.asarray(list_Err[1:])\n list_ErrH1 = np.asarray(list_ErrH1[1:])\n return list_Err, list_ErrH1","def baseline_correct(self):\n\n x_a = np.arange(0, len(self.phased))\n # vector the same length as the data in one direction\n\n base = np.zeros((dim_matrix, dim_matrix))\n for i in range(0, len(self.phased)):\n phased_baseline = np.polyfit(x_a, self.phased[i, :], 3)\n # baseline correct in y direction\n baseline = np.polyval(phased_baseline, x_a)\n self.phased[i, :] = self.phased[i, :]-baseline\n base[i, :] = baseline\n\n for i in range(0, len(self.phased)):\n phased_baseline = np.polyfit(x_a, self.phased[:, i], 3)\n # baseline correct in x direction\n baseline = np.polyval(phased_baseline, x_a)\n self.phased[:, i] = self.phased[:, i]-baseline\n base[:, i] = base[:, i]+baseline\n self.baseline_corrected = self.phased\n\n return self.baseline_corrected","def _solve(self) -> CasADiArrayType:\n solver_input = {\"x0\": self.x0, \"p\": self.p}\n if self.opt_type in CONSTRAINED_OPT:\n solver_input[\"lbg\"] = self._lbg\n solver_input[\"ubg\"] = self._ubg\n self._solution = self._solver(**solver_input)\n self._stats = self._solver.stats()\n self._stats[\"solution\"] = self._solution\n return self._solution[\"x\"]","def calibrate(self, Otrain, Ftrain, Feval):\n return Otrain[0] * np.ones(len(Feval))","def solve(self):","def _compute_correction(self, initial_state, final_state, a, b, c, s):\r\n pertub = self.pertub\r\n pertub_s = pertub *10\r\n \r\n pred_no_pertub = self._motion_update_one_shot(initial_state, a, b, c, s)\r\n pred_pertub_a = self._motion_update_one_shot(initial_state, a +pertub, b, c, s)\r\n pred_pertub_b = self._motion_update_one_shot(initial_state, a, b +pertub, c, s)\r\n # no need to correct C, C is constrained by kappa_final\r\n # # pred_pertub_c = self._motion_update_one_shot(initial_state, a, b, c +pertub, s)\r\n pred_pertub_s = self._motion_update_one_shot(initial_state, a, b, c, s +pertub_s)\r\n\r\n d_state = np.zeros((3,1))\r\n d_pertub_state = np.zeros((3,3))\r\n Jacobian = np.zeros((3,3))\r\n for i in range(0, 3):\r\n d_pertub_state[i][0] = (final_state[i] - pred_pertub_a[i]) # a\r\n d_pertub_state[i][1] = (final_state[i] - pred_pertub_b[i]) # b\r\n # d_pertub_state[i][2] = (final_state[i] - pred_pertub_c[i]) # c (no update)\r\n d_pertub_state[i][2] = (final_state[i] - pred_pertub_s[i]) # s\r\n \r\n d_state[i] = final_state[i] - pred_no_pertub[i]\r\n \r\n Jacobian[i][0] = (d_pertub_state[i][0] - d_state[i])/pertub # a\r\n Jacobian[i][1] = (d_pertub_state[i][1] - d_state[i])/pertub # b\r\n # Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub # c (no update)\r\n Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub_s # s\r\n\r\n # inv_Jacobian = np.linalg.inv(Jacobian)\r\n inv_Jacobian = np.linalg.pinv(Jacobian)\r\n correction = np.dot(inv_Jacobian, d_state)\r\n # pdb.set_trace()\r\n return correction","def compute_camera_calib_distortion_params():\r\n nx = 9#number of inside corners in x\r\n ny = 6#number of inside corners in y\r\n # prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)\r\n objp = np.zeros((ny*nx,3), np.float32)\r\n objp[:,:2] = np.mgrid[0:nx, 0:ny].T.reshape(-1,2)\r\n\r\n # Arrays to store object points and image points from all the images.\r\n objpoints = [] # 3d points in real world space\r\n imgpoints = [] # 2d points in image plane.\r\n\r\n # Read a particular image just to get image size (all images in the directory are same size)\r\n img = cv2.imread('./camera_cal/calibration3.jpg')\r\n img_size = (img.shape[1], img.shape[0])\r\n # Make a list of calibration images\r\n images = glob.glob('./camera_cal/calibration*.jpg')\r\n # Step through the list and search for chessboard corners\r\n for idx, fname in enumerate(images):\r\n img = cv2.imread(fname)\r\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\r\n\r\n # Find the chessboard corners\r\n ret, corners = cv2.findChessboardCorners(gray, (nx,ny), None)\r\n\r\n # If found, add object points, image points\r\n if ret == True:\r\n objpoints.append(objp)\r\n imgpoints.append(corners)\r\n # # Draw and display the corners\r\n # cv2.drawChessboardCorners(img, (nx,ny), corners, ret)\r\n # #write_name = 'corners_found'+str(idx)+'.jpg'\r\n # #cv2.imwrite(write_name, img)\r\n # cv2.imshow('img', img)\r\n # cv2.waitKey(500)\r\n\r\n # Do camera calibration given object points and image points\r\n ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, img_size,None,None)\r\n # Save the camera calibration result for later use (we won't worry about rvecs / tvecs)\r\n dist_pickle = {}\r\n dist_pickle[\"mtx\"] = mtx\r\n dist_pickle[\"dist\"] = dist\r\n pickle.dump( dist_pickle, open( \"data/cam_calib_pickle.p\", \"wb\" ) )\r\n print(\"Pickling done\")","def solve_l1(y, A_fun, AT_fun, lambda_l1, reshape_img_fun, show_img_progress=False, alpha=0.2, max_iter=100, solver_tol=1e-6):\n\n\n obj_lss = np.zeros(max_iter)\n x_zs = np.zeros(max_iter)\n u_norms = np.zeros(max_iter)\n times = np.zeros(max_iter)\n\n ATy = AT_fun(y)\n x_shape = ATy.shape\n d = np.prod(x_shape)\n\n def A_cgs_fun(x):\n x = np.reshape(x, x_shape, order='F')\n y = AT_fun(A_fun(x)) + alpha * x\n return vec(y)\n A_cgs = LinearOperator((d,d), matvec=A_cgs_fun, dtype='float')\n\n def compute_p_inv_A(b, z0):\n (z,info) = sp.sparse.linalg.cgs(A_cgs, vec(b), x0=vec(z0), tol=1e-3, maxiter=100)\n if info > 0:\n print('cgs convergence to tolerance not achieved')\n elif info <0:\n print('cgs gets illegal input or breakdown')\n z = np.reshape(z, x_shape, order='F')\n return z\n\n\n def A_cgs_fun_init(x):\n x = np.reshape(x, x_shape, order='F')\n y = AT_fun(A_fun(x))\n return vec(y)\n A_cgs_init = LinearOperator((d,d), matvec=A_cgs_fun_init, dtype='float')\n\n def compute_init(b, z0):\n (z,info) = sp.sparse.linalg.cgs(A_cgs_init, vec(b), x0=vec(z0), tol=1e-2)\n if info > 0:\n print('cgs convergence to tolerance not achieved')\n elif info <0:\n print('cgs gets illegal input or breakdown')\n z = np.reshape(z, x_shape, order='F')\n return z\n\n # initialize z and u\n z = compute_init(ATy, ATy)\n u = np.zeros(x_shape)\n\n\n plot_normalozer = matplotlib.colors.Normalize(vmin=0.0, vmax=1.0, clip=True)\n\n\n start_time = timeit.default_timer()\n\n for iter in range(max_iter):\n\n # x-update\n net_input = z+u\n Wzu, wbook = wavelet_transform(net_input)\n q = soft_threshold(Wzu, lambda_l1/alpha)\n x = inverse_wavelet_transform(q, wbook, x_shape)\n x = np.reshape(x, x_shape)\n\n # z-update\n b = ATy + alpha * (x - u)\n z = compute_p_inv_A(b, z)\n\n # u-update\n u += z - x;\n\n if show_img_progress == True:\n\n fig = plt.figure('current_sol')\n plt.gcf().clear()\n fig.canvas.set_window_title('iter %d' % iter)\n plt.subplot(1,3,1)\n plt.imshow(reshape_img_fun(np.clip(x, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\n plt.title('x')\n plt.subplot(1,3,2)\n plt.imshow(reshape_img_fun(np.clip(z, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\n plt.title('z')\n plt.subplot(1,3,3)\n plt.imshow(reshape_img_fun(np.clip(net_input, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\n plt.title('netin')\n plt.pause(0.00001)\n\n\n obj_ls = 0.5 * np.sum(np.square(y - A_fun(x)))\n x_z = np.sqrt(np.mean(np.square(x-z)))\n u_norm = np.sqrt(np.mean(np.square(u)))\n\n print('iter = %d: obj_ls = %.3e |x-z| = %.3e u_norm = %.3e' % (iter, obj_ls, x_z, u_norm))\n\n\n obj_lss[iter] = obj_ls\n x_zs[iter] = x_z\n u_norms[iter] = u_norm\n times[iter] = timeit.default_timer() - start_time\n\n if x_z < solver_tol:\n break\n\n infos = {'obj_lss': obj_lss, 'x_zs': x_zs, 'u_norms': u_norms,\n 'times': times, 'alpha':alpha, 'lambda_l1':lambda_l1,\n 'max_iter':max_iter, 'solver_tol':solver_tol}\n\n\n return (x, z, u, infos)","def arm_calibration(self):\n self.arm_motor.run_forever(speed_sp=900)\n while not self.touch_sensor.is_pressed:\n time.sleep(0.01)\n self.arm_motor.stop(stop_action=\"brake\")\n ev3.Sound.beep()\n self.arm_motor.run_to_rel_pos(\n speed_sp=900, position_sp=-5100)\n self.arm_motor.wait_while(ev3.Motor.STATE_RUNNING)\n print('motor is no longer running')\n ev3.Sound.beep()\n self.arm_motor.position = 0","def calibration(exp, args):\n show_text(\"Nous allons faire un calibrage\", args).present()\n exp.clock.wait(1500)\n expyriment.stimuli.FixCross(size=(25, 25),\n line_width=3,\n colour=args[\"stimuli_color\"]).present()\n exp.clock.wait(2100)","def _evolve(\n self,\n x0_idx: int,\n ) -> np.ndarray:\n x0 = self.starting_points[x0_idx, :]\n if type(x0) != np.ndarray:\n x0 = x0.toarray()\n x0 = x0.flatten()\n # [T, Dims, (Position, Velocity)]\n trajectory = np.zeros(\n (self.timesteps, x0.shape[0], 3), dtype=np.float32)\n \n # for each timestep, update the position of the phase point\n # based on the velocity of nearest neighbors and obey any\n # boundary constraints\n x = x0\n for t in range(self.timesteps):\n trajectory[t, :, 0] = x # match x position to dv/dx\n v = self.v_fxn(x=x.reshape(-1),)\n # add white noise if desired to better emulate a stochastic process\n noise = v[:, 1] * np.random.randn(v.shape[0]) * self.noise_scale\n x_new = x + (v[:, 0] + noise)*self.step_scale\n # constrain to a set of pre-defined boundaries\n # defaults to an identity if not set explicitly\n x_new = self.boundary_constraint(x_new)\n trajectory[t, :, 1] = v[:, 0]\n trajectory[t, :, 2] = v[:, 1]\n x = x_new\n return trajectory","def start_solving(self):\n self.mesh.output_vtk_mesh(self.model_name + \"0\", \n [self.current_pressure, \n self.mesh.get_cell_domain_all()], \n [\"pressure\", \"domain\"])\n\n self.time_step_output(0., 0)\n\n for time_step in range(1,self.number_of_time_steps+1):\n current_time = time_step*self.delta_t\n print(time_step)\n\n self.update_pressure()\n self.find_upwinding_direction()\n self.update_concentration()\n \n if time_step%self.output_frequency == 0:\n self.mesh.output_vtk_mesh(self.model_name+str(time_step), \n [self.current_pressure,\n self.current_concentration, \n self.mesh.get_cell_domain_all()],\n [\"pressure\", \"concentration\" , \"domain\"])\n\n self.time_step_output(current_time, time_step)","def step(self):\n #for the first step, we calculate only with the previous state\n if self.isFirstStep:\n F = (self.pot.f)(self.x, self.U)\n self.isFirstStep = False\n #else, we calculate with the previous step and the one before to keep the second order accuracy\n else:\n F = 3/2*(self.pot.f)(self.x, self.U)-1/2*(self.pot.f)(self.x, self.oldU)\n self.oldU = np.copy(self.U)\n C = self.B.dot(self.U)+self.dt*F\n C[0] = 0\n C[-1] = 0\n self.U = lin.solve_banded((1,1), self.A, C)","def calibration(N,kb,T,Ekinv,V):\n lamb = np.sqrt((N-1)*3*kb*T/(Ekinv*2))\n \n if lamb < 0.9999:\n V = lamb*V\n elif lamb>1.0001:\n V = lamb*V\n \n return V","def objective(trial):\n # The parameters that we will calibrate the model for are shown here.\n # Optuna trial i\n BOD = trial.suggest_uniform(\"BOD\", 0, 1) #Review ranges here\n k_r = trial.suggest_uniform(\"k_r\", 0, 1) #Review Ranges here \n \n def ChLa(t):\n return 1 # Need to link to data\n\n def I(x):\n return 1 # Need to link to data\n\n K_z = 2 * 10**(-5) # p.51\n a = K_z\n k_b = 0.1 # Table 5\n th_b = 1.047 # Table 5\n k_r = 0.1 # Table 5\n YCHO2 = 0.0083 # Table 5\n th_p = 1.036 # Table 5\n th_s = 1.065 # Table 5\n th_r = 1.047 # Table 5\n\n def Temp(t):\n \"\"\"\n Function that maps time to temperature\n \"\"\"\n return 20 # Need to link to data\n\n def P_max(t):\n return 9.6 * 1.036 **(Temp(t) - 20) # Eq. 4\n\n def L_min(t):\n I = 1 # Need to link to PAR data\n K_1 = 0.687 * 1.086**(Temp(t) - 20)\n K_2 = 15\n return I * (1 + 2 * np.sqrt(K_1 / K_2)) / (I + K_1 + I**2 / K_2) # Eq. 5\n \n # f deals with sink and source terms \n def f(x, t):\n return -1 / YCHO2 * k_r * th_r**(Temp(t) - 20) * ChLa(t) + P_max(t) * L_min(t) * ChLa(t) - k_b * th_b**(Temp(t)-20) * BOD \n\n L = 200 # Length of domain\n dt = 1 / 48 # Mesh spacing in t\n F = a * dt # a * dt / dx**2\n T = 100 # Simulation time stop\n\n # Solving the PDE\n DO, x, t, _ = solver_FE_simple(I, a, f, L, dt, F, T)\n \n # Creating some bogus targets while database errors are happening\n DO_data = DO + np.random.random(len(DO))\n\n # Using mean squared error as the measure of fit, where we want\n # to minimize this number\n return ((DO - DO_data)**2).mean()","def step_autocorrelation(self):\n\n max_hops = max([len(x) for x in self.steps])\n\n self.acf = np.zeros([len(self.steps), max_hops])\n\n keep = [] # list to hold indices of trajectories with a non-zero amount of hops\n for i in range(len(self.steps)):\n hops = self.steps[i]\n if len(hops) > 1:\n self.acf[i, :len(self.steps[i])] = timeseries.acf(self.steps[i])\n keep.append(i)\n\n self.acf = self.acf[keep, :]\n\n self.acf = np.array([self.acf[np.nonzero(self.acf[:, i]), i].mean() for i in range(max_hops)])\n\n #self.acf = timeseries.step_autocorrelation(self.z_interpolated.T[..., np.newaxis])","def ekf_algorithm(self, u, y):\n x_est_before = self.x_estimated_state\n cov_matrix_before = self.cov_matrix\n # 1. Prediction\n # predict the state by integrate the time continuous system numerically\n sim_state_predict = self.heliSim.calc_step(u[0][0], u[1][0], self.no_disturbance_eval)\n x_est_predict = np.resize(sim_state_predict, (8, 1))\n # predict the new covariance by linearizing and discretizing the model\n Ak, Bk, Ck, Dk = self.get_linear_discrete_matrices(x_est_before, u[0][0], u[1][0])\n cov_matrix_predict = Ak @ cov_matrix_before @ np.transpose(Ak) + Bk @ self.N @ np.transpose(Bk)\n # 2. Update\n # compute kalman gain\n Kl = cov_matrix_predict @ np.transpose(Ck) @ np.linalg.inv(Ck @ cov_matrix_predict @ np.transpose(Ck) + self.W)\n # update state\n y_est = np.concatenate((x_est_predict[0:3], x_est_predict[6:8]))\n x_est_update = x_est_predict + Kl @ (y - y_est)\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ Ck) @ cov_matrix_predict\n\n corrected_state = self.heliSim.get_limited_state_and_change_state(x_est_update.reshape((1, 8))[0],\n ModelType.GYROMOMENT)\n # corrected_state = x_est_update\n x_est_update = np.resize(corrected_state, (8, 1))\n\n self.x_estimated_state = x_est_update\n self.cov_matrix = cov_matrix_update\n # print(\"------\")\n # print(cov_matrix_predict)\n return x_est_update","def phase(self):\n pass","def F_cont(self):\n x0 = self.edp_par['x0'].value\n A = self.edp_par['A'].value\n f1 = self.edp_par['f1'].value\n f2 = self.edp_par['f2'].value\n lr = self.latt_par['lambda_r'].value\n w = 0.5 * (self.qx*x0 + self.qz*A)\n arg1 = 0.5*self.qx*lr + w\n arg2 = 0.5*self.qx*lr - w\n fir = x0 * np.sin(w) / lr / w\n sec = (lr-x0) * np.cos(0.5*arg1) * np.sin(arg2) / lr / np.cos(0.5*arg2) / arg2 \n #sec = (-1)**self.k * (lr-x0) * sin(self.k*pi-w)/(self.k*pi-w)/lr\n return (fir + f1*sec + 2*f2*np.cos(w)/lr)","def azizen(self):\n # x0,y0 array pixel coordinates relative to cx,cy\n# ndy0,ndx0=img.shape\n ndy0=self.ndy0\n ndx0=self.ndx0\n x0,y0=np.meshgrid(np.linspace(0,ndx0-1,ndx0)-self.cx,np.linspace(0,ndy0-1,ndy0)-self.cy)\n r0=np.sqrt(x0**2+y0**2)/self.pr0 # fractional radial distance from 0,0\n# self.roi=np.s_[ystart:ystart+self.ny0,xstart:xstart+self.nx0]\n # why not model the zenith angle dependence with polynomial directly\n # rather than linear interpolation between roots.\n roots=np.zeros(51)\n rr=np.arange(51)/100.0\n for i,ref in enumerate(rr):\n roots[i]=np.real(np.roots([self.c3,0,self.c2,0,self.c1,-ref])[-1])\n theta0 = np.interp(r0/2,rr,roots)\n \n phi0 = np.arctan2(x0,y0) - self.rot ####phi (i.e., azimuth) is reckoned with -pi corresponding to north, increasing clockwise, NOTE: pysolar use sub-standard definition\n phi0 = phi0%(2*np.pi)\n\n #####correction for the tilt of the camera\n k=np.array((np.sin(self.azm),np.cos(self.azm),0))\n a=np.array([np.sin(theta0)*np.cos(phi0),np.sin(theta0)*np.sin(phi0),np.cos(theta0)]); \n a = np.transpose(a,[1,2,0])\n b=np.cos(self.beta)*a + np.sin(self.beta)*np.cross(k,a,axisb=2) \\\n + np.reshape(np.outer(np.dot(a,k),k),(self.ndy0,self.ndx0,3))*(1-np.cos(self.beta))\n theta0=np.arctan(np.sqrt(b[:,:,0]**2+b[:,:,1]**2)/b[:,:,2])\n phi0=np.arctan2(b[:,:,1],b[:,:,0])%(2*np.pi)\n# max_theta *= deg2rad \n# valid0 = (theta0<max_theta) & (theta0>0); \n# theta0[valid0]=np.nan;\n self.theta0,self.phi0=theta0,phi0","def on_iteration_start(self):\n\n self.Xfprv = self.Xf.copy()\n if (not self.opt['FastSolve'] or isinstance(self.backtrack,\n BacktrackRobust)):\n self.Yfprv = self.Yf.copy()\n\n if self.opt['Monotone']:\n if self.k == 0:\n self.objfn = self.eval_objfn()\n self.objfn_prev = self.objfn","def reconstruct(self):\n self.print_tee(\"starting reconstruction\", self.log_file)\n\n # #############################################\n # estimate SIM parameters\n # #############################################\n # estimate frequencies\n tstart = time.time() # since done using joblib, process_time() is not useful...\n\n if self.use_fixed_frq:\n self.frqs = self.frqs_guess\n self.print_tee(\"using fixed frequencies\", self.log_file)\n else:\n if self.find_frq_first:\n self.frqs = self.estimate_sim_frqs(self.imgs_ft, self.imgs_ft, self.frqs_guess)\n else:\n self.print_tee(\"doing phase demixing prior to frequency finding\", self.log_file)\n self.separated_components_ft = separate_components(self.imgs_ft, self.phases_guess, np.ones((self.nangles, self.nphases)))\n imgs1 = np.expand_dims(self.separated_components_ft[:, 0], axis=1)\n imgs2 = np.expand_dims(self.separated_components_ft[:, 1], axis=1)\n self.frqs = self.estimate_sim_frqs(imgs1, imgs2, self.frqs_guess)\n\n tend = time.time()\n self.print_tee(\"fitting frequencies took %0.2fs\" % (tend - tstart), self.log_file)\n\n # estimate phases\n tstart = time.process_time()\n if self.use_fixed_phase:\n self.phases = self.phases_guess\n self.amps = np.ones((self.nangles, self.nphases))\n self.print_tee(\"Using fixed phases\", self.log_file)\n else:\n self.phases, self.amps = self.estimate_sim_phases(self.frqs, self.phases_guess)\n\n tend = time.process_time()\n self.print_tee(\"estimated %d phases in %0.2fs\" % (self.nangles * self.nphases, tend - tstart), self.log_file)\n\n # separate components\n self.separated_components_ft = separate_components(self.imgs_ft, self.phases, self.amps)\n\n # estimate modulation depths and power spectrum fit parameters\n tstart = time.process_time()\n # for the moment, need to do this feet even if have fixed mod depth, because still need the\n # power spectrum parameters\n self.mod_depths, self.power_spectrum_params, self.pspec_masks = self.estimate_mod_depths()\n\n if self.use_fixed_mod_depths:\n self.mod_depths = np.zeros((self.nangles, self.nphases))\n self.mod_depths[:, 0] = 1\n for jj in range(1, self.nphases):\n self.mod_depths[:, jj] = self.mod_depths_guess\n\n # also correct power spectrum params\n self.power_spectrum_params[:, jj, 2] = self.mod_depths[:, jj]\n\n tend = time.process_time()\n self.print_tee('estimated %d modulation depths in %0.2fs' % (self.nangles, tend - tstart), self.log_file)\n\n # #############################################\n # estimate modulation contrast to noise ratio for raw images\n # #############################################\n mcnr = np.zeros((self.nangles, self.nphases))\n for ii in range(self.nangles):\n for jj in range(self.nphases):\n mcnr[ii, jj] = get_mcnr(self.imgs_ft[ii, jj], self.frqs[ii], self.fx, self.fy, self.fmax)\n\n # if mcnr is too low (typically < 1), use guess values instead\n if self.default_to_guess_on_low_mcnr and np.min(mcnr[ii]) < self.min_mcnr and self.frqs_guess is not None:\n self.frqs[ii] = self.frqs_guess[ii]\n self.print_tee(\"Angle %d/%d, minimum mcnr = %0.2f is less than the minimum value, %0.2f,\"\n \" so fit frequency will be replaced with guess\"\n % (ii + 1, self.nangles, np.min(mcnr[ii]), self.min_mcnr), self.log_file)\n\n for jj in range(self.nphases):\n mcnr[ii, jj] = get_mcnr(self.imgs_ft[ii, jj], self.frqs[ii], self.fx, self.fy, self.fmax)\n\n self.mcnr = mcnr\n # for convenience, also save periods and angles\n self.periods = 1 / np.sqrt(self.frqs[:, 0] ** 2 + self.frqs[:, 1] ** 2)\n self.angles = np.angle(self.frqs[:, 0] + 1j * self.frqs[:, 1])\n\n # #############################################\n # estimate noise in component images\n # #############################################\n self.noise_power = self.power_spectrum_params[:, :, -1]\n\n # #############################################\n # SIM reconstruction\n # #############################################\n tstart = time.process_time()\n self.img_sr, self.img_sr_ft, self.components_deconvolved_ft, self.components_shifted_ft, \\\n self.weights, self.weight_norm, self.snr, self.snr_shifted = self.combine_components()\n # self.img_sr, self.img_sr_ft, self.components_deconvolved_ft, self.components_shifted_ft, \\\n # self.weights, self.weight_norm, self.snr, self.snr_shifted = self.combine_components_fairSIM()\n tend = time.process_time()\n\n self.print_tee(\"combining components took %0.2fs\" % (tend - tstart), self.log_file)\n\n # #############################################\n # widefield deconvolution\n # #############################################\n # get signal to noise ratio\n wf_noise = get_noise_power(self.widefield_ft, self.fx, self.fy, self.fmax)\n fit_result, self.mask_wf = fit_power_spectrum(self.widefield_ft, self.otf, self.fx, self.fy, self.fmax, self.fbounds,\n init_params=[None, self.power_spectrum_params[0, 0, 1], 1, wf_noise],\n fixed_params=[False, True, True, True])\n\n self.pspec_params_wf = fit_result['fit_params']\n ff = np.sqrt(self.fx[None, :]**2 + self.fy[:, None]**2)\n sig = power_spectrum_fn([self.pspec_params_wf[0], self.pspec_params_wf[1], self.pspec_params_wf[2], 0], ff, 1)\n wf_snr = sig / wf_noise\n # deconvolution\n wf_decon_ft, wfilter = wiener_deconvolution(self.widefield_ft, self.otf, wf_snr, snr_includes_otf=False)\n\n # upsample to make fully comparable to reconstructed image\n self.widefield_deconvolution_ft = tools.expand_fourier_sp(wf_decon_ft, 2, 2, centered=True)\n self.widefield_deconvolution = fft.fftshift(fft.ifft2(fft.ifftshift(self.widefield_deconvolution_ft))).real\n\n # #############################################\n # print parameters\n # #############################################\n self.print_parameters()\n\n try:\n self.log_file.close()\n except AttributeError:\n pass","def calibrate(\n self, acc: np.ndarray, gyr: np.ndarray, acc_unit: Optional[str], gyr_unit: Optional[str]\n ) -> Tuple[np.ndarray, np.ndarray]:\n raise NotImplementedError(\"This method needs to be implemented by a subclass\")","def solve(self, solver):\n solver.solve()","def getCalibration(self):\n self.a0 = float(self.getParameter(index=1))\n self.a1 = float(self.getParameter(index=2))\n self.a2 = float(self.getParameter(index=3))\n self.a3 = float(self.getParameter(index=4))\n status = self.getStatus()\n self.wavelength = [ self.a0 + self.a1*x + self.a2*x*x + self.a3*x*x*x \n for x in range(status.pixels)]\n if self.discardTrailingSamples > 0:\n self.wavelength = self.wavelength[:-self.discardTrailingSamples]\n if self.discardLeadingSamples > 0:\n self.wavelength = self.wavelength[self.discardLeadingSamples:]","def calibrate(self, position):\n current_position = self.robot._driver.get_plunger_positions()\n current_position = current_position['target'][self.axis]\n kwargs = {}\n kwargs[position] = current_position\n self.calibrate_plunger(**kwargs)\n\n return self","def _finish_calibration(self, objpoints, imgpoints_l, imgpoints_r, shape):\n left_camera = self.source._left._finish_calibration(objpoints, imgpoints_l, shape)\n right_camera = self.source._right._finish_calibration(objpoints, imgpoints_r, shape)\n\n ret, M1, d1, M2, d2, R, T, E, F = cv2.stereoCalibrate(\n objpoints,\n imgpoints_l, imgpoints_r,\n left_camera.matrix, left_camera.distortion,\n right_camera.matrix, right_camera.distortion,\n shape,\n criteria=self._stereocalib_criteria, flags=self._flags)\n\n R1, R2, P1, P2, Q, vb1, vb2 = cv2.stereoRectify(\n M1,\n d1,\n M2,\n d2,\n shape,\n R,\n T,\n flags=cv2.CALIB_ZERO_DISPARITY)\n\n left_camera = PinholeCamera(shape, M1, d1, R1, P1)\n right_camera = PinholeCamera(shape, M2, d2, R2, P2)\n\n return StereoCamera(left_camera, right_camera, R, T, E, F, Q)","def ekf_algorithm(self, u, y):\n x_est_before = self.x_estimated_state\n cov_matrix_before = self.cov_matrix\n # 1. Prediction\n # predict the state by integrate the time continuous system numerically\n sim_state_predict = self.heliSim.calc_step(u[0][0], u[1][0], self.no_disturbance_eval)\n x_est_predict = np.resize(sim_state_predict, (6, 1))\n # predict the new covariance by linearizing and discretizing the model\n Ak, Bk, Ck, Dk = self.get_linear_discrete_matrices(x_est_before, u[0][0], u[1][0])\n cov_matrix_predict = Ak @ cov_matrix_before @ np.transpose(Ak) + Bk @ self.N @ np.transpose(Bk)\n # 2. Update\n # compute kalman gain\n Kl = cov_matrix_predict @ np.transpose(Ck) @ np.linalg.inv(Ck @ cov_matrix_predict @ np.transpose(Ck) + self.W)\n # update state\n y_est = x_est_predict[0:3, ]\n x_est_update = x_est_predict + Kl @ (y - y_est)\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ Ck) @ cov_matrix_predict\n\n # check if the update step state needs to be changed because of limit crossing\n # if that is the case, correct the state and set the state of the simulation accordingly\n # heliSim_state = np.resize(x_est_update, (1, 6))[0]\n # heliSim_state = np.pad(heliSim_state, (0, 2), \"constant\")\n corrected_state = self.heliSim.get_limited_state_and_change_state(x_est_update.reshape((1, 6))[0],\n ModelType.EASY)\n x_est_update = np.resize(corrected_state, (6, 1))\n\n self.x_estimated_state = x_est_update\n self.cov_matrix = cov_matrix_update\n return x_est_update","def rm_calibration(self):\n\n self.bin_edges_kev = None","def calibrate(this, display=False, **kargs): # C'est des maths.\n\t\t# a -> Angle Alpha\n\t\t# b -> Angle Beta\n\t\t\n\t\th = float(kargs.get('h', 1))\n\t\tw = float(kargs.get('w', 1))\n\t\t\n\t\t# Verif de l'espace\n\t\tspace = this._SPACE\n\t\tif not space: return None\n\t\t\n\t\t#try:\n\t\ttry:\n\t\t\n\t\t\t# Calcul d'angles\n\t\t\ta = this._FOV.x * (space.i - space.o)\n\t\t\tb = this._FOV.x * (space.o - space.j)\n\t\t\n\t\t\t# On essaye gentillement\n\t\t\tCa = w - h / math.tan(b)\n\t\t\tCb = h - w / math.tan(a)\n\t\t\tkx = Ca/Cb\n\t\t\t\n\t\t\t# Position finale\n\t\t\tthis._POS.x = x = h * (kx + 1 / math.tan(b)) / (1 + kx**2)\n\t\t\tthis._POS.y = x * kx\n\t\t\n\t\t# Erm\n\t\texcept: this._POS = None\n\t\t\n\t\t# Petit affichage oklm\n\t\tif display: print 'Calibration: %f %f %s' % (math.degrees(a), math.degrees(b), ~this._POS)\n\t\treturn this._POS","def __init__(self, dev, **kw):\n AutomaticCalibrationRoutine.__init__(\n self,\n dev=dev,\n **kw,\n )\n\n self.final_init(**kw)","def solve(self, regparam):\n self.regparam = regparam\n \n #Some counters for bookkeeping\n self.stepcounter = 0\n self.flipcounter = 0\n self.nochangecounter = 0\n \n #Cached results\n self.evals = np.multiply(self.svals, self.svals)\n self.newevals = 1. / (self.evals + self.regparam)\n newevalslamtilde = np.multiply(self.evals, self.newevals)\n self.D = np.sqrt(newevalslamtilde)\n #self.D = -newevalslamtilde\n \n self.VTY = self.svecs.T * self.Y\n DVTY = np.multiply(self.D.T, self.svecs.T * self.Y)\n \n #Using lists in order to avoid unnecessary matrix slicings\n self.DVTY_list = []\n self.YTVDDVTY_list = []\n self.classFitnessList = []\n for i in range(self.labelcount):\n DVTY_i = DVTY[:,i]\n self.DVTY_list.append(DVTY_i)\n YTVDDVTY_i = DVTY_i.T * DVTY_i\n self.YTVDDVTY_list.append(YTVDDVTY_i)\n fitness_i = self.size - DVTY_i.T * DVTY_i\n self.classFitnessList.append(fitness_i)\n \n self.Dsvecs_list = []\n self.svecsDDsvecs_list = []\n for i in range(self.size):\n Dsvec = np.multiply(self.D.T, self.svecs[i].T)\n self.Dsvecs_list.append(Dsvec)\n self.svecsDDsvecs_list.append(Dsvec.T*Dsvec)\n \n self.updateA()\n \n \n converged = False\n print(self.classcounts.T)\n if self.callbackfun is not None:\n self.callbackfun.callback(self)\n while True:\n \n converged = self.roundRobin()\n print(self.classcounts.T)\n if self.callbackfun is not None:\n self.callbackfun.callback(self)\n if converged: break\n \n if self.oneclass:\n self.Y = self.Y[:, 0]\n self.A = self.A[:, 0]\n self.results['predicted_clusters_for_training_data'] = self.Y\n self.predictor = self.svdad.createModel(self)","def initialise_calibration(self):\n for i in range(0, self.NUM_SENSORS):\n self.calibratedMax[i] = 0\n self.calibratedMin[i] = self.READING_TIMEOUT","def _solve(self) -> CasADiArrayType:\n\n # Setup solver\n self.m = osqp.OSQP()\n self.m.setup(**self._setup_input)\n\n # Warm start optimization\n if self.use_warm_start:\n self.m.warm_start(x=self.x0.toarray().flatten())\n\n # Solve problem\n self._solution = self.m.solve()\n\n return self._solution.x"],"string":"[\n \"def _doCalibration(self):\\n self._cmdCalibration(2)\",\n \"def photometric_calibration():\\n pass\",\n \"def calibration(self) -> int:\",\n \"def calibration_wheel(self):\\n self.spectrum = self.spectrum\",\n \"def calibration(self, cal: int, /) -> None:\",\n \"def calibrate(self, master):\\n if master.polyorder == 'linear':\\n self.fitfunction = \\\"A0 + A1 * D\\\"\\n self.fit_fkt = self.calc_lin\\n elif master.polyorder == 'quadratic':\\n self.fit_fkt = self.calc_quad\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2\\\"\\n elif master.polyorder == \\\"cubic\\\":\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2 + A3 * D**3\\\"\\n self.fit_fkt = self.calc_cubic\\n else:\\n print(\\\"Polynomgrad nicht definiert\\\")\\n \\n self.mw = np.asarray(self.mw)\\n if master.sensortype == \\\"Druck\\\":\\n self.best, self.covar = curve_fit(self.fit_fkt, self.mw, master.Referencedata.caldat)\\n else:\\n print(\\\"Sensortyp noch nicht Hinterlegt\\\")\",\n \"def calibrate(self):\\n with completion_context(\\\"Estimating sensor offset\\\", color=\\\"c\\\", bright=True):\\n # Reset calibration\\n self._sens_offset = np.zeros(4) # last two entries are never calibrated but useful for broadcasting\\n self._wait_for_pole_at_rest()\\n\\n # Create parts of the calibration controller\\n go_right = QQubeGoToLimCtrl(positive=True, cnt_done=int(1.5 / self._dt))\\n go_left = QQubeGoToLimCtrl(positive=False, cnt_done=int(1.5 / self._dt))\\n go_center = QQubePDCtrl(self.spec)\\n\\n # Estimate alpha offset. Go to both limits for theta calibration.\\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\\n while not go_right.done:\\n meas = self._qsoc.snd_rcv(go_right(to.from_numpy(meas)))\\n while not go_left.done:\\n meas = self._qsoc.snd_rcv(go_left(to.from_numpy(meas)))\\n self._sens_offset[0] = (go_right.th_lim + go_left.th_lim) / 2\\n\\n # Estimate alpha offset\\n self._wait_for_pole_at_rest()\\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\\n self._sens_offset[1] = meas[1]\\n\\n print_cbt(\\n f\\\"Sensor offset: \\\"\\n f\\\"theta = {self._sens_offset[0]*180/np.pi:.3f} deg, \\\"\\n f\\\"alpha = {self._sens_offset[1]*180/np.pi:.3f} deg\\\",\\n \\\"g\\\",\\n )\\n\\n with completion_context(\\\"Centering cube\\\", color=\\\"c\\\", bright=True):\\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\\n while not go_center.done:\\n meas = self._qsoc.snd_rcv(go_center(to.from_numpy(meas - self._sens_offset)))\",\n \"def _calibrate(self, Otrain, Ftrain, Feval):\\n raise NotImplementedError()\",\n \"def arm_calibration(self):\\n self.arm_motor.run_forever(speed_sp=self.MAX_SPEED)\\n while not self.touch_sensor.is_pressed:\\n time.sleep(0.01)\\n self.arm_motor.stop()\\n ev3.Sound.beep().wait()\\n arm_revolutions_for_full_range = 14.2 * 360\\n self.arm_motor.run_to_rel_pos(\\n position_sp=-arm_revolutions_for_full_range,\\n speed_sp=self.MAX_SPEED,\\n stop_action=ev3.Motor.STOP_ACTION_BRAKE)\\n self.arm_motor.wait_while(ev3.Motor.STATE_RUNNING)\\n\\n self.arm_motor.position = 0 # Calibrate the down position as 0 (this\\n # line is correct as is).\",\n \"def calibrate(self):\\n\\t\\tLTOGRIGHT = []\\n\\t\\tLTOGUP = []\\n\\t\\tRTOGRIGHT = []\\n\\t\\tRTOGUP = []\\n\\t\\tstart = time.time()\\n\\t\\tcalibration_time = 5.0\\n\\t\\twhile time.time() - start < calibration_time:\\n\\t\\t\\tevents = pygame.event.get()\\n\\t\\t\\tfor event in events:\\n\\t\\t\\t\\tif event.type == pygame.JOYAXISMOTION:\\n\\t\\t\\t\\t\\tLTOGRIGHT.append(self.joystick.get_axis(self.LTOGRIGHT))\\n\\t\\t\\t\\t\\tLTOGUP.append(-self.joystick.get_axis(self.LTOGUP))\\n\\t\\t\\t\\t\\tRTOGRIGHT.append(self.joystick.get_axis(self.RTOGRIGHT))\\n\\t\\t\\t\\t\\tRTOGUP.append(-self.joystick.get_axis(self.RTOGUP))\\n\\n\\t\\t# calibration sets highest value equal to 1.0\\n\\t\\tself.calibration[0] = 1.0/max(LTOGRIGHT)\\n\\t\\tself.calibration[1] = -1.0/min(LTOGRIGHT)\\n\\t\\tself.calibration[2] = -1.0/min(LTOGUP)\\n\\t\\tself.calibration[3] = 1.0/max(LTOGUP)\\n\\t\\tself.calibration[4] = 1.0/max(RTOGRIGHT)\\n\\t\\tself.calibration[5] = -1.0/min(RTOGRIGHT)\\n\\t\\tself.calibration[6] = -1.0/min(RTOGUP)\\n\\t\\tself.calibration[7] = 1.0/max(RTOGUP)\",\n \"def do_calibration(self):\\n goal = CalculateParametersGoal()\\n self.calibrate_client.send_goal(goal)\\n self.calibrate_client.wait_for_result()\\n result = self.calibrate_client.get_result()\\n rospy.loginfo('Received the calibration results')\\n if result.number_of_images is 0:\\n rospy.logerr('Failed to calibrate the camera.')\\n else:\\n rospy.loginfo('Number of pictures: {}, error: {}'.format(result.number_of_images, result.error))\\n self.save_calibration_parameters(result.intrinsics, result.error, result.number_of_images)\",\n \"def calibration(self, pulse_min: int, pulse_max: int, pulse_centre: int, /) -> None:\",\n \"def run_calib(projector=OPTOMA_HD33()):\\n w, h = (0.2160, 0.2794)\\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\\n [-w/2, 0, 0], [w/2, 0, 0],\\n [-w/2, 0, h/2], [w/2, 0, h/2]])\\n\\n global img_points, going\\n img_points = []\\n\\n try:\\n window = Window()\\n window.MoveXY(1600,0)\\n window.ShowFullScreen(True)\\n going = True\\n\\n @window.eventx\\n def EVT_MOUSE_EVENTS(evt):\\n global going, img_points\\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\\n img_points.append(evt.Position)\\n print('Picked point %d of 6' % (len(img_points)))\\n if len(img_points) == len(obj_points):\\n print \\\"Done\\\"\\n going = False\\n\\n print(\\\"\\\"\\\"[Extrinsic Calibration] \\n\\nThere should be 6 points marked on the table and backdrop. \\nMoving the mouse over the projected display, click each of the points\\nin order:\\n (left top, on the backdrop),\\n (right top, on the backdrop),\\n (left center, on the crease),\\n (right center, on the crease),\\n (left bottom, on the table),\\n (right bottom, on the table)\\n\\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\\n\\nClick the six points:\\n\\\"\\\"\\\")\\n\\n while going: cv.WaitKey(10)\\n\\n finally:\\n window.Close()\\n\\n img_points = np.array(img_points, 'f')\\n projector.calibrate_extrinsic(img_points, obj_points)\\n\\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\\n print('OK')\",\n \"def calibrate(): \\n \\n # Calibrate of the run using beam data. Creates a folder cal-files/caltag \\n # containing all calibration data. \\n CalObj = Calibration(steerfiles=steerfiles, name=localcaltag + '-cal') \\n\\n # Set Beam energy\\n CalObj.set_beam_momentum(beamenergy)\\n\\n # Get gearfile and set air as DUT material\\n localgearfile = CalObj.get_filename('gear.xml')\\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='thickness', value=0.0001)\\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='radLength', value=304000.0)\\n \\n # Create list of calibration steps \\n calpath = create_calibration_path(CalObj)\\n \\n # Run the calibration steps \\n CalObj.calibrate(path=calpath,ifile=rawfile_air,caltag=localcaltag)\",\n \"def steering_calibration(self):\\n\\n # Minimum change of rotary encoder per 100 ms to detect stall\\n min_difference = 5\\n # Calibration motor power in percentage (absolute)\\n calibration_power = 30\\n\\n print('Calibration of steering axis started')\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n last_pos = 99999999 # any super big number\\n # Left turn calibration\\n while abs(current_pos - last_pos) > min_difference:\\n last_pos = current_pos\\n self.brick_pi.set_motor_power(self.motor_steer, calibration_power)\\n time.sleep(0.1)\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n\\n self.brick_pi.set_motor_power(self.motor_steer, 0)\\n time.sleep(0.1)\\n print('Reset motor encoder after left turn: 0')\\n self.brick_pi.reset_motor_encoder(self.motor_steer)\\n\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n last_pos = 99999999 # any super big number\\n # Right turn calibration\\n while abs(current_pos - last_pos) > min_difference:\\n last_pos = current_pos\\n self.brick_pi.set_motor_power(self.motor_steer, -calibration_power)\\n time.sleep(0.1)\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n\\n self.brick_pi.set_motor_power(self.motor_steer, 0)\\n time.sleep(0.1)\\n self.brick_pi.offset_motor_encoder(self.motor_steer, current_pos / 2)\\n self.steering_limit = abs(\\n self.brick_pi.get_motor_encoder(self.motor_steer))\\n print('Offset motor encoder after right turn: ' +\\n str(self.brick_pi.get_motor_encoder(self.motor_steer)))\\n\\n self.brick_pi.set_motor_position(self.motor_steer, 0)\\n print('Calibration of steering axis completed')\",\n \"def _applyCalibration(self, ws, detPos):\\n alg = self.createChildAlgorithm('ApplyCalibration')\\n alg.setProperty('Workspace', ws)\\n alg.setProperty('PositionTable', detPos)\\n alg.execute()\",\n \"def arm_calibration(self):\\n # DONE: 3. Implement the arm calibration movement by fixing the code below (it has many bugs). It should to this:\\n # Command the arm_motor to run forever in the positive direction at max speed.\\n # Create an infinite while loop that will block code execution until the touch sensor's is_pressed value is True.\\n # Within that loop sleep for 0.01 to avoid running code too fast.\\n # Once past the loop the touch sensor must be pressed. So stop the arm motor quickly using the brake stop action.\\n # Make a beep sound\\n # Now move the arm_motor 14.2 revolutions in the negative direction relative to the current location\\n # Note the stop action and speed are already set correctly so we don't need to specify them again\\n # Block code execution by waiting for the arm to finish running\\n # Make a beep sound\\n # Set the arm encoder position to 0 (the last line below is correct to do that, it's new so no bug there)\\n\\n # Code that attempts to do this task but has MANY bugs (nearly 1 on every line). Fix them!\\n self.arm_motor.run_forever(speed_sp=900)\\n while not self.touch_sensor.is_pressed:\\n time.sleep(0.01)\\n self.arm_motor.stop(stop_action='brake')\\n ev3.Sound.beep().wait()\\n # time.sleep(2)\\n # arm_motor.stop(stop_action='brake')\\n\\n arm_revolutions_for_full_range = 14.2 * 360\\n self.arm_motor.run_to_rel_pos(position_sp=-arm_revolutions_for_full_range, speed_sp=900)\\n self.arm_motor.wait_while(ev3.Motor.STATE_RUNNING)\\n ev3.Sound.beep()\\n self.arm_motor.position = 0 # Calibrate the down position as 0 (this line is correct as is).\",\n \"def calibration(\\n self,\\n pulse_min: int,\\n pulse_max: int,\\n pulse_centre: int,\\n pulse_angle_90: int,\\n pulse_speed_100: int,\\n /,\\n ) -> None:\",\n \"def solve_prep(self):\\n\\n par = self.par\\n sol = self.sol\\n\\n # a. retirement\\n sol.m_ret = np.zeros((par.T,par.Nm_ret))\\n sol.c_ret = np.zeros((par.T,par.Nm_ret))\\n sol.a_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_v_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vm_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vn_ret = np.zeros((par.T,par.Nm_ret))\\n\\n # b. working\\n if par.solmethod == 'G2EGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.ucon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.dcon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.acon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.z = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n \\n elif par.solmethod == 'NEGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((0,0,0))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((0,0,0))\\n \\n sol.c_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\\n sol.inv_v_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\",\n \"def __call__(self, data):\\n cal = self.calc()\\n assert data.shape == cal.shape, \\\\\\n \\\"data shape does not match calibration ({} != {})\\\".format(data.shape, cal.shape)\\n return data * cal\",\n \"def recalibrate_start(self):\\n self.epoch += 1\\n self.initialize()\\n self.recalibration_i = 0\\n\\n if self.vr_from_epoch is not None and self.epoch >= self.vr_from_epoch:\\n for group in self.param_groups:\\n for p in group['params']:\\n param_state = self.state[p]\\n param_state['gavg'].zero_()\\n param_state['m2'].zero_()\\n\\n # xk is changed to the running_x\\n p.data.zero_().add_(param_state['running_x'])\\n param_state['tilde_x'] = p.data.clone()\",\n \"def calibrate(self, x, y) -> None:\\n pass\",\n \"def calibrer(self):\\n self._angle_courant = self._angle_initial\\n self.angle(self._angle_initial)\",\n \"def calibrate(self):\\n\\n self.update_message('Calibrating platform...')\\n\\n self.calibrate_platform()\\n\\n self.update_message('Platform Calibrated.')\\n\\n # calibrate arm x axis\\n self.update_message('Calibrating x axis...')\\n calibrated = self.calibrate_arm(0)\\n\\n if not calibrated:\\n self.update_message('ERROR: Could not calibrate x axis.')\\n return 0\\n else:\\n self.update_message('x axis calibrated.')\\n\\n # calibrate arm y axis\\n self.update_message('Calibrating y axis...')\\n calibrated = self.calibrate_arm(1)\\n\\n if not calibrated:\\n self.update_message('ERROR: Could not calibrate y axis.')\\n return 0\\n else:\\n self.update_message('y axis calibrated.')\\n\\n # calibrate arm z axis\\n self.update_message('Calibrating z axis...')\\n calibrated = self.calibrate_arm(2)\\n\\n if not calibrated:\\n self.update_message('ERROR: Could not calibrate z axis.')\\n return 0\\n else:\\n self.update_message('z axis calibrated.\\\\n'\\n 'Autocalibration done.\\\\n'\\n 'Accuracy: {}'.format(self.matrix_accuracy()))\\n\\n # Getting the direction to withdraw pipette along x axis\\n self.get_withdraw_sign()\\n self.inv_mat = np.linalg.inv(self.mat)\\n self.calibrated = 1\\n self.cam.click_on_window = True\\n self.save_calibration()\\n return 1\",\n \"def _RunCalibration(self, graph_key, gdef, input_data, config):\\n return self._RunGraph(graph_key, gdef, input_data, config, 30)\",\n \"def proz(): \\r\\n print(\\\"processing: \\\",CURDATA()[0]) \\r\\n Check_180turn(left_boundary,right_boundary)\\r\\n EF() #exponential window multiplication + fourier\\r\\n APK0() #1. Phase correction 0th Ordnung\\r\\n APK1() #1. Phase correction 1st Ordnung\\r\\n ABS() #Baseline correction\\r\\n APK()\\r\\n ABS() #Baseline correction\\r\\n Check_180turn(left_boundary,right_boundary)\",\n \"def apply_calibration(self, cal):\\n\\n n_edges = len(self.channels) + 1\\n channel_edges = np.linspace(-0.5, self.channels[-1] + 0.5, num=n_edges)\\n self.bin_edges_kev = cal.ch2kev(channel_edges)\",\n \"def calibrate(self):\\n if self.iCAL_required:\\n logger.info(\\\"iCAL-sensitive registers were modified, performing calibration...\\\")\\n return self._run_ical()\\n else:\\n logger.info(\\\"iCAL-sensitive registers were not modified, skipping calibration...\\\")\\n return 0 # Still success\",\n \"def full_calibration(\\n cal: Calibration,\\n ref_pts: np.ndarray,\\n img_pts: TargetArray,\\n cparam: ControlPar,\\n flags: list = [],\\n):\\n # cdef:\\n # vec3d *ref_coord\\n # np.ndarray[ndim=2, dtype=pos_t] ret\\n # np.ndarray[ndim=1, dtype=np.int_t] used\\n # np.ndarray[ndim=1, dtype=pos_t] err_est\\n # orient_par *orip\\n # double *residuals\\n\\n ref_pts = np.ascontiguousarray(ref_pts)\\n ref_coord = ref_pts.data\\n\\n # Load up the orientation parameters. Silly, but saves on defining\\n # a whole new class for what is no more than a list.\\n\\n orip = OrientPar()\\n orip.useflag = 0\\n orip.ccflag = 1 if \\\"cc\\\" in flags else 0\\n orip.xhflag = 1 if \\\"xh\\\" in flags else 0\\n orip.yhflag = 1 if \\\"yh\\\" in flags else 0\\n orip.k1flag = 1 if \\\"k1\\\" in flags else 0\\n orip.k2flag = 1 if \\\"k2\\\" in flags else 0\\n orip.k3flag = 1 if \\\"k3\\\" in flags else 0\\n orip.p1flag = 1 if \\\"p1\\\" in flags else 0\\n orip.p2flag = 1 if \\\"p2\\\" in flags else 0\\n orip.scxflag = 1 if \\\"scale\\\" in flags else 0\\n orip.sheflag = 1 if \\\"shear\\\" in flags else 0\\n orip.interfflag = 0 # This also solves for the glass, I'm skipping it.\\n\\n err_est = np.empty((NPAR + 1), dtype=np.float64)\\n residuals = orient(\\n cal, cparam, len(ref_pts), ref_coord, img_pts, orip, err_est.data\\n )\\n\\n # free(orip)\\n\\n if residuals is None:\\n # free(residuals)\\n raise ValueError(\\\"Orientation iteration failed, need better setup.\\\")\\n\\n ret = np.empty((len(img_pts), 2))\\n used = np.empty(len(img_pts), dtype=np.int_)\\n\\n for ix, img_pt in enumerate(img_pts):\\n ret[ix] = (residuals[2 * ix], residuals[2 * ix + 1])\\n used[ix] = img_pt.pnr\\n\\n # free(residuals)\\n return ret, used, err_est\",\n \"def solve_and_apply_ensemble(self, save_datapack, ant_idx, time_idx, dir_idx, freq_idx, iterations,\\n interval, shift, init_solutions = None, num_threads=1,verbose=False,\\n model_kwargs = {}):\\n if init_solutions is not None:\\n data = np.load(init_solutions)\\n\\n kern_ls = data['kern_ls']\\n kern_var = data['kern_var']\\n kern_times = data['time']\\n kern_antenna_labels = data['antenna']\\n\\n \\n datapack = self.datapack\\n directions, patch_names = datapack.get_directions(dir_idx)\\n times,timestamps = datapack.get_times(time_idx)\\n antennas,antenna_labels = datapack.get_antennas(ant_idx)\\n freqs = datapack.get_freqs(freq_idx)\\n\\n if ant_idx is -1:\\n ant_idx = range(len(antennas))\\n if time_idx is -1:\\n time_idx = range(len(times))\\n if freq_idx is -1:\\n freq_idx = range(len(freqs))\\n if dir_idx is -1:\\n dir_idx = range(len(directions))\\n \\n\\n phase = datapack.get_phase(ant_idx,time_idx,dir_idx,freq_idx)\\n Na,Nt,Nd,Nf = phase.shape\\n logging.warning(\\\"Working on shapes {}\\\".format(phase.shape))\\n \\n if interval is None:\\n interval = Nt\\n\\n assert interval <= Nt\\n\\n variance = datapack.get_variance(ant_idx,time_idx,dir_idx,freq_idx)\\n error = np.sqrt(variance)\\n data_mask = variance < 0\\n error[data_mask] = -1\\n logging.warning(\\\"Total masked phases: {}\\\".format(np.sum(data_mask)))\\n\\n enu = ENU(obstime=times[0],location = self.datapack.radio_array.get_center())\\n \\n ant_enu = antennas.transform_to(enu)\\n x = np.array([ant_enu.east.to(au.km).value, ant_enu.north.to(au.km).value]).T\\n t = times.mjd*86400.#mjs\\n d = np.array([directions.ra.deg, directions.dec.deg]).T\\n f = freqs\\n \\n lock = Lock()\\n with futures.ThreadPoolExecutor(max_workers=num_threads) as executor:\\n jobs = []\\n\\n for j,aj in enumerate(time_idx[::shift]):\\n start = j*shift\\n stop = min(start+interval,Nt)\\n time_slice = slice(start,stop,1)\\n \\n# if init_solutions is not None:\\n# ###\\n# # interpolate kern_params with this interval/shift\\n# mean_time = np.mean(times.gps[time_slice])\\n\\n# model_kwargs['ls_init'] = (\\n# np.interp(mean_time, kern_times, kern_ls[ant_idx,:,1].mean(0)),\\n# np.interp(mean_time, kern_times, kern_ls[ant_idx,:,0].mean(0))\\n# )\\n #logging.warning(model_kwargs['ls_init'])\\n \\n # initial ls_scale (if they exist)\\n\\n# (phase, error, coords, lock, error_sigma_clip=4., m_type='sgp', \\n# iterations=1000, pargs=None,verbose=False,model_kwargs={}):\\n model_file = os.path.join(self.proj_dir,\\\"model_{}_{}\\\".format(start,stop))\\n\\n jobs.append(executor.submit(\\n self._solve_interval_full,\\n model_file,\\n phase[:,time_slice,:,:],\\n error[:,time_slice,:,:],\\n (x, t[time_slice],d,f),\\n lock,\\n load_model = model_file,\\n error_sigma_clip = None,\\n m_type='sgp_full',\\n iterations=iterations,\\n pargs=\\\"Working on time chunk ({}) {} to ({}) {}\\\".format(\\n start,timestamps[start],stop-1,timestamps[stop-1]),\\n verbose=verbose,\\n model_kwargs = model_kwargs\\n )\\n )\\n results = futures.wait(jobs)\\n if verbose:\\n logging.warning(results)\\n results = [j.result() for j in jobs]\\n\\n phase_mean = np.zeros(phase.shape)\\n phase_weights = np.zeros(phase.shape)\\n variance_mean = np.zeros(variance.shape)\\n res_idx = 0\\n for j,aj in enumerate(time_idx[::shift]):\\n start = j*interval\\n stop = min((j+1)*interval,Nt)\\n time_slice = slice(start,stop,1)\\n res = results[res_idx]\\n p,v = res\\n phase_mean[:,time_slice,:,:] += p/(v+1e-6)\\n variance_mean[:,time_slice,:,:] += 1.\\n phase_weights[:,time_slice,:,:] += 1./(v+1e-6)\\n res_idx += 1\\n phase_mean /= (phase_weights+1e-6)\\n variance_mean /= (phase_weights+1e-6)\\n datapack.set_phase(phase_mean, ant_idx=ant_idx,time_idx=time_idx,dir_idx=dir_idx,freq_idx=freq_idx)\\n datapack.set_variance(variance_mean, ant_idx=ant_idx,time_idx=time_idx,dir_idx=dir_idx,freq_idx=freq_idx)\\n datapack.save(save_datapack)\",\n \"def calibrate(self):\\n import time\\n\\n CALIBRATE_SLEEP = 0.75\\n\\n self.change_power(-self._calpow)\\n encprev, encnow = 0, None\\n while encprev != encnow:\\n encprev = encnow\\n time.sleep(CALIBRATE_SLEEP)\\n encnow = self._bp.get_motor_encoder(self._port)\\n self._pmin = encnow\\n self.change_power(0)\\n\\n self.change_power(self._calpow)\\n encprev, encnow = 0, None\\n while encprev != encnow:\\n encprev = encnow\\n time.sleep(CALIBRATE_SLEEP)\\n encnow = self._bp.get_motor_encoder(self._port)\\n self._pmax = encnow\\n self.change_power(0)\\n\\n if self._pmax == self._pmin:\\n raise Exception('motor {} does not move'.format(self._port))\\n\\n self._pinit = (self._pmax + self._pmin) * 0.5\\n time.sleep(0.5)\\n self.to_init_position()\",\n \"def calibrate(self):\\n self.mode = Mode.calibrating\\n yaw_sensor = yaw_button()\\n while not yaw_sensor.is_pressed():\\n self.move_left()\\n for _ in range(75):\\n self.move_right()\\n\\n pitch_sensor = pitch_button()\\n while not pitch_sensor.is_pressed():\\n self.move_up()\\n for _ in range(21):\\n self.move_down()\\n\\n self.pitch = 0.0\\n self.yaw = 0.0\\n self.mode = Mode.waiting\",\n \"def optimize_self(self):\\n self.compute_predicate_values();\\n \\\"\\\"\\\" Firstly,adjust the f(x) into > alpha_0; \\\"\\\"\\\"\\n for i in range(len(self.RING_PARA_PAIR_CD)):\\n self.adjust_to_excepted_value(self.RING_PARA_PAIR_CD[i]);\\n self.RING_PARA_PAIR_CD[i][0].VECTOR = RUNNING_DATA[self.RING_PARA_PAIR_CD[i][0].WORD_ID]; # 更新内部VECTOR;\\n self.RING_PARA_PAIR_CD[i][2] = self.RING_PARA_PAIR_CD[i][0].polynomial_func(self.RING_PARA_PAIR_CD[i][1]); # 更新内部ALPHA;\\n for i in range(len(self.RING_PARA_PAIR_CC)):\\n # ************** BUG 0627 **********************\\n # if self.RING_PARA_PAIR_CC[i][2]<41 and self.RING_PARA_PAIR_CC[i][2]>40: # ---------------------------------------------------------------->>>>>\\n # print( RUNNING_DATA[self.RING_PARA_PAIR_CC[i][0].WORD_ID] ); # ---------------------------------------------------------------->>>>>\\n self.adjust_to_excepted_value(self.RING_PARA_PAIR_CC[i]); \\n # ************** BUG 0627 **********************\\n # if self.RING_PARA_PAIR_CC[i][2]<41 and self.RING_PARA_PAIR_CC[i][2]>40: # ---------------------------------------------------------------->>>>> \\n # print(self.RING_PARA_PAIR_CC[i][0].VECTOR); # ---------------------------------------------------------------->>>>>\\n # print(RUNNING_DATA[self.RING_PARA_PAIR_CC[i][0].WORD_ID]); # ---------------------------------------------------------------->>>>>\\n # print(self.RING_PARA_PAIR_CC[i][0].polynomial_func(self.RING_PARA_PAIR_CC[i][1])); # ---------------------------------------------------------------->>>>>\\n # print( np.cumprod( self.RING_PARA_PAIR_CC[i][1] - self.RING_PARA_PAIR_CC[i][0].VECTOR )[-1] ); # ---------------------------------------------------------------->>>>>\\n self.RING_PARA_PAIR_CC[i][0].VECTOR = RUNNING_DATA[self.RING_PARA_PAIR_CC[i][0].WORD_ID]; # 更新内部VECTOR;\\n self.RING_PARA_PAIR_CC[i][2] = self.RING_PARA_PAIR_CC[i][0].polynomial_func(self.RING_PARA_PAIR_CC[i][1]); # 更新内部ALPHA;\\n \\\"\\\"\\\" Secondly,adjust the alpha_0 < p_min(y_n) < q_min(x_n)\\\"\\\"\\\" \\n P_MIN = 99999999.0; Q_MIN = 99999999.0;P_MAX = 0.0;Q_MAX = 0.0;\\n CD_ID = 0;CD_MIN=0;\\n # 找到结论中谓词的最小多项式值\\n for RING_PARA_PAIR in self.RING_PARA_PAIR_CC:\\n if Q_MIN>RING_PARA_PAIR[2]: Q_MIN=RING_PARA_PAIR[2];\\n # if Q_MAX<RING_PARA_PAIR[2]: Q_MAX=RING_PARA_PAIR[2];\\n # 不满足小于结论最小值的那些环的TARGET_ALPHA更新; \\n for RING_PARA_PAIR in self.RING_PARA_PAIR_CD:\\n if P_MIN>RING_PARA_PAIR[2]: P_MIN=RING_PARA_PAIR[2];CD_MIN=CD_ID;# self.RING_PARA_PAIR_CD[CD_ID][3]=-Q_MIN;\\n # if P_MAX<RING_PARA_PAIR[2]: P_MAX=RING_PARA_PAIR[2];self.RING_PARA_PAIR_CD[CD_ID][3]=-Q_MAX;\\n CD_ID+=1;\\n self.RING_PARA_PAIR_CD[CD_MIN][3]=-Q_MIN; \\n # 优化不满足小于结论最小值的那些环 \\n for i in range(len(self.RING_PARA_PAIR_CD)): \\n if self.RING_PARA_PAIR_CD[i][3]!=ALPHA:\\n if P_MIN>Q_MIN:\\n self.adjust_to_excepted_value(self.RING_PARA_PAIR_CD[i]); \\n self.RING_PARA_PAIR_CD[i][0].VECTOR = RUNNING_DATA[self.RING_PARA_PAIR_CD[i][0].WORD_ID]; # 更新内部VECTOR;\\n self.RING_PARA_PAIR_CD[i][2] = self.RING_PARA_PAIR_CD[i][0].polynomial_func(self.RING_PARA_PAIR_CD[i][1]); # 更新内部ALPHA;\",\n \"def calibrate(self, cal=1.0, pol_eff=1.0):\\n \\n if self.ncomp == 1:\\n self.data *= cal\\n else:\\n self.data[0] *= cal\\n self.data[1] *= cal * pol_eff\\n self.data[2] *= cal * pol_eff\\n\\n return self\",\n \"def _advance_settings(self, sol):\\r\\n if self.cond == True:\\r\\n # Save last solution...\\r\\n self.lst_tmp = sol\\r\\n # Check if all timesteps are complete.\\r\\n self.current_T += self.d_T\\r\\n self.step += 1\\r\\n if self.current_T > self.max_T:\\r\\n return False\\r\\n # Set to not be conduction any more\\r\\n self.cond = False\\r\\n if len(self.fq_list) > 0:\\r\\n self.rad = 0\\r\\n else:\\r\\n # There are radiation steps to do.\\r\\n self.cond = True\\r\\n return True\\r\\n\\r\\n # If we're here, we're either not done anything yet or have\\r\\n # just done a radiation step.\\r\\n if self.rad != None:\\r\\n # Save last solution\\r\\n self.lst_rad[self.rad] = sol\\r\\n # Advance to next radiation stage if one exists. Else cond.\\r\\n if self.rad + 1 != len(self.fq_list):\\r\\n self.rad += 1\\r\\n else:\\r\\n self.rad = None\\r\\n self.cond = True\\r\\n return True\\r\\n\\r\\n # If we've made it to here, we must just setting the simulation\\r\\n # going.\\r\\n assert (len(self.fq_list) == len(self.lst_rad))\\r\\n if len(self.lst_rad) > 0:\\r\\n assert (len(self.fq_list) == len(self.absorb_coeffs))\\r\\n assert (self.refr_idx_vol >= 0.0)\\r\\n # Could set to zero, but that might limit restarts. Just check\\r\\n # Validity....\\r\\n assert (self.step != None)\\r\\n assert (self.d_T > 0.0)\\r\\n assert (self.current_T != None)\\r\\n assert (self.max_T != None)\\r\\n assert (self.max_T > self.current_T)\\r\\n assert (self.diff_scale >= 0.0)\\r\\n assert (self.diff_scale <= 1.0)\\r\\n assert (self.thermal_conductivity > 0.0)\\r\\n assert (self.alpha >= 0.0)\\r\\n assert (self.refr_idx_background >= 0.0)\\r\\n # Set the ball rolling:\\r\\n if len(self.fq_list) > 0:\\r\\n # We can set solver for frequencies first...\\r\\n self.rad = 0\\r\\n else:\\r\\n self.cond = True\\r\\n return True\",\n \"def _calibrate_without_loss(self, calib_dataset, calib_batch_size,\\n calib_steps):\\n # Create quantize calibration model\\n if not self._optimized_model:\\n logger.error(\\n 'Should call `optimize_model()` before `_calibrate_without_loss`.')\\n self._qcb_model, self._layer_metadata = self._quantizer.create_quantize_model(\\n self._optimized_model,\\n candidate_layers=self._candidate_layers,\\n layer_metadata=self._layer_metadata,\\n quantize_strategy=self._quantize_strategy,\\n mode='QCB',\\n target=self._target,\\n dataset=calib_dataset,\\n batch_size=calib_batch_size,\\n steps=calib_steps,\\n specific_layers=self._specific_layers)\\n\\n if calib_dataset is not None:\\n logger.info(\\\"Start Quantize Calibration...\\\")\\n collector = self._run_model_with_collector(self._qcb_model, calib_dataset,\\n calib_batch_size, calib_steps)\\n\\n # Create quantize calibration evaluation model\\n self._qcbev_model = model_utils.clone_model_with_weights(self._qcb_model)\\n model_utils.set_layer_mode(self._qcbev_model, 'QCBEV')\\n\\n if type(self._quantize_strategy\\n ) == vitis_pof2s_quantize_strategy.VitisPof2SQuantizeStrategy:\\n # Freeze the quantize info into the model, now using most_common_quantize_info\\n # last_quantize_info = collector.get_last_quantize_info()\\n common_quantize_info = collector.get_most_common_quantize_info()\\n self._freeze_quantize_info(common_quantize_info)\\n elif type(self._quantize_strategy) in [\\n vitis_fs_quantize_strategy.VitisFSQuantizeStrategy,\\n vitis_fsx_quantize_strategy.VitisFSXQuantizeStrategy,\\n vitis_gpu_quantize_strategy.VitisGPUQuantizeStrategy\\n ]:\\n # Freeze the quantize info into the model, now using most_common_quantize_info\\n # last_quantize_info = collector.get_last_quantize_info()\\n common_quantize_info = collector.get_entropy_percentile_amax(\\n self._qcb_model)\\n self._freeze_quantize_info(common_quantize_info)\\n\\n logger.info(\\\"Quantize Calibration Done.\\\")\",\n \"def calibrate_arm(self, axis):\\n\\n while self.arm.position(axis) < self.maxdist:\\n\\n # calibrate arm axis using exponential moves:\\n # moves the arm, recenter the tip and refocus.\\n try:\\n self.exp_focus_track(axis)\\n except EnvironmentError:\\n self.update_message('Could not track the tip.')\\n return 0\\n\\n # When calibration is finished:\\n\\n # Resetting position of arm and microscope so no error gets to the next axis calibration\\n self.go_to_zero()\\n time.sleep(2)\\n\\n return 1\",\n \"def _calibrate_measurement(self):\\n\\n cold_blackbody = bb_radiance(self.cbb.header.cbb_temperature + 273.15,\\n self.cbb.data.wavelength)\\n warm_blackbody = bb_radiance(self.wbb.header.wbb_temperature + 273.15,\\n self.wbb.data.wavelength)\\n\\n self.wbb.data.average_spectrum[0] = 1\\n self.wbb.data.average_spectrum[2047] = 1\\n\\n calibration_slope = ((warm_blackbody - cold_blackbody) /\\n (self.wbb.data.average_spectrum - self.cbb.data.average_spectrum))\\n calibration_offset = warm_blackbody - (self.wbb.data.average_spectrum * \\n calibration_slope)\\n\\n self.wbb.calibrate_file(calibration_slope, calibration_offset)\\n self.cbb.calibrate_file(calibration_slope, calibration_offset)\\n self.sam.calibrate_file(calibration_slope, calibration_offset)\\n\\n if not self.dwr is None:\\n self.dwr.calibrate_file(calibration_slope, calibration_offset)\\n\\n plate_temperature = self.dwr.header.spare_f[0]\\n if (self.plate == -1) :\\n plate_emissivity = self.dwr.header.spare_f[1]\\n\\n plate_blackbody = bb_radiance(plate_temperature + 273.15,\\n self.dwr.data.wavelength)\\n plate_emission = plate_emissivity * plate_blackbody\\n\\n self.dwr.data.average_spectrum = ((self.dwr.data.average_spectrum - \\n plate_emission) / (1 - plate_emissivity))\",\n \"def _set_phase(self):\\n self.phase = np.sign(self._model())\",\n \"def one_step(self):\\r\\n assert (self.uv_vol is not None)\\r\\n assert (self.guv_vol is not None)\\r\\n assert (self.uv_bound is not None)\\r\\n assert (self.vf_vect_bound is not None)\\r\\n assert (self.vF_vect_vol is not None)\\r\\n # Shape checks\\r\\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\\r\\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\\r\\n assert (self.vF_vect_vol.shape == self.vf_vect_bound.shape)\\r\\n assert (self.uv_vol.shape[0] == self.uv_vol.shape[1])\\r\\n assert (self.uv_vol.shape == self.guv_vol.shape)\\r\\n assert (self.uv_vol.shape == self.uv_bound.shape)\\r\\n assert (self.uv_vol.shape[0] == self.vF_vect_vol.shape[0])\\r\\n \\r\\n if self.step == 0:\\r\\n self.check_k_matrix_stability()\\r\\n # print(\\\"Epsilon is :\\\"+str(self.Epsilon))\\r\\n # print(\\\"Beta is :\\\"+str(self.Beta))\\r\\n\\r\\n # Form \\\"Stiffness\\\" matrix:\\r\\n K = self.make_k_matrix()\\r\\n # Form \\\"Force\\\" vector: \\r\\n f = self.vF_vect_vol + (self.Epsilon / self.Beta) * self.vf_vect_bound\\r\\n\\r\\n # print(\\\"FORCE VECTOR:\\\")\\r\\n # print(f)\\r\\n # print(\\\"STIFFNESS MATRIX\\\")\\r\\n # print(K)\\r\\n # print(\\\"UV_VOL\\\")\\r\\n # print(self.uv_vol)\\r\\n # print(\\\"EPSILON * GUV_VOL\\\")\\r\\n # print(self.Epsilon * self.guv_vol)\\r\\n # print(\\\"UV_BOUND * COEFF\\\")\\r\\n # print((self.Epsilon / self.Beta) * self.uv_bound)\\r\\n sol = scipy_sparse_linsolve(K, f)\\r\\n # print(\\\"SOLUTION\\\")\\r\\n # print(sol)\\r\\n return sol\",\n \"def solve(self):\\n # check for jacobian and set it if present and to be used\\n if self.use_sparse:\\n if self._use_jac and hasattr(self.problem,'sparse_jac'):\\n jac = self.problem.sparse_jac\\n else:\\n jac = None\\n else:\\n if self._use_jac and hasattr(self.problem,'jac'):\\n jac = self.problem.jac\\n else:\\n jac = None\\n \\n # Initialize solver and solve \\n \\n solved = False\\n local_min = False\\n\\n res = N.zeros(self.x0.__len__())\\n while (not solved) and self.reg_count < 2:\\n try:\\n if self._use_fscale:\\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,self.fscale)\\n else:\\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,None)\\n start = time.clock()\\n res = self.solver.KINSOL_solve(not self._use_ls)\\n stop = time.clock()\\n self.exec_time += (stop - start)\\n solved = True\\n except KINError as error:\\n if error.value == 42:\\n # Try the heuristic\\n if hasattr(self.problem, 'get_heuristic_x0'):\\n print \\\"----------------------------------------------------\\\"\\n print \\\" Solver stuck with zero step-length.\\\"\\n print \\\"----------------------------------------------------\\\"\\n print \\\"The following variables have start value zero\\\"\\n print \\\"and min set to zero causing the zero step-lenght.\\\"\\n print \\\"These settings are either set by default or by user.\\\"\\n print \\\"\\\"\\n\\n self.x0 = self.problem.get_heuristic_x0()\\n self.reg_count += 1\\n \\n print \\\"\\\"\\n print \\\"This setting (start and min to zero) can often\\\"\\n print \\\"cause problem when initializing the system. \\\"\\n print \\\"\\\"\\n print \\\"To avoid this the above variables have\\\"\\n print \\\"their start attributes reset to one.\\\"\\n print \\\"\\\"\\n print \\\"Trying to solve the system again...\\\"\\n else:\\n raise KINSOL_Exception(\\\"Regularization failed due to constraints, tried getting heuristic initial guess but failed.\\\")\\n \\n\\n elif (error.value == 2):\\n print \\\"---------------------------------------------------------\\\"\\n print \\\"\\\"\\n print \\\" !!! WARNING !!!\\\"\\n print \\\"\\\"\\n print \\\" KINSOL has returned a result but the algorithm has converged\\\"\\n print \\\" to a local minima, the initial values are NOT consistant!\\\"\\n print \\\"\\\"\\n print \\\"---------------------------------------------------------\\\"\\n solved = True\\n local_min = True\\n else:\\n # Other error, send onward as exception\\n self.problem.check_constraints(res)\\n raise KINSOL_Exception(error.msg[error.value])\\n \\n if not solved:\\n self.solver.Free_KINSOL()\\n raise KINSOL_Exception(\\\"Algorithm exited solution loop without finding a solution, please contact Assimulo support.\\\")\\n\\n if self.check_with_model:\\n self.problem.check_constraints(res)\\n if not local_min:\\n print \\\"Problem sent to KINSOL solved.\\\"\\n \\n return res\",\n \"def calibrate(self):\\n if not self._calibrate:\\n raise ValueError(\\\"calibrate parameter must be set\\\")\\n\\n if self.calibration_samples >= self._max_samples:\\n return self._camera\\n\\n frame = self.capture()\\n left = frame.images[0]\\n right = frame.images[1]\\n\\n ret_l, corners_l = left.features\\n ret_r, corners_r = right.features\\n\\n if self._last_timestamp is None:\\n self._last_timestamp = frame.timestamp\\n\\n if ret_l is True and ret_r is True and (frame.timestamp - self._last_timestamp).total_seconds() > self._frame_delay:\\n self.objpoints.append(self.objp)\\n self.imgpoints_l.append(corners_l)\\n self.imgpoints_r.append(corners_r)\\n\\n self.calibration_samples += 1\\n self._last_timestamp = frame.timestamp\\n\\n if self.calibration_samples >= self._max_samples:\\n img_shape = left.image.shape[::-1]\\n self._camera = self._finish_calibration(self.objpoints, self.imgpoints_l, self.imgpoints_r, img_shape)\\n return self._camera\",\n \"def calc(self):\\n\\n # the following if query ensures that volume- and interaction-terms\\n # are only calculated if tau > 0.\\n # (to avoid nan-values from invalid function-evaluations)\\n\\n if self.V.tau.shape == (1,):\\n Isurf = self.surface()\\n # differentiation for non-existing canopy, as otherwise NAN values\\n if self.V.tau > 0.:\\n Ivol = self.volume()\\n if self.int_Q is True:\\n Iint = self.interaction()\\n else:\\n Iint = np.array([0.])\\n else:\\n Ivol = np.array([0.])\\n Iint = np.array([0.])\\n else:\\n # calculate surface-term (valid for any tau-value)\\n Isurf = self.surface()\\n\\n # store initial parameter-values\\n old_t_0 = self.t_0\\n old_p_0 = self.p_0\\n old_t_ex = self.t_ex\\n old_p_ex = self.p_ex\\n\\n old_tau = self.V._get_tau()\\n old_omega = self.V._get_omega()\\n old_NN = self.SRF._get_NormBRDF()\\n\\n # set mask for tau > 0.\\n mask = old_tau > 0.\\n valid_index = np.where(mask)\\n inval_index = np.where(~mask)\\n\\n # set parameter-values to valid values for calculation\\n self.t_0 = old_t_0[valid_index[0]]\\n self.p_0 = old_p_0[valid_index[0]]\\n self.t_ex = old_t_ex[valid_index[0]]\\n self.p_ex = old_p_ex[valid_index[0]]\\n\\n # squeezing the arrays is necessary since the setter-function for\\n # tau, omega and NormBRDF automatically adds an axis to the arrays!\\n self.V.tau = np.squeeze(old_tau[valid_index[0]])\\n if np.array(self.V.omega).size != 1:\\n self.V.omega = np.squeeze(old_omega[valid_index[0]])\\n if np.array(self.SRF.NormBRDF).size != 1:\\n self.SRF.NormBRDF = np.squeeze(old_NN[valid_index[0]])\\n\\n # calculate volume and interaction term where tau-values are valid\\n _Ivol = self.volume()\\n if self.int_Q is True:\\n _Iint = self.interaction()\\n else:\\n _Iint = np.full_like(self.t_0, 0.)\\n\\n # reset parameter values to old values\\n self.t_0 = old_t_0\\n self.p_0 = old_p_0\\n self.t_ex = old_t_ex\\n self.p_ex = old_p_ex\\n\\n # squeezing the arrays is necessary since the setter-function for\\n # tau, omega and NormBRDF automatically add an axis to the arrays!\\n self.V.tau = np.squeeze(old_tau)\\n self.V.omega = np.squeeze(old_omega)\\n self.SRF.NormBRDF = np.squeeze(old_NN)\\n\\n # combine calculated volume-contributions for valid tau-values\\n # with zero-arrays for invalid tau-values\\n Ivol = np.ones_like(self.t_0)\\n Ivol[valid_index[0]] = _Ivol\\n Ivol[inval_index[0]] = np.ones_like(Ivol[inval_index[0]]) * 0.\\n\\n # combine calculated interaction-contributions for valid tau-values\\n # with zero-arrays for invalid tau-values\\n if self.int_Q is True:\\n Iint = np.ones_like(self.t_0)\\n Iint[valid_index[0]] = _Iint\\n Iint[inval_index[0]] = np.ones_like(Iint[inval_index[0]]) * 0.\\n else:\\n Iint = np.full_like(self.t_0, 0.)\\n\\n return Isurf + Ivol + Iint, Isurf, Ivol, Iint\",\n \"def _solve(self):\\n B = sp.linalg.solve(self._XtX, self._XtY, assume_a='pos', overwrite_a=False, overwrite_b=False)\\n self.coef_ = B[1:]\\n self.intercept_ = B[0]\\n self.is_fitted_ = True\",\n \"def force_calibration_controller_test():\\n print(f\\\"Running {__file__}::{force_calibration_controller_test.__name__}()\\\")\\n arm_state = State()\\n alpha=0.2\\n ctrl = EMAForceCalibrator(Connection(arm_state), alpha=alpha)\\n cmd = Command()\\n state = State()\\n ctrl.execute(cmd, state)\\n assert np.all(ctrl.force_average.array == 0)\\n\\n arm_state.sensor_force()[:] = [2,2,2,2,2,2]\\n ctrl.execute(cmd, state)\\n assert np.all(ctrl.force_average.array != 0)\\n assert state.sensor_force().allclose(np.array([2,2,2,2,2,2])*(1-alpha), 0.001)\\n\\n for i in range(100):\\n ctrl.execute(cmd, state)\\n assert ctrl.force_average.allclose([2,2,2,2,2,2], 0.001)\\n assert state.sensor_force().allclose([0,0,0,0,0,0], 0.001)\\n\\n arm_state.sensor_force()[:] = [0,0,0,0,0,0]\\n ctrl.execute(cmd, state)\\n assert state.sensor_force().allclose(np.array([-2,-2,-2,-2,-2,-2])*(1-alpha), 0.001)\\n\\n for i in range(100):\\n ctrl.execute(cmd, state)\\n assert ctrl.force_average.allclose([0,0,0,0,0,0], 0.001)\\n assert state.sensor_force().allclose([0,0,0,0,0,0], 0.001)\\n\\n print(\\\"Passed.\\\")\",\n \"def start_uncorrelated_self_optimizer_strategy(wf):\\n\\n optimizer_method = wf.execution_strategy[\\\"optimizer_method\\\"]\\n info(\\\"> ExecStrategy | UncorrelatedSelfOptimizer\\\", Fore.CYAN)\\n info(\\\"> Optimizer | \\\" + optimizer_method, Fore.CYAN)\\n\\n knobs = wf.execution_strategy[\\\"knobs\\\"]\\n wf.totalExperiments = len(knobs) * wf.execution_strategy[\\\"optimizer_iterations\\\"]\\n\\n total_result = dict()\\n # we fill the arrays and use the index to map from gauss-optimizer-value to variable\\n for key in knobs:\\n optimal_knob_value = optimizeOneVariable(wf, wf.execution_strategy[\\\"optimizer_iterations\\\"], key,\\n (knobs[key][0], knobs[key][1]))\\n total_result[key] = optimal_knob_value\\n wf.change_provider[\\\"instance\\\"].applyChange(total_result)\\n info(\\\">\\\")\\n info(\\\"> FinalResult | Best Values: \\\" + str(total_result))\",\n \"def calibrate(self):\\n\\t\\twl = BLi.getWavelength()\\n\\t\\tif abs(self.stokes()) <= .5:\\n\\t\\t\\txxx=self.sign()*180/pi*asin( wl/(2*self.dspace)) - (self.thp())\\n\\t\\t\\tself.offset2(-xxx)\\n\\t\\t\\tyyy=self.tthp()-self.sign()*2*180/pi*asin(wl/(2*self.dspace))-self.offset5()\\n\\t\\t\\tself.offset4(yyy)\\n\\t\\t\\tself.offset9(self.dettrans())\\n\\t\\telif abs(self.stokes()-90.) <= .5:\\n\\t\\t\\txxx=self.sign()*180/pi*asin( wl/(2*self.dspace)) - (self.thp())\\n\\t\\t\\tself.offset3(-xxx)\\n\\t\\t\\tyyy=self.tthp()-self.sign()*2*180/pi*asin(wl/(2*self.dspace))-self.offset5()\\n\\t\\t\\tself.offset8(yyy)\\n\\t\\t\\tself.offset10(self.dettrans())\\n\\t\\telse:\\n\\t\\t\\tprint \\\"Can't calibrate at stokes=\\\",self.stokes()\\n\\t\\treturn [self.sign(),self.offset2(), self.offset3(),self.offset4(),self.offset5(),self.offset8(),self.offset9(),self.offset10()]\",\n \"def analyze_orbit_corrector(OC1, OC2, beamline, phase_beg):\\n\\n M = np.identity(4)\\n OC_parameters = np.zeros(4)\\n\\n for element in beamline:\\n M = np.dot(element.M1, M)\\n\\n # Since the X and Y are decoupled, we can treat them separately.\\n M_x = M[0:2, 0:2]\\n M_y = M[2:4, 2:4]\\n\\n L1 = [[OC1.length/2], [1]]\\n L2 = [[OC2.length/2], [1]]\\n\\n M_OC1 = np.array(OC1.M1)[0:2, 0:2]\\n M_OC2 = np.array(OC2.M1)[0:2, 0:2]\\n\\n # The following part solve the cx_1 and cx_2\\n M1_x = np.linalg.multi_dot([M_OC2, M_x, L1])\\n M2_x = np.linalg.multi_dot([M_OC2, M_x, M_OC1])\\n M_OC_x = np.hstack((M1_x, L2))\\n\\n OC_parameters[0:2] = -np.linalg.multi_dot([np.linalg.inv(M_OC_x), M2_x, phase_beg[0:2]])\\n # The end of the X-part\\n\\n # The following part solve the cy_1 and cy_2\\n M1_y = np.linalg.multi_dot([M_OC2, M_y, L1])\\n M2_y = np.linalg.multi_dot([M_OC2, M_y, M_OC1])\\n M_OC_y = np.hstack((M1_y, L2))\\n\\n OC_parameters[2:4] = -np.linalg.multi_dot([np.linalg.inv(M_OC_y), M2_y, phase_beg[2:4]])\\n # The end of the Y-part\\n\\n\\n return OC_parameters\",\n \"def control(self, arm, x_des=None):\\n if self.u is None:\\n self.u = np.zeros(arm.DOF)\\n\\n self.Q = np.zeros((arm.DOF*2, arm.DOF*2))\\n self.Q[:arm.DOF, :arm.DOF] = np.eye(arm.DOF) * 1000.0 \\n self.R = np.eye(arm.DOF) * 0.001 \\n\\n # calculate desired end-effector acceleration\\n if x_des is None:\\n self.x = arm.x \\n x_des = self.x - self.target \\n\\n self.arm, state = self.copy_arm(arm)\\n A, B = self.calc_derivs(state, self.u)\\n\\n if self.solve_continuous is True:\\n X = sp_linalg.solve_continuous_are(A, B, self.Q, self.R)\\n K = np.dot(np.linalg.pinv(self.R), np.dot(B.T, X))\\n else: \\n X = sp_linalg.solve_discrete_are(A, B, self.Q, self.R)\\n K = np.dot(np.linalg.pinv(self.R + np.dot(B.T, np.dot(X, B))), np.dot(B.T, np.dot(X, A)))\\n\\n # transform the command from end-effector space to joint space\\n J = self.arm.gen_jacEE()\\n\\n u = np.hstack([np.dot(J.T, x_des), arm.dq])\\n\\n self.u = -np.dot(K, u)\\n\\n if self.write_to_file is True:\\n # feed recorders their signals\\n self.u_recorder.record(0.0, self.u)\\n self.xy_recorder.record(0.0, self.x)\\n self.dist_recorder.record(0.0, self.target - self.x)\\n\\n # add in any additional signals \\n for addition in self.additions:\\n self.u += addition.generate(self.u, arm)\\n\\n return self.u\",\n \"def method1(self):\\n cres=0. # Variable for storing Chern number.\\n # The U matrices from Fukui's method; storage...\\n Ux=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n Uy=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n \\n # ... and calculation of U matrices\\n for ix in range(self.kS.Nx+1):\\n for iy in range(self.kS.Ny+1):\\n mat1=self.alleigvecs[:,:,ix ,iy ]\\n if ix<self.kS.Nx:\\n mat2=self.alleigvecs[:,:,ix+1,iy ]\\n else:\\n mat2=self.alleigvecs[:,:,1 ,iy ]\\n if iy<self.kS.Ny:\\n mat3=self.alleigvecs[:,:,ix ,iy+1]\\n else:\\n mat3=self.alleigvecs[:,:,ix ,1 ]\\n Ux[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat2)[:self.NL,:self.NL])\\n Uy[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat3)[:self.NL,:self.NL])\\n \\n # Local estimates of Berry curvature; storage ...\\n ftempall=np.zeros((self.kS.Nx,self.kS.Ny),complex)\\n # ... and calculation\\n for ix in range(self.kS.Nx):\\n for iy in range(self.kS.Ny):\\n ftemp=np.log(Ux[ix,iy]*Uy[ix+1,iy]/Ux[ix,iy+1]/Uy[ix,iy])\\n ftempall[ix,iy]=ftemp # ... of local Berry curvature ...\\n cres+=ftemp/2./pi/1j # ... and of Berry phase (Chern number).\\n\\n return cres.real, ftempall\",\n \"def calibrate(self):\\n self.gripper_io.set_signal_value(\\\"calibrate\\\", True)\\n success = intera_dataflow.wait_for(\\n lambda: self.is_calibrated(),\\n timeout=5.0,\\n raise_on_error=False\\n )\\n if not success:\\n rospy.logerr(\\\"({0}) calibration failed.\\\".format(self.name))\\n return success\",\n \"def apply_calib(fix_dir, tprobs, run, hour, exper=1, smooth=1, wd=''):\\n\\n # Apply smoothing\\n calib_probs = gaussian_filter(tprobs, smooth, mode='constant')\\n\\n # Apply calibration\\n run_str = str(run).zfill(2)\\n in_dir = f'{fix_dir}/calib_files/{exper}/{run_str}_{hour}.pkl'\\n\\n with open(in_dir, 'rb') as f:\\n corr_data = pickle.load(f, encoding='latin1')\\n\\n for index in np.ndindex(calib_probs.shape):\\n this_forecast = calib_probs * 100\\n if this_forecast[index] < 5:\\n bin = 0\\n elif this_forecast[index] >= 5 and this_forecast[index] < 15:\\n bin = 10\\n elif this_forecast[index] >= 15 and this_forecast[index] < 25:\\n bin = 20\\n elif this_forecast[index] >= 25 and this_forecast[index] < 35:\\n bin = 30\\n elif this_forecast[index] >= 35 and this_forecast[index] < 45:\\n bin = 40\\n elif this_forecast[index] >= 45 and this_forecast[index] < 55:\\n bin = 50\\n elif this_forecast[index] >= 55 and this_forecast[index] < 65:\\n bin = 60\\n elif this_forecast[index] >= 65 and this_forecast[index] < 75:\\n bin = 70\\n elif this_forecast[index] >= 75 and this_forecast[index] < 85:\\n bin = 80\\n elif this_forecast[index] >= 85:\\n bin = 90\\n\\n calib_probs[index] = calib_probs[index] + (corr_data[index][bin] / 100.)\\n calib_probs = calib_probs.astype(float)\\n \\n # Set anything less than 0 after calibration to 0\\n calib_probs[calib_probs < 0] = 0\\n \\n return calib_probs\",\n \"def platform_auto_calibrate(self):\\n self.platform_auto_calibrate_servos()\\n self.platform_auto_calibrate_imu()\",\n \"def run(self):\\n is_spsa = True\\n is_steep_descent = False\\n is_rprop = False\\n\\n k = 0\\n theta = self.theta0\\n\\n while True:\\n k = k + 1\\n\\n self.iter = k\\n print(f'starting iter {k} ...')\\n\\n if self.constraints is not None:\\n theta = self.constraints(theta)\\n\\n print('current param:')\\n for name, value in utils.true_param(theta).items():\\n print(f' {name}: {value[\\\"value\\\"]}')\\n\\n c_k = self.c / (k ** self.gamma)\\n a_k = self.a / ((k + self.A) ** self.alpha)\\n\\n # print(f' ck: {c_k:0.5f}')\\n # print(f' ak: {a_k:0.5f}')\\n\\n # Run the engine match here to get the gradient\\n print('Run engine match ...')\\n gradient = self.approximate_gradient(theta, c_k, k)\\n\\n # For SPSA we update with a small step (theta = theta - a_k * gradient)\\n if is_spsa:\\n theta = utils.linear_combinaison(1.0, theta, -a_k, gradient)\\n logging.info(f'{__file__} > theta from spsa: {theta}')\\n # print(f'new param after application of gradient:')\\n # for n, v in theta.items():\\n # print(f' {n}: {int(v[\\\"value\\\"] * v[\\\"factor\\\"])}')\\n\\n # For steepest descent we update via a constant small step in the gradient direction\\n elif is_steep_descent:\\n mu = -0.01 / max(1.0, utils.norm2(gradient))\\n theta = utils.linear_combinaison(1.0, theta, mu, gradient)\\n\\n # For RPROP, we update with information about the sign of the gradients\\n elif is_rprop:\\n theta = utils.linear_combinaison(1.0, theta, -0.01, self.rprop(theta, gradient))\\n\\n # Apply parameter limits\\n theta = utils.apply_limits(theta)\\n logging.info(f'{__file__} > theta with limits: {theta}')\\n # print(f'new param after application of limits:')\\n # for n, v in theta.items():\\n # print(f' {n}: {int(v[\\\"value\\\"] * v[\\\"factor\\\"])}')\\n\\n # We then move to the point which gives the best average of goal\\n (avg_goal, avg_theta) = self.average_best_evals(30)\\n logging.info(f'{__file__} > avg_theta from average_best_evals: {avg_theta}')\\n\\n theta = utils.linear_combinaison(0.98, theta, 0.02, avg_theta)\\n logging.info(f'{__file__} > theta with avg_theta: {theta}')\\n # print(f'new param after application of best average param:')\\n # for n, v in theta.items():\\n # print(f' {n}: {int(v[\\\"value\\\"] * v[\\\"factor\\\"])}')\\n\\n # Apply parameter limits\\n theta = utils.apply_limits(theta) # This is the best param.\\n logging.info(f'{__file__} > best param: {theta}')\\n # print(f'new param after application of limits:')\\n # for n, v in theta.items():\\n # print(f' {n}: {int(v[\\\"value\\\"] * v[\\\"factor\\\"])}')\\n\\n # Log best param values\\n for kv, vv in theta.items():\\n logging.info(f'<best> iter: {k}, param: {kv}, value: {int(vv[\\\"value\\\"]*vv[\\\"factor\\\"])}')\\n print('best param:')\\n for n, v in theta.items():\\n print(f' {n}: {int(v[\\\"value\\\"] * v[\\\"factor\\\"])}')\\n\\n mean_all_goal, _ = self.average_evaluations(30)\\n print(f'mean all goal: {mean_all_goal}')\\n\\n mean_best_goal, _ = self.average_best_evals(30)\\n print(f'mean best goal: {mean_best_goal}')\\n\\n # Save data in csv for plotting.\\n plot_data = {}\\n plot_data.update({'iter': k})\\n plot_data.update({'meanbestgoal': mean_best_goal})\\n plot_data.update({'meanallgoal': mean_all_goal})\\n plot_theta = utils.true_param(theta)\\n for name, value in plot_theta.items():\\n plot_data.update({name: value[\\\"value\\\"]})\\n\\n with open(self.plot_data_file, 'a') as f:\\n cnt = 0\\n for name, value in plot_data.items():\\n cnt += 1\\n if cnt == len(plot_data):\\n f.write(f'{value}\\\\n')\\n else:\\n f.write(f'{value},')\\n\\n print(f'done iter {k} / {self.max_iter}')\\n logging.info(f'{__file__} > done iter {k} / {self.max_iter}')\\n print('=========================================')\\n\\n # Stopping rule 1: Average goal and iteration meet the\\n # stop_all_mean_goal and stop_min_iter criteria.\\n if k >= self.stop_min_iter and mean_all_goal <= self.stop_all_mean_goal:\\n print('Stop opimization due to good average all goal!')\\n break\\n\\n # Stopping rule 2: Average best goal and iteration meet the\\n # stop_best_mean_goal and stop_min_iter criteria.\\n if k >= self.stop_min_iter and mean_best_goal <= self.stop_best_mean_goal:\\n print('Stop opimization due to good average best goal!')\\n break\\n\\n # Stopping rule 3: Max iteration is reached.\\n if k >= self.max_iter:\\n print('Stop opimization due to max iteration!')\\n break\\n\\n return utils.true_param(theta)\",\n \"def __call__(self):\\n\\n if self.indices is []:\\n return\\n\\n\\n #-----------------------------------------\\n # Here is where the important formula is applied\\n #----------------------------------------\\n if self.indices is None:\\n height = self.stage_c - self.elev_c\\n self.friction_c[:] = self.friction(height)\\n else:\\n ind = self.indices\\n height = self.stage_c[ind] - self.elev_c[ind]\\n self.friction_c[ind] = self.friction(height)\",\n \"def __solve(self) -> None:\\n pyo.TransformationFactory(\\\"contrib.detect_fixed_vars\\\").apply_to(self.model) # type: ignore\\n pyo.TransformationFactory(\\\"contrib.deactivate_trivial_constraints\\\").apply_to(self.model) # type: ignore\\n\\n # initialise the solver object\\n self._logger.debug(\\\"[ModelSolver] Solver object initiated...\\\")\\n solver = Config.OPTIMISATION_MODEL_CONFIG['SOLVER_TYPE']\\n opt = pyo.SolverFactory(solver)\\n if Config.OPTIMISATION_MODEL_CONFIG['SOLVER_OPTION'].get(solver) is not None:\\n for k, v in Config.OPTIMISATION_MODEL_CONFIG['SOLVER_OPTION'].get(solver).items():\\n opt.options[k] = v\\n\\n try:\\n start_time = datetime.now()\\n self._logger.debug(\\\"[ModelSolver] Solver starting...\\\")\\n results = opt.solve(self.model, tee=True)\\n self.results = results\\n end_time = datetime.now()\\n self._logger.info(f\\\"[ModelSolver] Solver completed in {end_time - start_time}.\\\")\\n except Exception as e:\\n raise Exception(f\\\"Model optimisation failed with {solver} with error message {e}.\\\")\\n\\n if (results.solver.status == SolverStatus.ok) and (results.solver.termination_condition == TerminationCondition.optimal):\\n self._logger.info(\\\"Solution is feasible and optimal\\\")\\n results.write()\\n elif results.solver.termination_condition == TerminationCondition.infeasible:\\n raise ValueError(\\\"Model optimisation resulted into an infeasible solution\\\")\\n\\n self.model.optimised = True\",\n \"def calcIntrasec(self, gui):\\n count = len(self.points)\\n numpoints = (self.chessSize[0]*self.chessSize[1])\\n\\n #create matrices that are needed to compute calibration\\n mat = cv.CreateMat(3,3,cv.CV_32FC1)\\n distCoeffs = cv.CreateMat(4,1,cv.CV_32FC1)\\n p3d = cv.CreateMat(count,3,cv.CV_32FC1) #compute 3D points\\n p2d = cv.CreateMat(count,2,cv.CV_32FC1) #compute 2D points\\n pointCounts = cv.CreateMat( self.nframe ,1,cv.CV_32SC1) #give numpoints per images\\n cv.Set(pointCounts,numpoints)\\n rvecs = cv.CreateMat(self.nframe,3,cv.CV_32FC1)\\n tvecs = cv.CreateMat(self.nframe,3,cv.CV_32FC1)\\n\\n i = 0\\n row = 0\\n col = 0\\n cv.Set(p3d,0.0) #to set every values to 0.0... and not set Z value\\n\\n #this compute points in row and cols...\\n for p in self.points:\\n p2d[i,0] = p[0]\\n p2d[i,1] = p[1]\\n \\n p3d[i,0] = col\\n p3d[i,1] = row\\n col+=1\\n if col >= self.chessSize[0]: \\n row+=1\\n col=0\\n if row >= self.chessSize[1]:\\n row = 0\\n i+=1\\n\\n #and now, calibrate...\\n cv.CalibrateCamera2(p3d, p2d, pointCounts, self.framesize, mat, distCoeffs, rvecs, tvecs, flags=0)\\n gui.setMessage(\\\"Intrasinc camera parameters checked\\\")\\n\\n return (mat, distCoeffs)\",\n \"def cam_calibration():\\n # read all calibration images in a folder with similar names\\n images = glob.glob('./camera_cal/calibration*.jpg')\\n\\n # calibrate camera and read object-points (3D), image points (2D) and image shape\\n objpoints, imgpoints, img_shape = calibrate_camera(images)\\n print(\\\"DONE: Camera calibration\\\")\\n # save calibration parameters' pickle file\\n save_calib_params(objpoints, imgpoints, img_shape)\\n print(\\\"Calibration parameters pickle file saved \\\")\",\n \"def advance(self):\\n\\n f, n, rtol, atol, neq = \\\\\\n self.f, self.n, self.rtol, self.atol, self.neq\\n u_n, t_n, t_next = self.u[n], self.t[n], self.t[n+1]\\n dt = t_next - t_n\\n\\n first_step = dt # try one big step to next desired level\\n\\n def middle(x,y,z): # Auxilary function\\n return sorted([x,y,z])[1]\\n\\n # Extract coefficients from Butcher-tableau\\n table = self._butcher_tableau\\n k_len = table.shape[1] - 1 # number of internal stages\\n\\n # coefficients for internal stages\\n factors_u = np.asarray(table[:k_len, 1:])\\n # coefficients for t\\n factors_t = table[:k_len, 0]\\n # coefficients for u_new\\n factors_u_new = table[k_len, 1:]\\n\\n # coefficients for local error between 2 levels\\n factors_error = table[k_len+1, 1:] - factors_u_new\\n\\n u_intermediate = [u_n,]\\n t_intermediate = [t_n,]\\n u, t, h = u_n, t_n, first_step # initial values\\n k = np.zeros((k_len, self.neq), self.dtype) # intern stages\\n\\n if self.verbose > 0:\\n print 'advance solution in [%s, %s], h=%g' % (t_n, t_next, h)\\n\\n # Loop until next time point is reached\\n while (abs(t - t_n) < abs(t_next - t_n)):\\n u, t = u_intermediate[-1], t_intermediate[-1]\\n\\n # Internal steps\\n k[:, :] = 0. # initialization for next step\\n for m in range(k_len):\\n k_factors = (np.dot(factors_u, k))[m]\\n #print u, u+h*k_factors, f(u+h*k_factor, 0.5), self.dtype\\n k[m] = f(u+h*k_factors, t+h*factors_t[m])\\n u_new = u + h*(np.dot(factors_u_new, k))\\n\\n self.info['rejected'] += 1 # reduced below if accepted\\n if self.verbose > 0:\\n print ' u(t=%g)=%g: ' % (t+h, u_new),\\n\\n # local error between 2 levels\\n error = h*np.abs(np.dot(factors_error, k))\\n # Acceptable error tolerance\\n tol = rtol*np.abs(u_new) + atol\\n\\n accurate = (error <= tol).all()\\n\\n if accurate or h <= self.min_step or h >= self.max_step:\\n # Accurate enough,\\n # or the step size exceeds valid range,\\n # must accept this solution\\n u_intermediate.append(u_new)\\n t_intermediate.append(t+h)\\n if not self.disk_storage:\\n self.u_all.append(u_new)\\n self.t_all.append(t+h)\\n self.info['rejected'] -= 1\\n\\n if self.verbose > 0:\\n print 'accepted, ',\\n else:\\n if self.verbose > 0:\\n print 'rejected, ',\\n\\n if self.verbose > 0:\\n print 'err=%s, ' % str(error),\\n if hasattr(self, 'u_exact') and callable(self.u_exact):\\n print 'exact-err=%s, ' % \\\\\\n (np.asarray(self.u_exact(t+h))-u_new),\\n if h <= self.min_step:\\n print 'h=min_step!! ',\\n\\n\\n # Replace 0 values by 1e-16 since we will divide by error\\n error = np.asarray([(1e-16 if x == 0. else x) \\\\\\n for x in error])\\n\\n # Normarized error rate\\n rms = error/tol\\n rms_norm = np.sqrt(np.sum(rms*rms)/self.neq)\\n\\n order = float(self._method_order[0])\\n # factor to adjust the size of next step\\n # Formula is from <Numerical Methods for Engineers,\\n # Chappra & Cannle>\\n s = .8 *((1./rms_norm)**(1/order))\\n # scalar should be in range(0.1, 4.)\\n # for better accuracy and smoothness\\n s = middle(s, 0.1, 4.0)\\n h *= s\\n\\n # step size should be in range [min_step, max_step]\\n h = middle(h, self.min_step, self.max_step)\\n # adjust h to fit the last step\\n h = min(h, t_next - t_intermediate[-1])\\n\\n if self.verbose > 0:\\n print 'new h=%g' % h\\n\\n if h == 0:\\n break\\n\\n return u_new\",\n \"def ekf_algorithm(self, u, y):\\n x_est_before = self.x_estimated_state\\n cov_matrix_before = self.cov_matrix\\n # 1. Prediction\\n # predict the state by integrate the time continuous system numerically\\n sim_state_predict = self.heliSim.calc_step(u[0][0], u[1][0], self.no_disturbance_eval)\\n x_est_predict = np.resize(sim_state_predict, (8, 1))\\n # predict the new covariance by linearizing and discretizing the model\\n Ak, Bk, Ck, Dk = self.get_linear_discrete_matrices(x_est_before, u[0][0], u[1][0])\\n cov_matrix_predict = Ak @ cov_matrix_before @ np.transpose(Ak) + Bk @ self.N @ np.transpose(Bk)\\n # 2. Update\\n # compute kalman gain\\n Kl = cov_matrix_predict @ np.transpose(Ck) @ np.linalg.inv(Ck @ cov_matrix_predict @ np.transpose(Ck) + self.W)\\n # update state\\n y_est = x_est_predict[0:3]\\n x_est_update = x_est_predict + Kl @ (y - y_est)\\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ Ck) @ cov_matrix_predict\\n\\n # check if the update step state needs to be changed because of limit crossing\\n # if that is the case, correct the state and set the state of the simulation accordingly\\n corrected_state = self.heliSim.get_limited_state_and_change_state(x_est_update.reshape((1, 8))[0],\\n ModelType.GYROMOMENT)\\n x_est_update = np.resize(corrected_state, (8, 1))\\n\\n self.x_estimated_state = x_est_update\\n self.cov_matrix = cov_matrix_update\\n # print(\\\"------\\\")\\n # print(cov_matrix_predict)\\n return x_est_update\",\n \"def __update(self):\\n\\n # Make sure loads have been assigned to group\\n if type(self.appliedLoad) == Load:\\n self.appliedLoad = LoadSet(self.appliedLoad)\\n elif type(self.appliedLoad) != LoadSet:\\n raise TypeError(\\\"Applied load must be a Load or LoadSet\\\")\\n\\n # Begin Calculations\\n _cg = self.cg # calculate the cg once to save computation time\\n _appLoad = self.appliedLoad.totalForce\\n _appMoment = self.appliedLoad.totalMoment\\n\\n coef_mat = np.zeros((len(self) * 3, len(self) * 3)) # coeff matrix\\n soln_mat = np.zeros(len(self) * 3) # solution matrix\\n\\n cSet = [[i, i+1, i+2] for i in range(0, 3 * len(self), 3)]\\n rSet = [[i+6, i+7, i+8] for i in range(0, 3 * (len(self) - 2), 3)]\\n\\n for i, j in enumerate(cSet):\\n # i = column fastener ID\\n # j = column fastener set\\n # Mx = yFz - zFy\\n # My = zFx - xFz\\n # Mz = xFy - yFx\\n\\n Fx = j[0]\\n Fy = j[1]\\n Fz = j[2]\\n\\n # fill in first three rows\\n coef_mat[0][Fx] = 1 # sum of Fx\\n coef_mat[1][Fy] = 1 # sum of Fy\\n coef_mat[2][Fz] = 1 # sum of Fz\\n\\n # fill in fourth row (sum of Mx at CG)\\n coef_mat[3][Fy] = -(F[i].xyz[2] - _cg[2]) # -zFy\\n coef_mat[3][Fz] = +(F[i].xyz[1] - _cg[1]) # +yFz\\n\\n # fill in fifth row (sum of My at CG)\\n coef_mat[4][Fx] = +(F[i].xyz[2] - _cg[2]) # +zFx\\n coef_mat[4][Fz] = -(F[i].xyz[0] - _cg[0]) # -xFz\\n\\n # fill in sixth row (sum of Mz at CG)\\n coef_mat[5][Fx] = -(F[i].xyz[1] - _cg[1]) # -yFx\\n coef_mat[5][Fy] = +(F[i].xyz[0] - _cg[0]) # +xFy\\n\\n for u, w in enumerate(rSet):\\n # u = row fastener ID\\n # w = row fastener set\\n\\n rX = w[0]\\n rY = w[1]\\n rZ = w[2]\\n\\n coef_mat[rX][Fy] = -(F[i].xyz[2] - F[u].xyz[2]) # -zFy\\n coef_mat[rX][Fz] = +(F[i].xyz[1] - F[u].xyz[1]) # +yFz\\n\\n coef_mat[rY][Fx] = +(F[i].xyz[2] - F[u].xyz[2]) # +zFx\\n coef_mat[rY][Fz] = -(F[i].xyz[0] - F[u].xyz[0]) # -xFz\\n\\n coef_mat[rZ][Fx] = -(F[i].xyz[1] - F[u].xyz[1]) # -yFx\\n coef_mat[rZ][Fy] = +(F[i].xyz[0] - F[u].xyz[0]) # +xFy\\n\\n # fill in the solution matrix (soln_mat)\\n for i in range(3):\\n soln_mat[i] = -_netLoad.force[i]\\n soln_mat[i+3] = -_netLoad.moment[i]\\n\\n # fill in the remaining rows\\n for i, j in enumerate(rSet):\\n # i = fastener\\n # j = row\\n\\n rX = j[0]\\n rY = j[1]\\n rZ = j[2]\\n\\n # Mx = (y_cg - y_i)F_znet - (z_cg - z_i)F_ynet + M_xnet\\n soln_mat[rX] = - ((_cg[1] - F[i].xyz[1]) * _netLoad.force[2]\\n - (_cg[2] - F[i].xyz[2]) * _netLoad.force[1]\\n + _netLoad.moment[0])\\n\\n # My = (z_cg - z_i)F_xnet - (x_cg - x_i)F_znet + M_ynet\\n soln_mat[rY] = -((_cg[2] - F[i].xyz[2]) * _netLoad.force[0]\\n - (_cg[0] - F[i].xyz[0]) * _netLoad.force[2]\\n + _netLoad.moment[1])\\n\\n # Mz = (x_cg - x_i)F_ynet - (y_cg - y_i)F_xnet + M_znet\\n soln_mat[rZ] = -((_cg[0] - F[i].xyz[0]) * _netLoad.force[1]\\n - (_cg[1] - F[i].xyz[1]) * _netLoad.force[0]\\n + _netLoad.moment[2])\\n\\n # Solve system of equations\\n matSol = np.linalg.lstsq(coef_mat, soln_mat)[0]\\n\\n # Add resulting fastener loads to fastener objects\\n for i, j in enumerate(cSet):\\n rX = j[0]\\n rY = j[1]\\n rZ = j[2]\\n\\n F[i].force[0] = matSol[rX]\\n F[i].force[1] = matSol[rY]\\n F[i].force[2] = matSol[rZ]\",\n \"def step(self):\\n # A = self.array\\n # B = self.array2\\n # ra, rb, f, k = self.params\\n H = self.array\\n L = self.array2\\n birth_rate, death_rate, a, c = self.params\\n \\n # cA = correlate2d(A, self.kernel, **self.options)\\n # cB = correlate2d(B, self.kernel, **self.options)\\n cH = correlate2d(H, self.kernel,**self.options)\\n cL = correlate2d(L, self.kernel, **self.options)\\n\\n # reaction = A * B**2\\n\\n # self.array += ra * cA - reaction + f * (1-A) \\n # self.array2 += rb * cB + reaction - (f+k) * B\\n self.array += birth_rate*cH - a*L*H\\n self.array2 += c*cL*cH - death_rate*L\",\n \"def efSolver2(self):\\n dx = self.dh[0] # dx\\n dy = self.dh[1] # dy\\n dz = self.dh[2] # dz\\n \\n \\\"\\\"\\\"\\n for i in np.arange(0, self.ni):\\n for j in np.arange(0, self.nj):\\n for k in np.arange(0, self.nk):\\n \\\"\\\"\\\"\\n\\n ##x-component#\\n #if i==0: \\n #x-component#\\n \\\"\\\"\\\"\\n if i==0: \\n # forward\\n self.ef[i][j][k][0] = -(-3*self.phi[i][j][k]+\\\\\\n 4*self.phi[i+1][j][k]-\\\\\\n self.phi[i+2][j][k])/(2*dx)\\n \\\"\\\"\\\"\\n \\n # forward\\n self.ef[0,0:self.nj,0:self.nk,0] = -(-3*self.phi[0,0:self.nj,0:self.nk]+\\\\\\n 4*self.phi[1,0:self.nj,0:self.nk]-\\\\\\n self.phi[2,0:self.nj,0:self.nk])/(2*dx)\\n \\n #elif i==self.ni-1: \\n \\\"\\\"\\\"\\n elif i==self.ni-1: \\n # backward\\n self.ef[i][j][k][0] = -(self.phi[i-2][j][k]-\\\\\\n 4*self.phi[i-1][j][k]+\\\\\\n 3*self.phi[i][j][k])/(2*dx)\\n \\\"\\\"\\\" \\n # backward\\n self.ef[self.ni-1,0:self.nj,0:self.nk,0] = -(self.phi[self.ni-3,0:self.nj,0:self.nk]-\\\\\\n 4*self.phi[self.ni-2,0:self.nj,0:self.nk]+\\\\\\n 3*self.phi[self.ni-1,0:self.nj,0:self.nk])/(2*dx)\\n \\\"\\\"\\\"\\n else: \\n #central\\n self.ef[i][j][k][0] = -(self.phi[i+1][j][k] - \\\\\\n self.phi[i-1][j][k])/(2*dx)\\n \\\"\\\"\\\" \\n #central\\n self.ef[1:self.ni-1,0:self.nj,0:self.nk,0] = -(self.phi[2:self.ni,0:self.nj,0:self.nk] - \\\\\\n self.phi[0:self.ni-2,0:self.nj,0:self.nk])/(2*dx)\\n\\n\\n #y-component\\n #if j==0:\\n \\\"\\\"\\\"\\n if j==0:\\n self.ef[i][j][k][1] = -(-3*self.phi[i][j][k] + \\\\\\n 4*self.phi[i][j+1][k]-\\\\\\n self.phi[i][j+2][k])/(2*dy)\\n \\n \\\"\\\"\\\"\\n self.ef[0:self.ni,0,0:self.nk,1] = -(-3*self.phi[0:self.ni,0,0:self.nk] + \\\\\\n 4*self.phi[0:self.ni,1,0:self.nk]-\\\\\\n self.phi[0:self.ni,2,0:self.nk])/(2*dy)\\n #elif j==self.nj-1:\\n \\\"\\\"\\\"\\n elif j==self.nj-1:\\n self.ef[i][j][k][1] = -(self.phi[i][j-2][k] - \\\\\\n 4*self.phi[i][j-1][k] +\\\\\\n 3*self.phi[i][j][k])/(2*dy)\\n \\n \\\"\\\"\\\"\\n self.ef[0:self.ni,self.nj-1,0:self.nk,1] = -(self.phi[0:self.ni,self.nj-3,0:self.nk] - \\\\\\n 4*self.phi[0:self.ni,self.nj-2,0:self.nk] +\\\\\\n 3*self.phi[0:self.ni,self.nj-1,0:self.nk])/(2*dy)\\n #else:\\n \\\"\\\"\\\"\\n else:\\n self.ef[i][j][k][1] = -(self.phi[i][j+1][k] - \\\\\\n self.phi[i][j-1][k])/(2*dy)\\n\\n \\\"\\\"\\\"\\n self.ef[0:self.ni,1:self.nj-1,0:self.nk,1] = -(self.phi[0:self.ni,2:self.nj,0:self.nk] - \\\\\\n self.phi[0:self.ni,0:self.nj-2,0:self.nk])/(2*dy)\\n\\n #z-component\\n '''\\n if k==0:\\n self.ef[i][j][k][2] = -(-3*self.phi[i][j][k] + \\\\\\n 4*self.phi[i][j][k+1]-\\n self.phi[i][j][k+2])/(2*dz)\\n \\n '''\\n #z-component\\n #if k==0:\\n self.ef[0:self.ni,0:self.nj,0,2] = -(-3*self.phi[0:self.ni,0:self.nj,0] + \\\\\\n 4*self.phi[0:self.ni,0:self.nj,1]-\\n self.phi[0:self.ni,0:self.nj,2])/(2*dz)\\n\\n \\\"\\\"\\\"\\n elif k==self.nk-1:\\n self.ef[i][j][k][2] = -(self.phi[i][j][k-2] - \\\\\\n 4*self.phi[i][j][k-1] + \\\\\\n 3*self.phi[i][j][k])/(2*dz)\\n \\\"\\\"\\\"\\n \\n #elif k==self.nk-1:\\n self.ef[0:self.ni,0:self.nj,self.nk-1,2] = -(self.phi[0:self.ni,0:self.nj,self.nk-3] - \\\\\\n 4*self.phi[0:self.ni,0:self.nj,self.nk-2] + \\\\\\n 3*self.phi[0:self.ni,0:self.nj,self.nk-1])/(2*dz) \\n \\\"\\\"\\\"\\n else:\\n self.ef[i][j][k][2] = -(self.phi[i][j][k+1] - \\\\\\n self.phi[i][j][k-1])/(2*dz)\\n \\\"\\\"\\\"\\n #else:\\n self.ef[0:self.ni,0:self.nj,1:self.nk-1,2] = -(self.phi[0:self.ni,0:self.nj,2:self.nk] - \\\\\\n self.phi[0:self.ni,0:self.nj,0:self.nk-2])/(2*dz)\",\n \"def findphase(self):\\n debug('ControllerStartup.findphase()')\\n if not self.pidevice.HasFPH() or self.prop['skipfph']:\\n return\\n if not self._databuf['cstdone']:\\n debug('no need to do find phase for axes %r', self.pidevice.axes)\\n return\\n for axis in self._databuf['cstdone']:\\n if self.pidevice.qFRF(axis)[axis]:\\n self.pidevice.FPH(axis)\\n waitonphase(self.pidevice, **self._kwargs)\\n self.pidevice.WPA()\\n else:\\n info('skip find phase for axis while axis %s is not referenced' % axis)\",\n \"def applyCal(beam, row, freqs, freqs_cal, cf, T_d_x, T_d_y):\\n \\n P_sys_xx = beam.cols.xx[row].astype('float')\\n xx_on = beam.cols.xx_cal_on[row].astype('float')\\n xx_off = beam.cols.xx_cal_off[row].astype('float')\\n P_on_xx = np.average(extractMid(xx_on))\\n P_off_xx = np.average(extractMid(xx_off))\\n \\n #P_on_xx = fitLine(freqs_cal, xx_on, len(freqs))\\n #P_off_xx = fitLine(freqs_cal, xx_off, len(freqs))\\n\\n P_sys_yy = beam.cols.yy[row].astype('float')\\n yy_on = beam.cols.yy_cal_on[row].astype('float')\\n yy_off = beam.cols.yy_cal_off[row].astype('float')\\n P_on_yy = np.average(extractMid(yy_on))\\n P_off_yy = np.average(extractMid(yy_off))\\n \\n #P_on_yy = fitLine(freqs_cal, yy_on, len(freqs))\\n #P_off_yy = fitLine(freqs_cal, yy_off, len(freqs))\\n\\n \\n T_sys_xx = P_sys_xx / (cf*P_on_xx - cf*P_off_xx) * T_d_x\\n T_sys_yy = P_sys_yy / (cf*P_on_yy - cf*P_off_yy) * T_d_y\\n \\n return T_sys_xx, T_sys_yy\",\n \"def do_calibration(x,y,z,temperature,cp, optimal_t=25):\\n # if temperature is used for calibration:\\n if temperature is not None:\\n # create an array of T - optimal_T (temperature minus the optimal temperature) i.e. the deviation in T from the optimum\\n temp_dev = np.empty(len(temperature.data))\\n for i in range(len(temperature.data)):\\n temp_dev[i] = temperature.data[i] - optimal_t\\n\\n x.data = cp[\\\"x_offset\\\"] + (temp_dev * cp[\\\"x_temp_offset\\\"]) + (x.data * cp[\\\"x_scale\\\"])\\n y.data = cp[\\\"y_offset\\\"] + (temp_dev * cp[\\\"y_temp_offset\\\"]) + (y.data * cp[\\\"y_scale\\\"])\\n z.data = cp[\\\"z_offset\\\"] + (temp_dev * cp[\\\"z_temp_offset\\\"]) + (z.data * cp[\\\"z_scale\\\"])\\n\\n x.temp_offset = cp[\\\"x_temp_offset\\\"]\\n y.temp_offset = cp[\\\"y_temp_offset\\\"]\\n z.temp_offset = cp[\\\"z_temp_offset\\\"]\\n\\n # if temperature is not used for calibration:\\n else:\\n x.data = cp[\\\"x_offset\\\"] + (x.data * cp[\\\"x_scale\\\"])\\n y.data = cp[\\\"y_offset\\\"] + (y.data * cp[\\\"y_scale\\\"])\\n z.data = cp[\\\"z_offset\\\"] + (z.data * cp[\\\"z_scale\\\"])\\n\\n x.offset = cp[\\\"x_offset\\\"]\\n x.scale = cp[\\\"x_scale\\\"]\\n x.calibrated = True\\n\\n y.offset = cp[\\\"y_offset\\\"]\\n y.scale = cp[\\\"y_scale\\\"]\\n y.calibrated = True\\n\\n z.offset = cp[\\\"z_offset\\\"]\\n z.scale = cp[\\\"z_scale\\\"]\\n z.calibrated = True\",\n \"def solve(self, F, u0=None, maxiter=100, rtol=1.e-6, rtol2=1.e-6 \\\\\\n , verbose=False, update=False):\\n # assembly the stifness matrix and bc terms\\n poisson.assembly(self, update=update)\\n\\n # project u0 onto the discrete vectorial space\\n self.initialize(u0=u0)\\n\\n # ...\\n PDE = self\\n V = PDE.space\\n un = PDE.unknown\\n rhs = self.rhs\\n # ...\\n\\n rhs.func = F\\n\\n # ...\\n from time import time\\n list_Err = [1.e6]\\n list_ErrH1 = [1.e6]\\n un_values = un.get()\\n normH1_old = np.dot(PDE.dot(un.get()), un.get())\\n i = 0\\n if verbose:\\n tb = time()\\n while (list_Err[-1] > rtol) and (list_ErrH1[-1] > rtol2) and (i < maxiter):\\n U_old_values = un.get()\\n# print \\\"-------\\\"\\n# print \\\"solve\\\"\\n# import matplotlib.pyplot as plt\\n## Phi = PDE.G_W\\n# Phi = PDE.unknown_dirichlet\\n## Phi.plot(withpcolor=True) ; plt.colorbar() ; plt.show()\\n# Phi.fast_plot() ; plt.colorbar() ; plt.show()\\n# print \\\"-------\\\"\\n\\n # assembly the right hand side\\n rhs.reset()\\n self.update()\\n # solve and update unew\\n poisson.solve(self, rhs)\\n\\n U_values = un.get()\\n err = np.linalg.norm(U_values-U_old_values)\\n list_Err.append(err)\\n\\n normH1 = np.dot(PDE.dot(un.get()), un.get())\\n list_ErrH1.append(np.abs(normH1-normH1_old))\\n\\n normH1_old = normH1\\n\\n i += 1\\n if verbose:\\n print(i, \\\": \\\",\\\" |F(x)| = \\\", list_Err[-1],\\\" |DF(x)| = \\\", list_ErrH1[-1])\\n if verbose:\\n te = time()\\n print(\\\">> Elapsed time \\\", te-tb)\\n\\n list_Err = np.asarray(list_Err[1:])\\n list_ErrH1 = np.asarray(list_ErrH1[1:])\\n return list_Err, list_ErrH1\",\n \"def baseline_correct(self):\\n\\n x_a = np.arange(0, len(self.phased))\\n # vector the same length as the data in one direction\\n\\n base = np.zeros((dim_matrix, dim_matrix))\\n for i in range(0, len(self.phased)):\\n phased_baseline = np.polyfit(x_a, self.phased[i, :], 3)\\n # baseline correct in y direction\\n baseline = np.polyval(phased_baseline, x_a)\\n self.phased[i, :] = self.phased[i, :]-baseline\\n base[i, :] = baseline\\n\\n for i in range(0, len(self.phased)):\\n phased_baseline = np.polyfit(x_a, self.phased[:, i], 3)\\n # baseline correct in x direction\\n baseline = np.polyval(phased_baseline, x_a)\\n self.phased[:, i] = self.phased[:, i]-baseline\\n base[:, i] = base[:, i]+baseline\\n self.baseline_corrected = self.phased\\n\\n return self.baseline_corrected\",\n \"def _solve(self) -> CasADiArrayType:\\n solver_input = {\\\"x0\\\": self.x0, \\\"p\\\": self.p}\\n if self.opt_type in CONSTRAINED_OPT:\\n solver_input[\\\"lbg\\\"] = self._lbg\\n solver_input[\\\"ubg\\\"] = self._ubg\\n self._solution = self._solver(**solver_input)\\n self._stats = self._solver.stats()\\n self._stats[\\\"solution\\\"] = self._solution\\n return self._solution[\\\"x\\\"]\",\n \"def calibrate(self, Otrain, Ftrain, Feval):\\n return Otrain[0] * np.ones(len(Feval))\",\n \"def solve(self):\",\n \"def _compute_correction(self, initial_state, final_state, a, b, c, s):\\r\\n pertub = self.pertub\\r\\n pertub_s = pertub *10\\r\\n \\r\\n pred_no_pertub = self._motion_update_one_shot(initial_state, a, b, c, s)\\r\\n pred_pertub_a = self._motion_update_one_shot(initial_state, a +pertub, b, c, s)\\r\\n pred_pertub_b = self._motion_update_one_shot(initial_state, a, b +pertub, c, s)\\r\\n # no need to correct C, C is constrained by kappa_final\\r\\n # # pred_pertub_c = self._motion_update_one_shot(initial_state, a, b, c +pertub, s)\\r\\n pred_pertub_s = self._motion_update_one_shot(initial_state, a, b, c, s +pertub_s)\\r\\n\\r\\n d_state = np.zeros((3,1))\\r\\n d_pertub_state = np.zeros((3,3))\\r\\n Jacobian = np.zeros((3,3))\\r\\n for i in range(0, 3):\\r\\n d_pertub_state[i][0] = (final_state[i] - pred_pertub_a[i]) # a\\r\\n d_pertub_state[i][1] = (final_state[i] - pred_pertub_b[i]) # b\\r\\n # d_pertub_state[i][2] = (final_state[i] - pred_pertub_c[i]) # c (no update)\\r\\n d_pertub_state[i][2] = (final_state[i] - pred_pertub_s[i]) # s\\r\\n \\r\\n d_state[i] = final_state[i] - pred_no_pertub[i]\\r\\n \\r\\n Jacobian[i][0] = (d_pertub_state[i][0] - d_state[i])/pertub # a\\r\\n Jacobian[i][1] = (d_pertub_state[i][1] - d_state[i])/pertub # b\\r\\n # Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub # c (no update)\\r\\n Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub_s # s\\r\\n\\r\\n # inv_Jacobian = np.linalg.inv(Jacobian)\\r\\n inv_Jacobian = np.linalg.pinv(Jacobian)\\r\\n correction = np.dot(inv_Jacobian, d_state)\\r\\n # pdb.set_trace()\\r\\n return correction\",\n \"def compute_camera_calib_distortion_params():\\r\\n nx = 9#number of inside corners in x\\r\\n ny = 6#number of inside corners in y\\r\\n # prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)\\r\\n objp = np.zeros((ny*nx,3), np.float32)\\r\\n objp[:,:2] = np.mgrid[0:nx, 0:ny].T.reshape(-1,2)\\r\\n\\r\\n # Arrays to store object points and image points from all the images.\\r\\n objpoints = [] # 3d points in real world space\\r\\n imgpoints = [] # 2d points in image plane.\\r\\n\\r\\n # Read a particular image just to get image size (all images in the directory are same size)\\r\\n img = cv2.imread('./camera_cal/calibration3.jpg')\\r\\n img_size = (img.shape[1], img.shape[0])\\r\\n # Make a list of calibration images\\r\\n images = glob.glob('./camera_cal/calibration*.jpg')\\r\\n # Step through the list and search for chessboard corners\\r\\n for idx, fname in enumerate(images):\\r\\n img = cv2.imread(fname)\\r\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\r\\n\\r\\n # Find the chessboard corners\\r\\n ret, corners = cv2.findChessboardCorners(gray, (nx,ny), None)\\r\\n\\r\\n # If found, add object points, image points\\r\\n if ret == True:\\r\\n objpoints.append(objp)\\r\\n imgpoints.append(corners)\\r\\n # # Draw and display the corners\\r\\n # cv2.drawChessboardCorners(img, (nx,ny), corners, ret)\\r\\n # #write_name = 'corners_found'+str(idx)+'.jpg'\\r\\n # #cv2.imwrite(write_name, img)\\r\\n # cv2.imshow('img', img)\\r\\n # cv2.waitKey(500)\\r\\n\\r\\n # Do camera calibration given object points and image points\\r\\n ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, img_size,None,None)\\r\\n # Save the camera calibration result for later use (we won't worry about rvecs / tvecs)\\r\\n dist_pickle = {}\\r\\n dist_pickle[\\\"mtx\\\"] = mtx\\r\\n dist_pickle[\\\"dist\\\"] = dist\\r\\n pickle.dump( dist_pickle, open( \\\"data/cam_calib_pickle.p\\\", \\\"wb\\\" ) )\\r\\n print(\\\"Pickling done\\\")\",\n \"def solve_l1(y, A_fun, AT_fun, lambda_l1, reshape_img_fun, show_img_progress=False, alpha=0.2, max_iter=100, solver_tol=1e-6):\\n\\n\\n obj_lss = np.zeros(max_iter)\\n x_zs = np.zeros(max_iter)\\n u_norms = np.zeros(max_iter)\\n times = np.zeros(max_iter)\\n\\n ATy = AT_fun(y)\\n x_shape = ATy.shape\\n d = np.prod(x_shape)\\n\\n def A_cgs_fun(x):\\n x = np.reshape(x, x_shape, order='F')\\n y = AT_fun(A_fun(x)) + alpha * x\\n return vec(y)\\n A_cgs = LinearOperator((d,d), matvec=A_cgs_fun, dtype='float')\\n\\n def compute_p_inv_A(b, z0):\\n (z,info) = sp.sparse.linalg.cgs(A_cgs, vec(b), x0=vec(z0), tol=1e-3, maxiter=100)\\n if info > 0:\\n print('cgs convergence to tolerance not achieved')\\n elif info <0:\\n print('cgs gets illegal input or breakdown')\\n z = np.reshape(z, x_shape, order='F')\\n return z\\n\\n\\n def A_cgs_fun_init(x):\\n x = np.reshape(x, x_shape, order='F')\\n y = AT_fun(A_fun(x))\\n return vec(y)\\n A_cgs_init = LinearOperator((d,d), matvec=A_cgs_fun_init, dtype='float')\\n\\n def compute_init(b, z0):\\n (z,info) = sp.sparse.linalg.cgs(A_cgs_init, vec(b), x0=vec(z0), tol=1e-2)\\n if info > 0:\\n print('cgs convergence to tolerance not achieved')\\n elif info <0:\\n print('cgs gets illegal input or breakdown')\\n z = np.reshape(z, x_shape, order='F')\\n return z\\n\\n # initialize z and u\\n z = compute_init(ATy, ATy)\\n u = np.zeros(x_shape)\\n\\n\\n plot_normalozer = matplotlib.colors.Normalize(vmin=0.0, vmax=1.0, clip=True)\\n\\n\\n start_time = timeit.default_timer()\\n\\n for iter in range(max_iter):\\n\\n # x-update\\n net_input = z+u\\n Wzu, wbook = wavelet_transform(net_input)\\n q = soft_threshold(Wzu, lambda_l1/alpha)\\n x = inverse_wavelet_transform(q, wbook, x_shape)\\n x = np.reshape(x, x_shape)\\n\\n # z-update\\n b = ATy + alpha * (x - u)\\n z = compute_p_inv_A(b, z)\\n\\n # u-update\\n u += z - x;\\n\\n if show_img_progress == True:\\n\\n fig = plt.figure('current_sol')\\n plt.gcf().clear()\\n fig.canvas.set_window_title('iter %d' % iter)\\n plt.subplot(1,3,1)\\n plt.imshow(reshape_img_fun(np.clip(x, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\\n plt.title('x')\\n plt.subplot(1,3,2)\\n plt.imshow(reshape_img_fun(np.clip(z, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\\n plt.title('z')\\n plt.subplot(1,3,3)\\n plt.imshow(reshape_img_fun(np.clip(net_input, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\\n plt.title('netin')\\n plt.pause(0.00001)\\n\\n\\n obj_ls = 0.5 * np.sum(np.square(y - A_fun(x)))\\n x_z = np.sqrt(np.mean(np.square(x-z)))\\n u_norm = np.sqrt(np.mean(np.square(u)))\\n\\n print('iter = %d: obj_ls = %.3e |x-z| = %.3e u_norm = %.3e' % (iter, obj_ls, x_z, u_norm))\\n\\n\\n obj_lss[iter] = obj_ls\\n x_zs[iter] = x_z\\n u_norms[iter] = u_norm\\n times[iter] = timeit.default_timer() - start_time\\n\\n if x_z < solver_tol:\\n break\\n\\n infos = {'obj_lss': obj_lss, 'x_zs': x_zs, 'u_norms': u_norms,\\n 'times': times, 'alpha':alpha, 'lambda_l1':lambda_l1,\\n 'max_iter':max_iter, 'solver_tol':solver_tol}\\n\\n\\n return (x, z, u, infos)\",\n \"def arm_calibration(self):\\n self.arm_motor.run_forever(speed_sp=900)\\n while not self.touch_sensor.is_pressed:\\n time.sleep(0.01)\\n self.arm_motor.stop(stop_action=\\\"brake\\\")\\n ev3.Sound.beep()\\n self.arm_motor.run_to_rel_pos(\\n speed_sp=900, position_sp=-5100)\\n self.arm_motor.wait_while(ev3.Motor.STATE_RUNNING)\\n print('motor is no longer running')\\n ev3.Sound.beep()\\n self.arm_motor.position = 0\",\n \"def calibration(exp, args):\\n show_text(\\\"Nous allons faire un calibrage\\\", args).present()\\n exp.clock.wait(1500)\\n expyriment.stimuli.FixCross(size=(25, 25),\\n line_width=3,\\n colour=args[\\\"stimuli_color\\\"]).present()\\n exp.clock.wait(2100)\",\n \"def _evolve(\\n self,\\n x0_idx: int,\\n ) -> np.ndarray:\\n x0 = self.starting_points[x0_idx, :]\\n if type(x0) != np.ndarray:\\n x0 = x0.toarray()\\n x0 = x0.flatten()\\n # [T, Dims, (Position, Velocity)]\\n trajectory = np.zeros(\\n (self.timesteps, x0.shape[0], 3), dtype=np.float32)\\n \\n # for each timestep, update the position of the phase point\\n # based on the velocity of nearest neighbors and obey any\\n # boundary constraints\\n x = x0\\n for t in range(self.timesteps):\\n trajectory[t, :, 0] = x # match x position to dv/dx\\n v = self.v_fxn(x=x.reshape(-1),)\\n # add white noise if desired to better emulate a stochastic process\\n noise = v[:, 1] * np.random.randn(v.shape[0]) * self.noise_scale\\n x_new = x + (v[:, 0] + noise)*self.step_scale\\n # constrain to a set of pre-defined boundaries\\n # defaults to an identity if not set explicitly\\n x_new = self.boundary_constraint(x_new)\\n trajectory[t, :, 1] = v[:, 0]\\n trajectory[t, :, 2] = v[:, 1]\\n x = x_new\\n return trajectory\",\n \"def start_solving(self):\\n self.mesh.output_vtk_mesh(self.model_name + \\\"0\\\", \\n [self.current_pressure, \\n self.mesh.get_cell_domain_all()], \\n [\\\"pressure\\\", \\\"domain\\\"])\\n\\n self.time_step_output(0., 0)\\n\\n for time_step in range(1,self.number_of_time_steps+1):\\n current_time = time_step*self.delta_t\\n print(time_step)\\n\\n self.update_pressure()\\n self.find_upwinding_direction()\\n self.update_concentration()\\n \\n if time_step%self.output_frequency == 0:\\n self.mesh.output_vtk_mesh(self.model_name+str(time_step), \\n [self.current_pressure,\\n self.current_concentration, \\n self.mesh.get_cell_domain_all()],\\n [\\\"pressure\\\", \\\"concentration\\\" , \\\"domain\\\"])\\n\\n self.time_step_output(current_time, time_step)\",\n \"def step(self):\\n #for the first step, we calculate only with the previous state\\n if self.isFirstStep:\\n F = (self.pot.f)(self.x, self.U)\\n self.isFirstStep = False\\n #else, we calculate with the previous step and the one before to keep the second order accuracy\\n else:\\n F = 3/2*(self.pot.f)(self.x, self.U)-1/2*(self.pot.f)(self.x, self.oldU)\\n self.oldU = np.copy(self.U)\\n C = self.B.dot(self.U)+self.dt*F\\n C[0] = 0\\n C[-1] = 0\\n self.U = lin.solve_banded((1,1), self.A, C)\",\n \"def calibration(N,kb,T,Ekinv,V):\\n lamb = np.sqrt((N-1)*3*kb*T/(Ekinv*2))\\n \\n if lamb < 0.9999:\\n V = lamb*V\\n elif lamb>1.0001:\\n V = lamb*V\\n \\n return V\",\n \"def objective(trial):\\n # The parameters that we will calibrate the model for are shown here.\\n # Optuna trial i\\n BOD = trial.suggest_uniform(\\\"BOD\\\", 0, 1) #Review ranges here\\n k_r = trial.suggest_uniform(\\\"k_r\\\", 0, 1) #Review Ranges here \\n \\n def ChLa(t):\\n return 1 # Need to link to data\\n\\n def I(x):\\n return 1 # Need to link to data\\n\\n K_z = 2 * 10**(-5) # p.51\\n a = K_z\\n k_b = 0.1 # Table 5\\n th_b = 1.047 # Table 5\\n k_r = 0.1 # Table 5\\n YCHO2 = 0.0083 # Table 5\\n th_p = 1.036 # Table 5\\n th_s = 1.065 # Table 5\\n th_r = 1.047 # Table 5\\n\\n def Temp(t):\\n \\\"\\\"\\\"\\n Function that maps time to temperature\\n \\\"\\\"\\\"\\n return 20 # Need to link to data\\n\\n def P_max(t):\\n return 9.6 * 1.036 **(Temp(t) - 20) # Eq. 4\\n\\n def L_min(t):\\n I = 1 # Need to link to PAR data\\n K_1 = 0.687 * 1.086**(Temp(t) - 20)\\n K_2 = 15\\n return I * (1 + 2 * np.sqrt(K_1 / K_2)) / (I + K_1 + I**2 / K_2) # Eq. 5\\n \\n # f deals with sink and source terms \\n def f(x, t):\\n return -1 / YCHO2 * k_r * th_r**(Temp(t) - 20) * ChLa(t) + P_max(t) * L_min(t) * ChLa(t) - k_b * th_b**(Temp(t)-20) * BOD \\n\\n L = 200 # Length of domain\\n dt = 1 / 48 # Mesh spacing in t\\n F = a * dt # a * dt / dx**2\\n T = 100 # Simulation time stop\\n\\n # Solving the PDE\\n DO, x, t, _ = solver_FE_simple(I, a, f, L, dt, F, T)\\n \\n # Creating some bogus targets while database errors are happening\\n DO_data = DO + np.random.random(len(DO))\\n\\n # Using mean squared error as the measure of fit, where we want\\n # to minimize this number\\n return ((DO - DO_data)**2).mean()\",\n \"def step_autocorrelation(self):\\n\\n max_hops = max([len(x) for x in self.steps])\\n\\n self.acf = np.zeros([len(self.steps), max_hops])\\n\\n keep = [] # list to hold indices of trajectories with a non-zero amount of hops\\n for i in range(len(self.steps)):\\n hops = self.steps[i]\\n if len(hops) > 1:\\n self.acf[i, :len(self.steps[i])] = timeseries.acf(self.steps[i])\\n keep.append(i)\\n\\n self.acf = self.acf[keep, :]\\n\\n self.acf = np.array([self.acf[np.nonzero(self.acf[:, i]), i].mean() for i in range(max_hops)])\\n\\n #self.acf = timeseries.step_autocorrelation(self.z_interpolated.T[..., np.newaxis])\",\n \"def ekf_algorithm(self, u, y):\\n x_est_before = self.x_estimated_state\\n cov_matrix_before = self.cov_matrix\\n # 1. Prediction\\n # predict the state by integrate the time continuous system numerically\\n sim_state_predict = self.heliSim.calc_step(u[0][0], u[1][0], self.no_disturbance_eval)\\n x_est_predict = np.resize(sim_state_predict, (8, 1))\\n # predict the new covariance by linearizing and discretizing the model\\n Ak, Bk, Ck, Dk = self.get_linear_discrete_matrices(x_est_before, u[0][0], u[1][0])\\n cov_matrix_predict = Ak @ cov_matrix_before @ np.transpose(Ak) + Bk @ self.N @ np.transpose(Bk)\\n # 2. Update\\n # compute kalman gain\\n Kl = cov_matrix_predict @ np.transpose(Ck) @ np.linalg.inv(Ck @ cov_matrix_predict @ np.transpose(Ck) + self.W)\\n # update state\\n y_est = np.concatenate((x_est_predict[0:3], x_est_predict[6:8]))\\n x_est_update = x_est_predict + Kl @ (y - y_est)\\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ Ck) @ cov_matrix_predict\\n\\n corrected_state = self.heliSim.get_limited_state_and_change_state(x_est_update.reshape((1, 8))[0],\\n ModelType.GYROMOMENT)\\n # corrected_state = x_est_update\\n x_est_update = np.resize(corrected_state, (8, 1))\\n\\n self.x_estimated_state = x_est_update\\n self.cov_matrix = cov_matrix_update\\n # print(\\\"------\\\")\\n # print(cov_matrix_predict)\\n return x_est_update\",\n \"def phase(self):\\n pass\",\n \"def F_cont(self):\\n x0 = self.edp_par['x0'].value\\n A = self.edp_par['A'].value\\n f1 = self.edp_par['f1'].value\\n f2 = self.edp_par['f2'].value\\n lr = self.latt_par['lambda_r'].value\\n w = 0.5 * (self.qx*x0 + self.qz*A)\\n arg1 = 0.5*self.qx*lr + w\\n arg2 = 0.5*self.qx*lr - w\\n fir = x0 * np.sin(w) / lr / w\\n sec = (lr-x0) * np.cos(0.5*arg1) * np.sin(arg2) / lr / np.cos(0.5*arg2) / arg2 \\n #sec = (-1)**self.k * (lr-x0) * sin(self.k*pi-w)/(self.k*pi-w)/lr\\n return (fir + f1*sec + 2*f2*np.cos(w)/lr)\",\n \"def azizen(self):\\n # x0,y0 array pixel coordinates relative to cx,cy\\n# ndy0,ndx0=img.shape\\n ndy0=self.ndy0\\n ndx0=self.ndx0\\n x0,y0=np.meshgrid(np.linspace(0,ndx0-1,ndx0)-self.cx,np.linspace(0,ndy0-1,ndy0)-self.cy)\\n r0=np.sqrt(x0**2+y0**2)/self.pr0 # fractional radial distance from 0,0\\n# self.roi=np.s_[ystart:ystart+self.ny0,xstart:xstart+self.nx0]\\n # why not model the zenith angle dependence with polynomial directly\\n # rather than linear interpolation between roots.\\n roots=np.zeros(51)\\n rr=np.arange(51)/100.0\\n for i,ref in enumerate(rr):\\n roots[i]=np.real(np.roots([self.c3,0,self.c2,0,self.c1,-ref])[-1])\\n theta0 = np.interp(r0/2,rr,roots)\\n \\n phi0 = np.arctan2(x0,y0) - self.rot ####phi (i.e., azimuth) is reckoned with -pi corresponding to north, increasing clockwise, NOTE: pysolar use sub-standard definition\\n phi0 = phi0%(2*np.pi)\\n\\n #####correction for the tilt of the camera\\n k=np.array((np.sin(self.azm),np.cos(self.azm),0))\\n a=np.array([np.sin(theta0)*np.cos(phi0),np.sin(theta0)*np.sin(phi0),np.cos(theta0)]); \\n a = np.transpose(a,[1,2,0])\\n b=np.cos(self.beta)*a + np.sin(self.beta)*np.cross(k,a,axisb=2) \\\\\\n + np.reshape(np.outer(np.dot(a,k),k),(self.ndy0,self.ndx0,3))*(1-np.cos(self.beta))\\n theta0=np.arctan(np.sqrt(b[:,:,0]**2+b[:,:,1]**2)/b[:,:,2])\\n phi0=np.arctan2(b[:,:,1],b[:,:,0])%(2*np.pi)\\n# max_theta *= deg2rad \\n# valid0 = (theta0<max_theta) & (theta0>0); \\n# theta0[valid0]=np.nan;\\n self.theta0,self.phi0=theta0,phi0\",\n \"def on_iteration_start(self):\\n\\n self.Xfprv = self.Xf.copy()\\n if (not self.opt['FastSolve'] or isinstance(self.backtrack,\\n BacktrackRobust)):\\n self.Yfprv = self.Yf.copy()\\n\\n if self.opt['Monotone']:\\n if self.k == 0:\\n self.objfn = self.eval_objfn()\\n self.objfn_prev = self.objfn\",\n \"def reconstruct(self):\\n self.print_tee(\\\"starting reconstruction\\\", self.log_file)\\n\\n # #############################################\\n # estimate SIM parameters\\n # #############################################\\n # estimate frequencies\\n tstart = time.time() # since done using joblib, process_time() is not useful...\\n\\n if self.use_fixed_frq:\\n self.frqs = self.frqs_guess\\n self.print_tee(\\\"using fixed frequencies\\\", self.log_file)\\n else:\\n if self.find_frq_first:\\n self.frqs = self.estimate_sim_frqs(self.imgs_ft, self.imgs_ft, self.frqs_guess)\\n else:\\n self.print_tee(\\\"doing phase demixing prior to frequency finding\\\", self.log_file)\\n self.separated_components_ft = separate_components(self.imgs_ft, self.phases_guess, np.ones((self.nangles, self.nphases)))\\n imgs1 = np.expand_dims(self.separated_components_ft[:, 0], axis=1)\\n imgs2 = np.expand_dims(self.separated_components_ft[:, 1], axis=1)\\n self.frqs = self.estimate_sim_frqs(imgs1, imgs2, self.frqs_guess)\\n\\n tend = time.time()\\n self.print_tee(\\\"fitting frequencies took %0.2fs\\\" % (tend - tstart), self.log_file)\\n\\n # estimate phases\\n tstart = time.process_time()\\n if self.use_fixed_phase:\\n self.phases = self.phases_guess\\n self.amps = np.ones((self.nangles, self.nphases))\\n self.print_tee(\\\"Using fixed phases\\\", self.log_file)\\n else:\\n self.phases, self.amps = self.estimate_sim_phases(self.frqs, self.phases_guess)\\n\\n tend = time.process_time()\\n self.print_tee(\\\"estimated %d phases in %0.2fs\\\" % (self.nangles * self.nphases, tend - tstart), self.log_file)\\n\\n # separate components\\n self.separated_components_ft = separate_components(self.imgs_ft, self.phases, self.amps)\\n\\n # estimate modulation depths and power spectrum fit parameters\\n tstart = time.process_time()\\n # for the moment, need to do this feet even if have fixed mod depth, because still need the\\n # power spectrum parameters\\n self.mod_depths, self.power_spectrum_params, self.pspec_masks = self.estimate_mod_depths()\\n\\n if self.use_fixed_mod_depths:\\n self.mod_depths = np.zeros((self.nangles, self.nphases))\\n self.mod_depths[:, 0] = 1\\n for jj in range(1, self.nphases):\\n self.mod_depths[:, jj] = self.mod_depths_guess\\n\\n # also correct power spectrum params\\n self.power_spectrum_params[:, jj, 2] = self.mod_depths[:, jj]\\n\\n tend = time.process_time()\\n self.print_tee('estimated %d modulation depths in %0.2fs' % (self.nangles, tend - tstart), self.log_file)\\n\\n # #############################################\\n # estimate modulation contrast to noise ratio for raw images\\n # #############################################\\n mcnr = np.zeros((self.nangles, self.nphases))\\n for ii in range(self.nangles):\\n for jj in range(self.nphases):\\n mcnr[ii, jj] = get_mcnr(self.imgs_ft[ii, jj], self.frqs[ii], self.fx, self.fy, self.fmax)\\n\\n # if mcnr is too low (typically < 1), use guess values instead\\n if self.default_to_guess_on_low_mcnr and np.min(mcnr[ii]) < self.min_mcnr and self.frqs_guess is not None:\\n self.frqs[ii] = self.frqs_guess[ii]\\n self.print_tee(\\\"Angle %d/%d, minimum mcnr = %0.2f is less than the minimum value, %0.2f,\\\"\\n \\\" so fit frequency will be replaced with guess\\\"\\n % (ii + 1, self.nangles, np.min(mcnr[ii]), self.min_mcnr), self.log_file)\\n\\n for jj in range(self.nphases):\\n mcnr[ii, jj] = get_mcnr(self.imgs_ft[ii, jj], self.frqs[ii], self.fx, self.fy, self.fmax)\\n\\n self.mcnr = mcnr\\n # for convenience, also save periods and angles\\n self.periods = 1 / np.sqrt(self.frqs[:, 0] ** 2 + self.frqs[:, 1] ** 2)\\n self.angles = np.angle(self.frqs[:, 0] + 1j * self.frqs[:, 1])\\n\\n # #############################################\\n # estimate noise in component images\\n # #############################################\\n self.noise_power = self.power_spectrum_params[:, :, -1]\\n\\n # #############################################\\n # SIM reconstruction\\n # #############################################\\n tstart = time.process_time()\\n self.img_sr, self.img_sr_ft, self.components_deconvolved_ft, self.components_shifted_ft, \\\\\\n self.weights, self.weight_norm, self.snr, self.snr_shifted = self.combine_components()\\n # self.img_sr, self.img_sr_ft, self.components_deconvolved_ft, self.components_shifted_ft, \\\\\\n # self.weights, self.weight_norm, self.snr, self.snr_shifted = self.combine_components_fairSIM()\\n tend = time.process_time()\\n\\n self.print_tee(\\\"combining components took %0.2fs\\\" % (tend - tstart), self.log_file)\\n\\n # #############################################\\n # widefield deconvolution\\n # #############################################\\n # get signal to noise ratio\\n wf_noise = get_noise_power(self.widefield_ft, self.fx, self.fy, self.fmax)\\n fit_result, self.mask_wf = fit_power_spectrum(self.widefield_ft, self.otf, self.fx, self.fy, self.fmax, self.fbounds,\\n init_params=[None, self.power_spectrum_params[0, 0, 1], 1, wf_noise],\\n fixed_params=[False, True, True, True])\\n\\n self.pspec_params_wf = fit_result['fit_params']\\n ff = np.sqrt(self.fx[None, :]**2 + self.fy[:, None]**2)\\n sig = power_spectrum_fn([self.pspec_params_wf[0], self.pspec_params_wf[1], self.pspec_params_wf[2], 0], ff, 1)\\n wf_snr = sig / wf_noise\\n # deconvolution\\n wf_decon_ft, wfilter = wiener_deconvolution(self.widefield_ft, self.otf, wf_snr, snr_includes_otf=False)\\n\\n # upsample to make fully comparable to reconstructed image\\n self.widefield_deconvolution_ft = tools.expand_fourier_sp(wf_decon_ft, 2, 2, centered=True)\\n self.widefield_deconvolution = fft.fftshift(fft.ifft2(fft.ifftshift(self.widefield_deconvolution_ft))).real\\n\\n # #############################################\\n # print parameters\\n # #############################################\\n self.print_parameters()\\n\\n try:\\n self.log_file.close()\\n except AttributeError:\\n pass\",\n \"def calibrate(\\n self, acc: np.ndarray, gyr: np.ndarray, acc_unit: Optional[str], gyr_unit: Optional[str]\\n ) -> Tuple[np.ndarray, np.ndarray]:\\n raise NotImplementedError(\\\"This method needs to be implemented by a subclass\\\")\",\n \"def solve(self, solver):\\n solver.solve()\",\n \"def getCalibration(self):\\n self.a0 = float(self.getParameter(index=1))\\n self.a1 = float(self.getParameter(index=2))\\n self.a2 = float(self.getParameter(index=3))\\n self.a3 = float(self.getParameter(index=4))\\n status = self.getStatus()\\n self.wavelength = [ self.a0 + self.a1*x + self.a2*x*x + self.a3*x*x*x \\n for x in range(status.pixels)]\\n if self.discardTrailingSamples > 0:\\n self.wavelength = self.wavelength[:-self.discardTrailingSamples]\\n if self.discardLeadingSamples > 0:\\n self.wavelength = self.wavelength[self.discardLeadingSamples:]\",\n \"def calibrate(self, position):\\n current_position = self.robot._driver.get_plunger_positions()\\n current_position = current_position['target'][self.axis]\\n kwargs = {}\\n kwargs[position] = current_position\\n self.calibrate_plunger(**kwargs)\\n\\n return self\",\n \"def _finish_calibration(self, objpoints, imgpoints_l, imgpoints_r, shape):\\n left_camera = self.source._left._finish_calibration(objpoints, imgpoints_l, shape)\\n right_camera = self.source._right._finish_calibration(objpoints, imgpoints_r, shape)\\n\\n ret, M1, d1, M2, d2, R, T, E, F = cv2.stereoCalibrate(\\n objpoints,\\n imgpoints_l, imgpoints_r,\\n left_camera.matrix, left_camera.distortion,\\n right_camera.matrix, right_camera.distortion,\\n shape,\\n criteria=self._stereocalib_criteria, flags=self._flags)\\n\\n R1, R2, P1, P2, Q, vb1, vb2 = cv2.stereoRectify(\\n M1,\\n d1,\\n M2,\\n d2,\\n shape,\\n R,\\n T,\\n flags=cv2.CALIB_ZERO_DISPARITY)\\n\\n left_camera = PinholeCamera(shape, M1, d1, R1, P1)\\n right_camera = PinholeCamera(shape, M2, d2, R2, P2)\\n\\n return StereoCamera(left_camera, right_camera, R, T, E, F, Q)\",\n \"def ekf_algorithm(self, u, y):\\n x_est_before = self.x_estimated_state\\n cov_matrix_before = self.cov_matrix\\n # 1. Prediction\\n # predict the state by integrate the time continuous system numerically\\n sim_state_predict = self.heliSim.calc_step(u[0][0], u[1][0], self.no_disturbance_eval)\\n x_est_predict = np.resize(sim_state_predict, (6, 1))\\n # predict the new covariance by linearizing and discretizing the model\\n Ak, Bk, Ck, Dk = self.get_linear_discrete_matrices(x_est_before, u[0][0], u[1][0])\\n cov_matrix_predict = Ak @ cov_matrix_before @ np.transpose(Ak) + Bk @ self.N @ np.transpose(Bk)\\n # 2. Update\\n # compute kalman gain\\n Kl = cov_matrix_predict @ np.transpose(Ck) @ np.linalg.inv(Ck @ cov_matrix_predict @ np.transpose(Ck) + self.W)\\n # update state\\n y_est = x_est_predict[0:3, ]\\n x_est_update = x_est_predict + Kl @ (y - y_est)\\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ Ck) @ cov_matrix_predict\\n\\n # check if the update step state needs to be changed because of limit crossing\\n # if that is the case, correct the state and set the state of the simulation accordingly\\n # heliSim_state = np.resize(x_est_update, (1, 6))[0]\\n # heliSim_state = np.pad(heliSim_state, (0, 2), \\\"constant\\\")\\n corrected_state = self.heliSim.get_limited_state_and_change_state(x_est_update.reshape((1, 6))[0],\\n ModelType.EASY)\\n x_est_update = np.resize(corrected_state, (6, 1))\\n\\n self.x_estimated_state = x_est_update\\n self.cov_matrix = cov_matrix_update\\n return x_est_update\",\n \"def rm_calibration(self):\\n\\n self.bin_edges_kev = None\",\n \"def calibrate(this, display=False, **kargs): # C'est des maths.\\n\\t\\t# a -> Angle Alpha\\n\\t\\t# b -> Angle Beta\\n\\t\\t\\n\\t\\th = float(kargs.get('h', 1))\\n\\t\\tw = float(kargs.get('w', 1))\\n\\t\\t\\n\\t\\t# Verif de l'espace\\n\\t\\tspace = this._SPACE\\n\\t\\tif not space: return None\\n\\t\\t\\n\\t\\t#try:\\n\\t\\ttry:\\n\\t\\t\\n\\t\\t\\t# Calcul d'angles\\n\\t\\t\\ta = this._FOV.x * (space.i - space.o)\\n\\t\\t\\tb = this._FOV.x * (space.o - space.j)\\n\\t\\t\\n\\t\\t\\t# On essaye gentillement\\n\\t\\t\\tCa = w - h / math.tan(b)\\n\\t\\t\\tCb = h - w / math.tan(a)\\n\\t\\t\\tkx = Ca/Cb\\n\\t\\t\\t\\n\\t\\t\\t# Position finale\\n\\t\\t\\tthis._POS.x = x = h * (kx + 1 / math.tan(b)) / (1 + kx**2)\\n\\t\\t\\tthis._POS.y = x * kx\\n\\t\\t\\n\\t\\t# Erm\\n\\t\\texcept: this._POS = None\\n\\t\\t\\n\\t\\t# Petit affichage oklm\\n\\t\\tif display: print 'Calibration: %f %f %s' % (math.degrees(a), math.degrees(b), ~this._POS)\\n\\t\\treturn this._POS\",\n \"def __init__(self, dev, **kw):\\n AutomaticCalibrationRoutine.__init__(\\n self,\\n dev=dev,\\n **kw,\\n )\\n\\n self.final_init(**kw)\",\n \"def solve(self, regparam):\\n self.regparam = regparam\\n \\n #Some counters for bookkeeping\\n self.stepcounter = 0\\n self.flipcounter = 0\\n self.nochangecounter = 0\\n \\n #Cached results\\n self.evals = np.multiply(self.svals, self.svals)\\n self.newevals = 1. / (self.evals + self.regparam)\\n newevalslamtilde = np.multiply(self.evals, self.newevals)\\n self.D = np.sqrt(newevalslamtilde)\\n #self.D = -newevalslamtilde\\n \\n self.VTY = self.svecs.T * self.Y\\n DVTY = np.multiply(self.D.T, self.svecs.T * self.Y)\\n \\n #Using lists in order to avoid unnecessary matrix slicings\\n self.DVTY_list = []\\n self.YTVDDVTY_list = []\\n self.classFitnessList = []\\n for i in range(self.labelcount):\\n DVTY_i = DVTY[:,i]\\n self.DVTY_list.append(DVTY_i)\\n YTVDDVTY_i = DVTY_i.T * DVTY_i\\n self.YTVDDVTY_list.append(YTVDDVTY_i)\\n fitness_i = self.size - DVTY_i.T * DVTY_i\\n self.classFitnessList.append(fitness_i)\\n \\n self.Dsvecs_list = []\\n self.svecsDDsvecs_list = []\\n for i in range(self.size):\\n Dsvec = np.multiply(self.D.T, self.svecs[i].T)\\n self.Dsvecs_list.append(Dsvec)\\n self.svecsDDsvecs_list.append(Dsvec.T*Dsvec)\\n \\n self.updateA()\\n \\n \\n converged = False\\n print(self.classcounts.T)\\n if self.callbackfun is not None:\\n self.callbackfun.callback(self)\\n while True:\\n \\n converged = self.roundRobin()\\n print(self.classcounts.T)\\n if self.callbackfun is not None:\\n self.callbackfun.callback(self)\\n if converged: break\\n \\n if self.oneclass:\\n self.Y = self.Y[:, 0]\\n self.A = self.A[:, 0]\\n self.results['predicted_clusters_for_training_data'] = self.Y\\n self.predictor = self.svdad.createModel(self)\",\n \"def initialise_calibration(self):\\n for i in range(0, self.NUM_SENSORS):\\n self.calibratedMax[i] = 0\\n self.calibratedMin[i] = self.READING_TIMEOUT\",\n \"def _solve(self) -> CasADiArrayType:\\n\\n # Setup solver\\n self.m = osqp.OSQP()\\n self.m.setup(**self._setup_input)\\n\\n # Warm start optimization\\n if self.use_warm_start:\\n self.m.warm_start(x=self.x0.toarray().flatten())\\n\\n # Solve problem\\n self._solution = self.m.solve()\\n\\n return self._solution.x\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67444855","0.64102155","0.62887526","0.62739146","0.62539726","0.61133844","0.6096612","0.6041767","0.5968712","0.5952701","0.59089845","0.58992106","0.58605576","0.5847041","0.5796397","0.57910454","0.57832146","0.5780262","0.57560104","0.5751728","0.5705195","0.5689438","0.5655034","0.562459","0.56146675","0.56130666","0.56107885","0.5570062","0.55587846","0.55579436","0.55511415","0.55067855","0.5492958","0.5485608","0.5476281","0.54746795","0.54722226","0.5469433","0.5459025","0.54496074","0.54465026","0.54350334","0.54218525","0.5415067","0.54142404","0.54132503","0.5411288","0.54052514","0.54025954","0.5355776","0.5339396","0.5339082","0.5339027","0.53370374","0.5330674","0.5319655","0.53186566","0.5307914","0.52893883","0.5283084","0.5281653","0.5280256","0.52796054","0.5263991","0.5258884","0.5258485","0.5250189","0.52475625","0.52285963","0.52261454","0.5225623","0.5224538","0.5223019","0.5222497","0.52196854","0.5217301","0.5210978","0.5210619","0.5209831","0.52067816","0.5200897","0.519716","0.51947314","0.51938945","0.5193797","0.51935166","0.5191927","0.5187638","0.5172419","0.5160263","0.51487815","0.5143226","0.514282","0.51425046","0.51355994","0.5126581","0.5125616","0.51213","0.51200885","0.51139426"],"string":"[\n \"0.67444855\",\n \"0.64102155\",\n \"0.62887526\",\n \"0.62739146\",\n \"0.62539726\",\n \"0.61133844\",\n \"0.6096612\",\n \"0.6041767\",\n \"0.5968712\",\n \"0.5952701\",\n \"0.59089845\",\n \"0.58992106\",\n \"0.58605576\",\n \"0.5847041\",\n \"0.5796397\",\n \"0.57910454\",\n \"0.57832146\",\n \"0.5780262\",\n \"0.57560104\",\n \"0.5751728\",\n \"0.5705195\",\n \"0.5689438\",\n \"0.5655034\",\n \"0.562459\",\n \"0.56146675\",\n \"0.56130666\",\n \"0.56107885\",\n \"0.5570062\",\n \"0.55587846\",\n \"0.55579436\",\n \"0.55511415\",\n \"0.55067855\",\n \"0.5492958\",\n \"0.5485608\",\n \"0.5476281\",\n \"0.54746795\",\n \"0.54722226\",\n \"0.5469433\",\n \"0.5459025\",\n \"0.54496074\",\n \"0.54465026\",\n \"0.54350334\",\n \"0.54218525\",\n \"0.5415067\",\n \"0.54142404\",\n \"0.54132503\",\n \"0.5411288\",\n \"0.54052514\",\n \"0.54025954\",\n \"0.5355776\",\n \"0.5339396\",\n \"0.5339082\",\n \"0.5339027\",\n \"0.53370374\",\n \"0.5330674\",\n \"0.5319655\",\n \"0.53186566\",\n \"0.5307914\",\n \"0.52893883\",\n \"0.5283084\",\n \"0.5281653\",\n \"0.5280256\",\n \"0.52796054\",\n \"0.5263991\",\n \"0.5258884\",\n \"0.5258485\",\n \"0.5250189\",\n \"0.52475625\",\n \"0.52285963\",\n \"0.52261454\",\n \"0.5225623\",\n \"0.5224538\",\n \"0.5223019\",\n \"0.5222497\",\n \"0.52196854\",\n \"0.5217301\",\n \"0.5210978\",\n \"0.5210619\",\n \"0.5209831\",\n \"0.52067816\",\n \"0.5200897\",\n \"0.519716\",\n \"0.51947314\",\n \"0.51938945\",\n \"0.5193797\",\n \"0.51935166\",\n \"0.5191927\",\n \"0.5187638\",\n \"0.5172419\",\n \"0.5160263\",\n \"0.51487815\",\n \"0.5143226\",\n \"0.514282\",\n \"0.51425046\",\n \"0.51355994\",\n \"0.5126581\",\n \"0.5125616\",\n \"0.51213\",\n \"0.51200885\",\n \"0.51139426\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5608362"},"document_rank":{"kind":"string","value":"27"}}},{"rowIdx":93182,"cells":{"query":{"kind":"string","value":"Use `tclean` to CLEAN a spectral cube. Additional keyword arguements are passed to `tclean`."},"document":{"kind":"string","value":"def clean_line(imc, spw, contsub=False, fullcube=False, interactive=True,\n export=False, use_existing_psf=False, automask=False, **kwargs):\n vis = imc.viscs if contsub else imc.vis\n imagename = '{0}_{1}'.format(imc.path_base, spw.name)\n tclean_kwargs = {\n 'interactive': interactive,\n 'niter': 1000000 if interactive else 0,\n 'start': '' if fullcube else imc.start_vlsr(spw),\n 'width': '' if fullcube else spw.velo_width,\n 'nchan': -1 if fullcube else spw.nchan,\n 'calcpsf': not use_existing_psf,\n }\n if automask == 'auto':\n kwargs.update({\n 'usemask': 'auto-thresh' if automask else None,\n 'maskthreshold': '33mJy' if automask else None,\n 'maskresolution': 1.0 if automask else None,\n })\n elif automask == 'multi':\n kwargs.update({\n 'usemask': 'auto-multithresh' if automask else None,\n 'noisethreshold': 4.0 if automask else None,\n 'lownoisethreshold': 1.5 if automask else None,\n 'smoothfactor': 1.0 if automask else None,\n 'minbeamfrac': 0.3 if automask else None,\n 'growiterations': 4 if automask else None,\n })\n if kwargs is not None:\n tclean_kwargs.update(kwargs)\n print(':: Running clean')\n tclean(vis=vis,\n imagename=imagename,\n field='0',\n spw=imc.get_one_spw(spw, contsub=contsub),\n specmode='cube',\n outframe='lsrk',\n veltype='radio',\n restfreq=spw.restfreq,\n imsize=imc.imsize,\n cell=imc.cell,\n gridder=imc.gridder,\n deconvolver=imc.deconvolver,\n scales=imc.scales,\n smallscalebias=imc.smallscalebias,\n restoringbeam='common',\n weighting='briggs',\n robust=imc.robust,\n **tclean_kwargs)\n if export:\n export_fits(imagename+'.image')"},"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 clean(args):\n with_dataset(args, Dataset._clean)","def test_clean_line_target(cfg, spw, ext=None, iterzero=False, fullcube=False,\n parallel=False):\n imagename = cfg.get_basename(spw, ext=ext)\n spw_id = cfg.get_spw_id(spw)\n log_post(':: Running clean for {0}'.format(imagename))\n niter = 0 if iterzero else int(1e6)\n if not fullcube and spw.line_win != -1:\n start = int(spw.nchan / 2) - spw.line_win\n nchan = spw.line_win * 2\n else:\n start = -1\n nchan = -1\n delete_all_extensions(imagename)\n tclean(\n vis=cfg.vis,\n imagename=imagename,\n field=cfg.targ.name,\n spw=spw_id,\n specmode='cube',\n outframe='lsrk',\n veltype='radio',\n restfreq=spw.restfreq,\n start=start,\n nchan=nchan,\n imsize=cfg.array_config.imsize,\n cell=cfg.array_config.cell,\n # gridder parameters\n gridder=cfg.array_config.gridder,\n # deconvolver parameters\n deconvolver='multiscale',\n scales=[0, 9, 18, 36], # delta, 1, 2, 4 beam hpbw's\n smallscalebias=0.6,\n restoringbeam='common',\n weighting='briggs',\n robust=1.0,\n niter=niter,\n nsigma=2.0,\n pblimit=-0.001,\n interactive=False,\n parallel=parallel,\n # automasking parameters\n usemask='auto-multithresh', # ALMA joint values\n noisethreshold=4.25,\n sidelobethreshold=2.0,\n lownoisethreshold=1.0,\n minbeamfrac=0.3,\n pbmask=0.0,\n negativethreshold=0.0,\n verbose=True,\n pbcor=True,\n )\n workdir = '{0}.workdirectory'.format(imagename)\n if os.path.exists(workdir):\n shutil.rmtree(workdir)","def test_clean(self):\n\n arg_parser = arguments.get_parser()\n\n args = arg_parser.parse_args([\n 'run',\n '-H', 'this',\n 'clean_test'\n ])\n run_cmd = commands.get_command(args.command_name)\n run_cmd.silence()\n run_cmd.run(self.pav_cfg, args)\n\n for test in run_cmd.last_tests:\n test.wait(timeout=10)\n\n args = arg_parser.parse_args([\n 'clean'\n ])\n\n clean_cmd = commands.get_command(args.command_name)\n clean_cmd.silence()\n\n self.assertEqual(clean_cmd.run(self.pav_cfg, args), 0)","def clean(c):","def clean():\n filter_phase_data()\n combine_phase_data()\n remove_duplicates_phase_data()","def clean(args):\n log = 'removing tmp dir %s ' % (args.tmpdir)\n if args.tmpdir.endswith('STAR'):\n cmd = ['rm -rf %s' % (args.tmpdir)]\n run_subprocess(cmd,args,log)\n log = \"remove tmp files from output dir\"\n cmd = ['mv %s/crick_joinedLog.final.out %s/Crick_joinedLog.final.out' % (args.output_dir, args.output_dir)]\n run_subprocess(cmd, args, log)\n cmd = ['mv %s/watson_joinedLog.final.out %s/Watson_joinedLog.final.out' % (args.output_dir, args.output_dir)]\n run_subprocess(cmd, args, log)\n cmd = ['mv %s/crick_mergedLog.final.out %s/Crick_mergedLog.final.out' % (args.output_dir, args.output_dir)]\n run_subprocess(cmd, args, log)\n cmd = ['mv %s/watson_mergedLog.final.out %s/Watson_mergedLog.final.out' % (args.output_dir, args.output_dir)]\n run_subprocess(cmd, args, log)\n cmd = ['rm -rf %s/crick_*' % args.output_dir]\n run_subprocess(cmd, args, log)\n cmd = ['rm -rf %s/watson_*' % args.output_dir]\n run_subprocess(cmd, args, log)\n cmd = ['rm -rf %s/joined* header.sam' % args.output_dir]\n run_subprocess(cmd, args, log)","def _clean_objects(*args):\n\n for arg in args:\n attrs = dir(arg)\n # QuadContourSet\n if 'collections' in attrs:\n for item in arg.collections: item.remove()\n # Wind barbs and contour labels\n elif '__len__' in attrs:\n for item in arg:\n item.remove()\n # Text strings and everything else\n elif 'get_text' in attrs: arg.remove()","def clean_leftovers(tests):\n for test in tests:\n test.clean()","def Clean(self, targets, arguments):\n raise NotImplementedError('Must be overridden.')","def clean(working_directory=None, args=None):\n\n from .cleanme import main\n if args is None:\n args = []\n return main(working_directory, args)","def clean_tests(c, tox=False): # pylint: disable=unused-argument\n _delete_file(COVERAGE_FILE)\n if tox:\n shutil.rmtree(TOX_DIR, ignore_errors=True)\n shutil.rmtree(COVERAGE_DIR, ignore_errors=True)","def test_clean_cont_target(targ, ext=None, iterzero=False, restart=False,\n parallel=False):\n log_post(':: Running clean ({0}, continuum)'.format(targ.name))\n imagename = 'images/{0}/{0}_contfull'.format(targ.name)\n if ext is not None:\n imagename = '{0}_{1}'.format(imagename, ext)\n # restart parameters\n niter = 0 if iterzero else int(1e6)\n calcpsf = not restart # ie True when not restarting\n calcres = not restart\n cont_spws = get_spw_list(targ, kind='cont')\n linefree = fitspw_from_spws(cont_spws)\n #spws = '40:5~60' # XXX\n delete_all_extensions(imagename)\n tclean(\n vis=[get_vis_name(targ)],\n imagename=imagename,\n field=targ.name,\n spw=linefree,\n specmode='mfs',\n nterms=2,\n imsize=[1472, 1472], # 189.3 as, efficient size?\n cell='0.1286arcsec', # 0.9 as / 7\n # gridder parameters\n gridder='standard',\n # deconvolver parameters\n deconvolver='mtmfs',\n scales=[0, 7, 14], # point, 1, 2 beam hpbw's\n smallscalebias=0.6,\n weighting='briggs',\n robust=1.0,\n niter=niter,\n threshold='9.0uJy', # 30uJy for one SPW, 5 uJy for all SPWs XXX\n interactive=True,\n parallel=parallel,\n # automasking parameters\n usemask='auto-multithresh',\n noisethreshold=5.0,\n sidelobethreshold=3.0,\n lownoisethreshold=2.0,\n minbeamfrac=0.3,\n negativethreshold=0.0,\n verbose=True,\n # restart parameters\n restart=restart,\n calcpsf=calcpsf,\n calcres=calcres,\n #savemodel='modelcolumn',\n )\n workdir = '{0}.workdirectory'.format(imagename)\n if os.path.exists(workdir):\n shutil.rmtree(workdir)","def polyClean(*args, caching: bool=True, cleanEdges: bool=True, cleanPartialUVMapping:\n bool=True, cleanUVs: bool=True, cleanVertices: bool=True, constructionHistory:\n bool=True, frozen: bool=True, name: AnyStr=\"\", nodeState: Union[int, bool]=0,\n q=True, query=True, e=True, edit=True, **kwargs)->Union[AnyStr, Any]:\n pass","def clean_tests(c):\n for test_path in TEST_PATHS:\n print(f'Running `make clean` for {test_path}...')\n _run(c, f'cd {test_path} && make clean', hide='out')","def clean(options, project_directory=None):\n if options.help:\n print clean.__doc__\n sys.exit(1)\n\n if not project_directory:\n project_directory = os.getcwd()\n action_clean(project_directory)","def main():\n\targs = read_inputs()\n\tCase(args.path)\n\n\tprint 'case path: %s' % Case.path\n\n\tprint '[info]: cleaning mesh and force coefficients'\n\tos.system('rm -f '+Case.path+'/*.dat')\n\n\tprint '[info]: cleaning solution folders'\n\tfor i in xrange(10):\n\t\tos.system('rm -rf '+Case.path+'/'+str(i)+'*')\n\n\tprint '[info]: cleaning images'\n\tos.system('rm -rf '+Case.images)","def clean_object(metadata, analysistype):\n for sample in metadata:\n try:\n delattr(sample[analysistype], \"targetnames\")\n except AttributeError:\n pass\n try:\n delattr(sample[analysistype], \"targets\")\n except AttributeError:\n pass\n try:\n delattr(sample[analysistype], \"dnaseq\")\n except AttributeError:\n pass\n try:\n delattr(sample[analysistype], \"protseq\")\n except AttributeError:\n pass","def clean(_context):","def clean():\n clean_files()","def clean(ctx, so=False, cache=False):\n for name in ctx.shell.files('.', '.coverage*', recursive=False):\n ctx.shell.rm(name)\n for name in ctx.shell.files('bench', '.out.*', recursive=False):\n ctx.shell.rm(name)\n ctx.shell.rm_rf(\n 'docs/coverage',\n 'docs/gcov',\n 'build',\n 'dist',\n 'wheel/dist',\n ctx.doc.userdoc,\n 'docs/_userdoc/_build',\n ctx.doc.website.source,\n ctx.doc.website.target,\n )\n if cache:\n cacheclean(ctx)\n if so:\n soclean(ctx)","def clean():\n user_init.clean_setup()","def clean_mesh(self, scale, rescaling_type):\n self._remove_bad_tris()\n self._remove_unreferenced_vertices()\n self._standardize_pose()\n self._rescale_vertices(scale, rescaling_type)","def dev_clean():\n clean_files(\"csv\", True)\n clean_files(\"jsontxt\", True)","def clean_line_with_uvtaper(cfg, spw, fullcube=False, parallel=True):\n log_post(':: Running clean with uv-taper ({0}, {1})'.format(targ.name, spw.name))\n imagename = cfg.get_basename(spw, ext='uvtaper')\n spw_id = cfg.get_spw_id(spw)\n # restart parameters\n if not fullcube and spw.line_win != -1:\n start = spw.nchan // 2 - spw.line_win\n nchan = spw.line_win * 2\n else:\n start = -1\n nchan = -1\n delete_all_extensions(imagename)\n tclean(\n vis=cfg.vis,\n imagename=imagename,\n field=targ.name,\n spw=spw_id,\n specmode='cube',\n outframe='lsrk',\n veltype='radio',\n restfreq=spw.restfreq,\n start=start,\n nchan=nchan,\n imsize=cfg.array_config.imsize,\n cell=cfg.array_config.cell,\n # gridder parameters\n gridder='standard',\n uvtaper='5arcsec',\n # deconvolver parameters\n deconvolver='hogbom',\n restoringbeam='common',\n weighting='briggs',\n robust=2.0,\n niter=int(1e6),\n nsigma=2.0,\n interactive=False,\n parallel=parallel,\n # automasking parameters\n usemask='auto-multithresh', # use ALMA 12m(short) values\n noisethreshold=3.0,\n sidelobethreshold=3.0,\n lownoisethreshold=2.0,\n minbeamfrac=0.3,\n negativethreshold=1000.0,\n verbose=True,\n )\n workdir = '{0}.workdirectory'.format(imagename)\n if os.path.exists(workdir):\n shutil.rmtree(workdir)","def clean_line_with_uvt_mask(cfg, spw, fullcube=False, parallel=True):\n log_post(':: Running clean with uv-taper ({0}, {1})'.format(targ.name, spw.name))\n imagename = cfg.get_basename(spw, ext='smask')\n maskname = cfg.get_basename(spw, ext='uvtaper') + '.image.smask'\n spw_id = cfg.get_spw_id(spw)\n # restart parameters\n if not fullcube and spw.line_win != -1:\n start = spw.nchan // 2 - spw.line_win\n nchan = spw.line_win * 2\n else:\n start = -1\n nchan = -1\n delete_all_extensions(imagename)\n tclean(\n vis=cfg.vis,\n imagename=imagename,\n field=targ.name,\n spw=spw_id,\n specmode='cube',\n outframe='lsrk',\n veltype='radio',\n restfreq=spw.restfreq,\n start=start,\n nchan=nchan,\n imsize=cfg.array_config.imsize,\n cell=cfg.array_config.cell,\n # gridder parameters\n gridder='standard',\n # deconvolver parameters\n deconvolver='multiscale',\n scales=[0, 5, 10], # point, 1, 2 beam hpbw's\n smallscalebias=0.6,\n restoringbeam='common',\n weighting='briggs',\n robust=2.0,\n niter=int(1e6),\n nsigma=2.0,\n interactive=False,\n parallel=parallel,\n # mask from smoothed uv-taper\n usemask='user',\n mask=maskname,\n verbose=True,\n )\n workdir = '{0}.workdirectory'.format(imagename)\n if os.path.exists(workdir):\n shutil.rmtree(workdir)","def clean(session):\n clean_dirs = (\n get_path(\".cache\"),\n get_path(\".coverage\"),\n get_path(\".pytest_cache\"),\n get_path(\"__pycache__\"),\n get_path(\"build\"),\n get_path(\"dist\"),\n get_path(\"docs\", \"__pycache__\"),\n get_path(\"docs\", \"build\"),\n get_path(\"scripts\", \"macos\", \"__pycache__\"),\n get_path(\"src\", \"python\", \"bezier.egg-info\"),\n get_path(\"src\", \"python\", \"bezier\", \"__pycache__\"),\n get_path(\"tests\", \"__pycache__\"),\n get_path(\"tests\", \"functional\", \"__pycache__\"),\n get_path(\"tests\", \"unit\", \"__pycache__\"),\n get_path(\"tests\", \"unit\", \"hazmat\", \"__pycache__\"),\n get_path(\"wheelhouse\"),\n )\n clean_globs = (\n get_path(\".coverage\"),\n get_path(\"*.mod\"),\n get_path(\"*.pyc\"),\n get_path(\"docs\", \"abi\", \"example\"),\n get_path(\"src\", \"python\", \"bezier\", \"*.pyc\"),\n get_path(\"src\", \"python\", \"bezier\", \"*.pyd\"),\n get_path(\"src\", \"python\", \"bezier\", \"*.so\"),\n get_path(\"src\", \"fortran\", \"*.o\"),\n get_path(\"tests\", \"*.pyc\"),\n get_path(\"tests\", \"functional\", \"*.pyc\"),\n get_path(\"tests\", \"unit\", \"*.pyc\"),\n )\n for dir_path in clean_dirs:\n session.run(shutil.rmtree, dir_path, ignore_errors=True)\n for glob_path in clean_globs:\n for filename in glob.glob(glob_path):\n session.run(os.remove, filename)","def hxlclean():\n run_script(hxlclean_main)","def filter_clear(self, samples=None, subset=None):\n if samples is not None:\n subset = self.make_subset(samples)\n elif not hasattr(self, 'subsets'):\n self.make_subset()\n\n if subset is None:\n samples = self.subsets['All_Analyses']\n else:\n try:\n samples = self.subsets[subset]\n except:\n raise ValueError((\"Subset '{:s}' does not .\".format(subset) +\n \"exist.\\nRun 'make_subset' to create a\" +\n \"subset.\"))\n\n for s in samples:\n self.data_dict[s].filt.clear()","def pyccel_clean_command():\n parser = ArgumentParser(description='Tool for removing files generated by pyccel')\n\n parser.add_argument('folders', metavar='N', type=str, nargs='*',\n help='The folders to be cleaned (default is the current folder')\n parser.add_argument('-n', '--not-recursive', action='store_false',\n help='Only run pyccel-clean in the current directory. Do not recurse into other folders')\n parser.add_argument('-s', '--remove-libs', action='store_true',\n help='Also remove any libraries generated by Python from the folder. Beware this may remove shared libraries generated by tools other than pyccel')\n parser.add_argument('-p', '--remove-programs', action='store_true',\n help='Also remove any programs from the folder. Beware this may remove programs unrelated to pyccel')\n args = parser.parse_args()\n\n folders = args.folders\n recursive = args.not_recursive\n remove_libs = args.remove_libs\n remove_programs = args.remove_programs\n\n if len(folders)==0:\n pyccel_clean(None, recursive, remove_libs, remove_programs)\n else:\n for f in folders:\n pyccel_clean(f, recursive, remove_libs, remove_programs)","def test_parser_clean(parser):\n parser.parse_args(['--destroy'])","def do_clean(VERBOSE=0):\r\n thisdir = os.getcwd()\r\n tempdir = \"TEMP\"\r\n\r\n if os.path.isdir(os.path.join(thisdir, \"TEMP\")):\r\n tempdir = os.path.join(thisdir, \"TEMP\")\r\n elif os.path.isdir(os.path.join(thisdir, \"..\", \"TEMP\")):\r\n tempdir = os.path.join(thisdir, \"..\", \"TEMP\")\r\n\r\n if os.path.isdir(tempdir):\r\n os.chdir(tempdir)\r\n if VERBOSE > 0:\r\n print \" cleaning temporary directory '%s'\" % tempdir\r\n filestogo = glob.glob(\"*.*\")\r\n gonecount = 0\r\n for fg in filestogo:\r\n try:\r\n os.remove(fg)\r\n gonecount = gonecount +1\r\n except:\r\n if VERBOSE > 0:\r\n print \" !!! COULDN@T DELETE FILE '%s'\" % fg\r\n else:\r\n pass\r\n if VERBOSE > 0:\r\n print \" Deleted %s files\" % gonecount\r\n print\r\n os.chdir(thisdir)","def trim(args) :\n from trimmer import trim_reads\n trim_reads(args)","def cleanup(options=None):\n if options is None:\n for f in glob.glob(\"*.grmpy.*\"):\n os.remove(f)\n elif options == 'regression':\n for f in glob.glob(\"*.grmpy.*\"):\n if f.startswith('regression'):\n pass\n else:\n os.remove(f)","def clean(self, bbci_set_cnt, ignore_chans=False):\n if self.low_cut_hz is not None:\n assert self.low_cut_hz > 0\n if self.high_cut_hz is not None:\n assert self.high_cut_hz < int(bbci_set_cnt.fs / 2), (\"Frequency \"\n \"should be below Nyquist frequency.\")\n if self.low_cut_hz is not None and self.high_cut_hz is not None:\n assert self.low_cut_hz < self.high_cut_hz\n \n cleaner = Cleaner(\n bbci_set_cnt, \n self.eog_set, \n rejection_blink_ival=self.rejection_blink_ival, \n max_min=self.max_min, \n rejection_var_ival=self.rejection_var_ival, \n whisker_percent=self.whisker_percent, \n whisker_length=self.whisker_length,\n low_cut_hz=self.low_cut_hz,\n high_cut_hz=self.high_cut_hz,\n filt_order=4,\n marker_def=self.marker_def,\n ignore_chans=ignore_chans)\n cleaner.clean()\n \n clean_result = CleanResult(rejected_chan_names=cleaner.rejected_chan_names,\n rejected_trials=cleaner.rejected_trials,\n clean_trials=cleaner.clean_trials,\n rejected_max_min=cleaner.rejected_max_min,\n rejected_var=cleaner.rejected_var)\n \n \n return clean_result","def clean(self):","def main():\n\n parser = argparse.ArgumentParser(prog='clean_questions')\n\n parser.add_argument('-f', '--force', dest='force_write',\n action='store_true', default=False,\n help=\"If true, rsmtool will not check if the \"\n \"output directory already contains the \"\n \"output of another rsmtool experiment. \")\n\n parser.add_argument('input_file',\n help=\"The path to the input file (.txt). \"\n \"Should have one line per question.\")\n\n parser.add_argument('output_file',\n help=\"The path to the output file (.txt or .xlsx). \"\n \"If .txt, then write out the cleaned text. \"\n \"If .xlsx, then write out both original and cleaned text.\")\n\n parser.add_argument('-c', '--min_char_len', dest='min_char_len',\n type=int, default=2,\n help=\"The minimum number of characters to consider, \"\n \"when determining whether to remove text\")\n\n parser.add_argument('-t', '--min_word_threshold', dest='min_word_threshold',\n type=float, default=0.20,\n help=\"The proportion of actual words to consider, \"\n \"when determining whether to remove text.\")\n\n parser.add_argument('-w', '--max_word_len', dest='max_word_len',\n type=int, default=100,\n help=\"The maximum number of words before we decided \"\n \"to take the last sentence.\")\n\n parser.add_argument('-r', '--removed_token', dest='removed_token',\n default=\"<REMOVED>\",\n help=\"A token to use in place of removed text.\")\n\n args = parser.parse_args()\n\n path_to_questions = Path(args.input_file)\n\n error_msg = f'The `input_file`, {args.input_file}, does not exist.'\n assert path_to_questions.exists(), error_msg\n\n with open(path_to_questions) as fb:\n questions = [line.strip() for line in fb.readlines()]\n\n # loop through all of the questions and perform cleaning\n cleaned_questions = []\n for question in tqdm(questions):\n cleaned_questions.append(clean_text(question,\n min_char_len=args.min_char_len,\n min_word_threshold=args.min_word_threshold,\n max_word_len=args.max_word_len,\n removed_token=args.removed_token))\n\n # if the output file is Excel, then write out a formatted file\n # with both the original and cleaned questions in separate columns\n if args.output_file.lower().endswith('xlsx'):\n\n df_output = pd.DataFrame({'original': questions, 'cleaned': cleaned_questions})\n\n writer = pd.ExcelWriter(args.output_file, engine='xlsxwriter')\n df_output.to_excel(writer, sheet_name='questions', index=False, encoding='utf-8')\n\n workbook = writer.book\n worksheet = writer.sheets['questions']\n formatting = workbook.add_format({'text_wrap': True, 'font_size': 18})\n\n worksheet.set_column('A:A', 100, formatting)\n worksheet.set_column('B:B', 100, formatting)\n worksheet.freeze_panes(1, 0)\n\n writer.save()\n\n # otherwise, just put the cleaned questions in each row\n else:\n\n df_output = pd.DataFrame({'questions': cleaned_questions})\n df_output.to_csv(args.output_file, index=False, header=False)","def test_clear_just_cheated_bad_argument(self):\n\n bad_args = [23.7, \"barf\", ['b', 3]]\n for bad_arg in bad_args:\n self._test_clear_just_cheated_bad_argument(bad_arg)","def Cleanup(benchmark_spec):\n pass","def __call__(self, **kwargs):\n if self._update:\n self._debug('update target')\n self.update(**kwargs)\n self._debug('clean target')\n self.clean(**kwargs)","def clean(text, cls=None, **kwargs):\n cls = cls or Desensitize\n scrubber = cls()\n return scrubber.clean(text, **kwargs)","def cleanup(*args, **kwargs): # real signature unknown\n pass","def clean(c):\n clean_docker(c)\n clean_repo(c)","def cleanup(self):\n\n self.PLC['1'].set_plc_mode(0)\n self.PLC['1'].plc_clear('all')\n super(Test200SmartSanityClear005, self).cleanup()","def actionClean():\n result = NO_ERROR\n\n Logger.printStartActionMessage(ACTION_CLEAN)\n #Init cleanup logger\n Cleanup.init()\n\n for action in Settings.cleanupOptions['actions']:\n if action == 'cleanOutput':\n for target in Settings.cleanupOptions['targets']:\n for platform in Settings.cleanupOptions['platforms']:\n for cpu in Settings.cleanupOptions['cpus']:\n for configuration in Settings.cleanupOptions['configurations']:\n #Clean up output folders for specific target, platform, cpu and configuration\n result = Cleanup.run(action, target, platform, cpu, configuration)\n else:\n #Perform other cleanup acrions that are not dependent of target ...\n result = Cleanup.run(action)\n if result == NO_ERROR:\n Logger.printEndActionMessage(ACTION_CLEAN)\n else:\n Logger.printEndActionMessage('Cleanup failed!',ColoredFormatter.RED)\n System.stopExecution(result)","def cleanUp():\n pass","def main():\n results_dir = 'results/macros/cube/'\n filename = glob.glob(results_dir+'macro-results.pickle')[-1]\n with open(filename, 'rb') as file:\n search_results = pickle.load(file)\n best_n = search_results[-1]\n best_n = [(score, [a[0] for a in macro]) for score, macro in best_n]\n\n n_macros = len(expert.macros)\n\n clean_macros = []\n for _, macro in best_n:\n if macro != [] and ' '.join(macro) not in primitive_actions:\n clean_macros.append(macro)\n clean_macros = clean_macros[-n_macros:]\n\n #%% Save the results\n os.makedirs('results/macros/cube', exist_ok=True)\n with open('results/macros/cube/clean_macros.pickle', 'wb') as file:\n pickle.dump(clean_macros, file)","def test_quartet():\n test_path = tempfile.mkdtemp()\n x_train, metadata = quartet(test_path)\n try:\n assert x_train.shape == (11, 6)\n except:\n shutil.rmtree(test_path)\n raise()","def clean(times,signal, f0=None, fn=None, df=None, freqbins=None, niter=10.,\n gain=1.0):\n T = times.ptp()\n n = len(times)\n if freqbins is None:\n freqbins = [f0,fn]\n \n startfreqs = np.array(freqbins[0::2])\n endfreqs = np.array(freqbins[1::2])\n nbins = len(freqbins)-1\n \n nf = int(fn/df)\n \n #-- do clean computation, seems not so straightforward to thread cleaning\n f,wpow,wpha = pyclean.main_clean(times,signal,fn,nf,gain,niter,nbins,\\\n startfreqs,endfreqs)\n \n return f,wpow","def clean_continuum(imc, linefree=False, remove_existing=True, export=False):\n if linefree:\n vis = imc.vislf\n spw = ''\n imagename = imc.path_base\n else:\n vis = imc.vis\n spw = imc.get_cont_spw()\n imagename = imc.path_base +'_single'\n if remove_existing:\n check_delete_image_files(imagename)\n print(':: Running clean')\n tclean(vis=vis,\n imagename=imagename,\n spw=spw,\n specmode='mfs',\n imsize=imc.imsize,\n cell=imc.cell,\n gridder=imc.gridder,\n deconvolver=imc.deconvolver,\n restoringbeam='common',\n weighting='briggs',\n robust=imc.robust,\n niter=100000,\n interactive=True)\n if export:\n export_fits(imagename+'.image')","def clean(ctx):\n header(clean.__doc__)\n with ctx.cd(ROOT):\n for pattern in CLEAN_PATTERNS:\n info(\"Removing {0}\", pattern)\n ctx.run(\"rm -rf {0}\".format(pattern))","def teardown_module(module):\n cf.delete_from_table(idm.SURVEY_SUBSAMPLE_TABLE, 'RUN_ID', '=', RUN_ID)\n\n # List of tables to cleanse where [RUN_ID] = RUN_ID\n tables_to_cleanse = ['[dbo].[PROCESS_VARIABLE_PY]',\n '[dbo].[PROCESS_VARIABLE_TESTING]',\n '[dbo].[TRAFFIC_DATA]',\n '[dbo].[SHIFT_DATA]',\n '[dbo].[NON_RESPONSE_DATA]',\n '[dbo].[UNSAMPLED_OOH_DATA]',\n idm.SURVEY_SUBSAMPLE_TABLE]\n\n # Try to delete from each table in list where condition. If exception occurs,\n # assume table is already empty, and continue deleting from tables in list.\n for table in tables_to_cleanse:\n try:\n cf.delete_from_table(table, 'RUN_ID', '=', RUN_ID)\n except Exception:\n continue\n\n print(\"Duration: {}\".format(time.strftime(\"%H:%M:%S\", time.gmtime(time.time() - START_TIME))))","def cleancosmeticdir(rootdir):\n for subdir in [t120.t120_ofst_dir,t120.t120_flat_dir,t120.t120_dark_dir]:\n tocleandir = rootdir + t120.t120_ofst_dir\n t120.log.info('tocleandir: '+tocleandir)\n pattern = tocleandir+'master*.fit*'\n tocleanlist = glob.glob(pattern)\n if len(tocleanlist):\n for tocleanfile in tocleanlist:\n t120.log.info('Now removing file: '+tocleanfile)\n os.remove(tocleanfile)\n return","def clean():\n clean_flatbuffer_binaries()\n clean_webp_textures()","def __call__( self, top ):\n\t\tsuper( CleanAction, self )( top, \"after\", self.clean )","def clean():\n\tprint(\"Started cleaning....\")\n\trc = call(\"./clean.sh\", shell=True)\n\tprint(\"Cleaning done.\")","def test_text_cleaning(basic_multilingual, clean_multilingual):\n docs = [\"Bonjour le monde! #thisisfrench #ilovefrance\",\n \"Bonjour le monde! https://t.co/U0Zjp3tusD\"]\n docs = [Document([], text=text) for text in docs]\n \n basic_multilingual(docs)\n assert [doc.lang for doc in docs] == [\"it\", \"it\"]\n \n assert clean_multilingual.processors[\"langid\"]._clean_text\n clean_multilingual(docs)\n assert [doc.lang for doc in docs] == [\"fr\", \"fr\"]","def clean(data, skip_transformations=False, target=False):\n data = convert_type(data)\n data = category_grouping(data)\n if target:\n target = data[['Target']]\n data = data.drop(columns='Target')\n x_train, x_test, y_train, y_test = f.train_test(data, target)\n x_train, y_train = resample_vals(x_train, y_train)\n x_train = x_train.assign(Train=lambda x: 1)\n x_test = x_test.assign(Train=lambda x: 0)\n data = pd.concat([x_train, x_test])\n data = onehot_features(data)\n data = log_trans(data, test=True)\n data = cap_outliers(data, test=True)\n data = scale(data, test=True)\n x_train = data.loc[data['Train'] == 1]\n x_test = data.loc[data['Train'] == 0]\n return x_train, x_test, y_train, y_test\n data = onehot_features(data)\n if skip_transformations:\n return data\n data = log_trans(data)\n data = cap_outliers(data)\n data = scale(data)\n return data","def cli(argv):\r\n argv.append(\"--exhaust-materials\")\r\n cltestbench.cli(argv)","def clean(self):\n self._raw_execute(\"clean\", {\"job_id\": self.job_id})","def clean_raw_input(successful, pks_calcs, dry_run=False):\n from aiida.orm import load_node\n from aiida_kkr.calculations import KkrimpCalculation\n if successful:\n for pk in pks_calcs:\n node = load_node(pk)\n # clean only nodes that are KkrimpCalculations\n if node.process_class == KkrimpCalculation:\n raw_input_folder = node._raw_input_folder\n # clean potential and shapefun files\n for filename in [KkrimpCalculation._POTENTIAL, KkrimpCalculation._SHAPEFUN]:\n if filename in raw_input_folder.get_content_list():\n if dry_run:\n print(f'clean {filename}')\n else:\n raw_input_folder.remove_path(filename)\n elif dry_run:\n print('no raw_inputs to clean')","def clearAll(*args):\n\n pi.openScene = \"\"\n pi.openSceneFullPath = \"\"\n\n #shot lists and variants\n cmds.textScrollList(widgets[\"shotListTSL\"], e=True, ra =True)\n cmds.textScrollList(widgets[\"anmVariationsTSL\"], e=True, ra =True)\n cmds.textScrollList(widgets[\"lgtVariationsTSL\"], e=True, ra =True)\n cmds.textScrollList(widgets[\"fxVariationsTSL\"], e=True, ra =True) \n cmds.text(widgets[\"shotInfoNameText\"], e=True, l=\"\")\n cmds.text(widgets[\"shotInfoVariantText\"], e=True, l=\"\") \n #anm\n cmds.textFieldGrp(widgets[\"anmLastWSTFG\"], e=True, tx = \"\")\n cmds.textFieldGrp(widgets[\"anmLastMasterTFG\"], e=True, tx=\"\")\n #lgt\n cmds.textFieldGrp(widgets[\"lgtLastWSTFG\"], e=True, tx = \"\")\n cmds.textFieldGrp(widgets[\"lgtLastMasterTFG\"], e=True, tx=\"\")\n #fx\n cmds.textFieldGrp(widgets[\"fxLastWSTFG\"], e=True, tx = \"\")\n cmds.textFieldGrp(widgets[\"fxLastMasterTFG\"], e=True, tx=\"\")\n cmds.textScrollList(widgets[\"shotAssListTSL\"], e=True, ra=True)\n cmds.textScrollList(widgets[\"shotAssRigCharListTSL\"], e=True, ra=True) \n cmds.textScrollList(widgets[\"shotAssRigPropListTSL\"], e=True, ra=True) \n cmds.textScrollList(widgets[\"shotAssRigSetListTSL\"], e=True, ra=True) \n cmds.textScrollList(widgets[\"shotAnmMstListTSL\"], e=True, ra=True) \n #shot info\n cmds.image(widgets[\"shotInfoPic\"], e=True, image = \"{0}/noImage.jpg\".format(pi.images))\n cmds.textScrollList(widgets[\"shotAssListTSL\"], e=True, ra=True)","def free_intermediate_arrays(self):\n self._mgx = None\n self._mgy = None\n self._mgz = None\n self._vander = None\n self._bkg_cube = None\n self._bkg_cube_dirty = True","def remove_biases_in_cube(DataCube,no_channels=32,time=None,do_LSQmedian_correction=-99999,array_size=2048):\n # Convert to float, just incase it is something else like uint\n if DataCube.dtype not in [np.float, np.float_, np.float16, np.float32, np.float64, np.float128]:\n DataCube = DataCube.astype(np.float) \n\n # Step 1: Subtract the pedestal bias levels.\n # Removing these first is important to improve the accuracy of estimates of \n # various statistics in later steps.\n DataCube -= DataCube[0,:,:].copy()\n \n # Step 2: Estimate bias values from top and bottom reference pixels and subtract them for each channel strip.\n # Step 3: Estimate bias value fluctuation in Vertical direction during the readout time, and subtract them from each strip.\n DataCube = np.array([subtract_reference_pixels(ndr,no_channels=no_channels,array_size=array_size) for ndr in DataCube])\n\n DataCube[0,:,:] = 0 # Just incase it becomes nan in bias subtraction\n\n if do_LSQmedian_correction > robust_median_from_percentiles(DataCube[-1,:,:]):\n # Step 4: After the previous step the errors in the bias corrections are Gaussian, since it comes \n # from the error in estimate of bias from small number of reference pixels.\n # So, in the next step we shall fit straight line to the full median image sections of each strip and estimate residual bias corrections.\n DataCube = subtract_median_bias_residue(DataCube,no_channels=no_channels,time=time,array_size=array_size)\n\n return DataCube","def hxlclean_main(args, stdin=STDIN, stdout=sys.stdout, stderr=sys.stderr):\n\n parser = make_args('Clean data in a HXL file by standardising formats.')\n parser.add_argument(\n '-w',\n '--whitespace',\n help='Comma-separated list of tag patterns for whitespace normalisation.',\n metavar='tag,tag...',\n type=hxl.model.TagPattern.parse_list\n )\n parser.add_argument(\n '-u',\n '--upper',\n help='Comma-separated list of tag patterns for uppercase conversion.',\n metavar='tag,tag...',\n type=hxl.model.TagPattern.parse_list\n )\n parser.add_argument(\n '-l',\n '--lower',\n help='Comma-separated list of tag patterns for lowercase conversion.',\n metavar='tag,tag...',\n type=hxl.model.TagPattern.parse_list\n )\n parser.add_argument(\n '-d',\n '--date',\n help='Comma-separated list of tag patterns for date normalisation.',\n metavar='tag,tag...',\n type=hxl.model.TagPattern.parse_list\n )\n parser.add_argument(\n '--date-format',\n help='Date formatting string in strftime format (defaults to %%Y-%%m-%%d).',\n default=None,\n metavar='format',\n )\n parser.add_argument(\n '-n',\n '--number',\n help='Comma-separated list of tag patternss for number normalisation.',\n metavar='tag,tag...',\n type=hxl.model.TagPattern.parse_list\n )\n parser.add_argument(\n '--number-format',\n help='Number formatting string in printf format (without leading %%).',\n default=None,\n metavar='format',\n )\n parser.add_argument(\n '--latlon',\n help='Comma-separated list of tag patterns for lat/lon normalisation.',\n metavar='tag,tag...',\n type=hxl.model.TagPattern.parse_list\n )\n parser.add_argument(\n '-p',\n '--purge',\n help='Purge unparseable dates, numbers, and lat/lon during cleaning.',\n action='store_const',\n const=True,\n default=False\n )\n add_queries_arg(parser, 'Clean only rows matching at least one query.')\n\n args = parser.parse_args(args)\n\n do_common_args(args)\n\n with make_source(args, stdin) as source, make_output(args, stdout) as output:\n\n filter = hxl.filters.CleanDataFilter(\n source, whitespace=args.whitespace, upper=args.upper, lower=args.lower,\n date=args.date, date_format=args.date_format, number=args.number, number_format=args.number_format,\n latlon=args.latlon, purge=args.purge, queries=args.query\n )\n hxl.input.write_hxl(output.output, filter, show_headers=not args.remove_headers, show_tags=not args.strip_tags)\n\n return EXIT_OK","def clearScript(subarray=DEFAULT) :\n scriptClear(subarray=subarray)","def test_3dtproject_temporal_filter_wf_scrubs(self):\n\n self.wf = build_3dtproject_temporal_filter(\n bpHigh= .9, bpLow= 0.005, tr=2,\n scrub_targets=True,\n import_file=self.sample_raw_image,\n export_file=self.export_path,\n base_dir=self.test_path, crashdump_dir=self.test_path,\n mask_file=self.sample_raw_image_mask\n )\n scrub_targets = [1] * 100\n scrub_targets[46:52] = [0] * 6\n self.highlight_ranges = [(45.5, 52.5)]\n self.wf.inputs.inputnode.scrub_targets = scrub_targets","def devclean():\n click.echo(\"start clean your output folder...\")\n rm(OUTPUTDIR, recursive=True)","def test_t_tide_demo(matlab):\n cmd = \"\"\"[b,a] = butter(6,0.2); % Butterworth filter design\n h = filter(b,a,[1 zeros(1,100)]); % Filter data using above filter\n [bb,aa] = stmcb(h,4,4);\n \"\"\"\n out = matlab.eval(cmd)\n print \"Printing output\"\n print out\n print \"bb is:\"\n bb = matlab.get('bb')\n print bb\n del(out)","def clear(context):\n\n log.log(level=0, msg=\"clear !\")\n log.log(level=0, msg=\"controller set\")\n log.log(level=0, msg=\"mesh set\")\n log.log(level=0, msg=\"joint set\")\n\n # node = pm.PyNode(node)\n #\n # for script in info[const.POSTSCRIPTS]:\n # mod = importlib.import_module(script)\n # mod.PrePost.run(context)","def Cleanup(benchmark_spec):\n del benchmark_spec # unused","def Cleanup(benchmark_spec):\n del benchmark_spec # unused","def cleaning (data):","def clean_file(file_to_clean):\n\n logging.info(f'Cleaning file = {file_to_clean}')\n new_file_name = (file_to_clean.split('/')[-1]).split('.')[0]\n text = open(f\"{new_file_name}\", \"w\")\n lecture = open(f\"{file_to_clean}\", \"r\")\n for line in lecture:\n if not ('[' in line):\n line = line.replace('#', '')\n text.write(line)\n text.close()\n lecture.close()\n logging.info(f'File = {file_to_clean} Cleaned')\n synthesis_file(new_file_name)","def teardown(self):\n del self.testC, self.bounds, self.one_d_vars, self.unequal_one_d_vars\n del self.testI\n\n return","def test_cpoy_clean():\n home_dir = \"/home/xyz\"\n result_root = \"tq-data01\"\n root_folder = \"sentinel1_GRD\"\n local_path = \"/home/xyz/data_pool/test_data/sentinel_GRD/77\"\n suffix_pattern = suffix_pattern = [\"/*.data\", \"/*.dim\", \"/*.SAFE\"]\n\n logger.info(\"Delete test\")\n res_path, flag = CCL.copy_clean_local(\n home_dir, result_root, root_folder, local_path, suffix_pattern\n )\n logger.info(\"%s, %s\", res_path, flag)","def rmclean_loop(rmsynth_pixel, rmsf, rmsf_double, phi, rmclean_gain, niter, \\\n clean_threshold, cellsize, rmsf_std):\n # Empty list of clean components:\n cclist = []\n ccpeak = []\n # Loop over niter iterations:\n for i in range(niter):\n # If the max in Q/U spectra is less than 3sigma, then stop cleaning:\n maxq = np.amax(np.abs(np.real(rmsynth_pixel)))\n maxu = np.amax(np.abs(np.imag(rmsynth_pixel)))\n if (maxq < 3.0*clean_threshold) and (maxu < 3.0*clean_threshold):\n break\n else:\n # Cross-correlate the signal:\n faraday_peak = correlate_signal(rmsynth_pixel, rmsf)\n # Identify the clean component:\n ccomp = form_clean_components(rmsynth_pixel, faraday_peak,\n rmclean_gain)\n # Shift and scale the rmsf:\n rmsf_shifted = shift_scale_rmsf(rmsf_double, phi, cellsize,\n ccomp, faraday_peak)\n # Subtract the dirty beam from the data:\n rmsynth_pixel = rmsynth_pixel-rmsf_shifted\n # Save the clean component:\n cclist.append(ccomp)\n ccpeak.append(faraday_peak)\n cclist = np.array(cclist)\n ccpeak = np.array(ccpeak)\n # Restore all of the clean components, convolved with the clean beam:\n restored = np.array([[cclist[i]*np.exp(((-((phi[z] - \\\n phi[ccpeak[i]])**2))/rmsf_std)) \\\n for z in range(len(phi))]\n for i in range(len(ccpeak))])\n # Sum all of the restored clean components and add into the residuals:\n rmsynth_pixel += np.sum(restored, axis=0)\n return rmsynth_pixel","def clean(self, args):\n for j in self.jobs:\n j.clean(args)","def clean(all):\n docker_clean(all)","def do_clear(self, args):\n if (len(args.split()) > 0):\n self.__bad_arguments(\"clear\")\n else:\n os.system('clear')","def test_cleanup():\n os.remove(test_file[:-4] + \"_no_grave.h5m\")","def clear_temp(remove_all=True):\n tf_list = []\n\n if remove_all:\n temp_dir = _get_temp_dir(False)\n temp_dir += (\n os.path.sep if os.path.sep not in temp_dir[len(temp_dir) - 1] else \"\"\n )\n tf_list = glob.glob(\"{0}TESS_*\".format(temp_dir))\n else:\n global _tempfiles\n\n tf_list = list(_tempfiles)\n _tempfiles.clear()\n\n for tf in tf_list:\n if os.path.isfile(tf):\n _remove_file(tf)","def clean(self):\n self.clean_rally_conf()\n rally.RallyBase.clean_rally_logs()\n if self.image_alt:\n self.cloud.delete_image(self.image_alt)\n if self.flavor_alt:\n self.orig_cloud.delete_flavor(self.flavor_alt.id)\n super().clean()","def clean(self):\n self.clean_rally_conf()\n self.clean_rally_logs()\n if self.flavor_alt:\n self.orig_cloud.delete_flavor(self.flavor_alt.id)\n super().clean()","def set_clean_raw_text(raw_text):\n\tlogger.debug('Cleaning Text')\n\n\t#tokenize and lower sentence\n\ttokenizer = RegexpTokenizer(r'\\w+')\n\ttokens = tokenizer.tokenize(raw_text.lower())\t\t# tokens = nltk.word_tokenize(corpus.lower()) # without removing punctiation\n\n\t#remove stop words\n\ttokens = [w for w in tokens if not is_stopword(w)]\n\n\t#remove punctuation\n\ttokens = [w for w in tokens if not is_punctuation(w)]\n\n\t#remove short \n\ttokens = [w for w in tokens if not is_shorter(w)]\n\n\t#remove number\n\ttokens = [w for w in tokens if not is_number(w)]\n\n\t#stem words\n\ttokens = map(stem, tokens)\n\n\tlogger.debug('Cleaning Text Complete')\n\treturn set(tokens)","def clean(self, context):\n pass","def clean_trial(src_loc: Path, test_cmds: List[str]) -> timedelta:\n cache.remove_existing_cache_files(src_loc)\n\n LOGGER.info(\"Running clean trial\")\n\n # clean trial will show output all the time for diagnostic purposes\n start = datetime.now()\n clean_run = subprocess.run(test_cmds, capture_output=False)\n end = datetime.now()\n\n if clean_run.returncode != 0:\n raise BaselineTestException(\n f\"Clean trial does not pass, mutant tests will be meaningless.\\n\"\n f\"Output: {str(clean_run.stdout)}\"\n )\n\n return end - start","def _clean(base_dir):\n # remove the snakemake cache\n shutil.rmtree(os.path.join(base_dir, \".snakemake\"), ignore_errors=True)\n\n # remove seq2science caches\n shutil.rmtree(os.path.expanduser(os.path.join(xdg.XDG_CACHE_HOME, \"seq2science\")), ignore_errors=True)\n\n # remove historic seq2science cache location\n shutil.rmtree(os.path.expanduser(f\"~/.config/seq2science/\"), ignore_errors=True)\n\n print(\"All cleaned up!\")","def clean():\n click.secho(\"-\" * 88)\n click.secho(\"Cleaning - Start\\n\")\n click.secho(\n \"Unnecessary files in the repository can cause errors while building the\\n\"\n \"building the package. Check for some known issues.\\n\"\n )\n\n # Check for environments in .tox.\n tox_envs = list(Path(\".\", \".tox\").glob(\"*\"))\n if tox_envs and click.confirm(\n \"Do you want to remove all tests environments under .tox?\"\n ):\n for path in tox_envs:\n subprocess.run(f\"conda env remove -p {path}\", shell=True)\n shutil.rmtree(\".tox\")\n\n # Check for temporary files and folders which can be deleted.\n for path in TEMPORARY_FOLDERS:\n if path.is_dir():\n shutil.rmtree(path)\n elif path.is_file():\n path.unlink()\n else:\n pass\n\n # Check for uncommitted and untracked files.\n files = subprocess.run(\n \"git status --porcelain\", shell=True, stdout=subprocess.PIPE\n ).stdout.decode(\"utf-8\")\n if files:\n click.secho(\n \"There are some uncommitted or untracked files. Please manually clean \\n\"\n \"them up or move them somewhere else before proceeding.\\n\",\n color=\"yellow\",\n )\n click.secho(files, color=\"yellow\")\n raise click.Abort\n\n click.secho(\"Cleaning - End\")\n click.secho(\"-\" * 88 + \"\\n\")","def clean(working_directory):\n\n clean_directories(working_directory, (\"temp\", \"_build\"))\n clean_files(working_directory, \".DS_Store\")\n return 0","def clean(raw_file,clean_path,results_path):\n clean_file = clean_path + 'clean.pkl'\n stats_file = results_path + 'corpus_stats.pkl' \n raw_text = load_raw_text(raw_file) \n clean_docs = list()\n nlp = spacy.load('en')\n i = 0\n print('Cleaning documents...')\n for text in raw_text: \n words = nlp(text)\n raw_count = len(words)\n words = [w for w in words if not w.is_stop]\n words = [w for w in words if w.ent_type_ != 'PERSON' and w.pos_ != 'PROPN']\n words = [w for w in words if w.is_alpha and not w.is_digit]\n words = [w.lemma_ for w in words if w.text != '-PRON-']\n word_string = ' '.join(words)\n word_string = word_string.lower()\n doc = Document(word_string)\n doc.clean_count = len(words)\n doc.raw_count = raw_count\n clean_docs.append(doc)\n if i%10 == 0:\n print('Document: ' + str(i))\n i += 1\n clean_corpus = Corpus(clean_docs)\n clean_corpus.save_corpus_text(clean_file)\n clean_corpus.save_corpus_stats(stats_file)\n return clean_corpus","def removevars(self,subset): # 3\n num_ = None\n if num_ is None:\n num_ = len(subset)\n elif num_ != len(subset):\n raise IndexError(\"Inconsistent length of array subset\")\n if num_ is None: num_ = 0\n if subset is None: raise TypeError(\"Invalid type for argument subset\")\n if subset is None:\n subset_ = None\n else:\n try:\n subset_ = memoryview(subset)\n except TypeError:\n try:\n _tmparr_subset = array.array(\"i\",subset)\n except TypeError:\n raise TypeError(\"Argument subset has wrong type\")\n else:\n subset_ = memoryview(_tmparr_subset)\n \n else:\n if subset_.format != \"i\":\n subset_ = memoryview(array.array(\"i\",subset))\n \n res = self.__obj.removevars(num_,subset_)\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)","def clean_dataset(args, min_class_count=5):\n classes_count = get_classes_count(args)\n print(f\"cleaning dataset of {len(args)} arguments\")\n classes_to_remove = []\n for c in classes_count.keys():\n if classes_count[c] < min_class_count:\n classes_to_remove.append(c)\n\n clean_args = [a for a in args if a.frame_id not in classes_to_remove]\n removed_args = [a for a in args if a.frame_id in classes_to_remove]\n print(f\"removed {len(removed_args)} arguments from dataset. {len(clean_args)} remaining.\")\n return clean_args, removed_args","def calculate_mixture_features(args):\n workspace = args.workspace\n speech_dir = args.speech_dir\n noise_dir = args.noise_dir\n data_type = args.data_type\n fs = cfg.sample_rate\n dir_name = args.dir_name\n\n fid_clean = open(speech_dir, 'r')\n lines_clean = fid_clean.readlines()\n fid_clean.close()\n\n fid_reverb = open(noise_dir, 'r')\n lines_reverb = fid_reverb.readlines()\n fid_reverb.close()\n\n for files_clean, files_reverb in zip(lines_clean, lines_reverb):\n\n files_clean = files_clean.strip('\\n')\n files_reverb = files_reverb.strip('\\n')\n\n fid = open(files_clean,'r')\n wavLines_clean = fid.readlines()\n fid.close()\n fid = open(files_reverb,'r')\n wavLines_reverb = fid.readlines()\n fid.close()\n\n cnt = 0 \n\n for wavs_clean, wavs_reverb in zip(wavLines_clean, wavLines_reverb):\n \n t1 = time.time()\n # cnt = 0\n\n wav_name_clean, wav_path_clean = wavs_clean.split()\n wav_name_reverb, wav_path_reverb = wavs_reverb.split()\n \n # Read clean speech audio. \n (speech_audio, _) = read_audio(wav_path_clean, target_fs=fs)\n \n # Read reverb speech audio. \n (noise_audio, _) = read_audio(wav_path_reverb, target_fs=fs)\n \n # Cut reverb speech to the same length as clean speech. \n if len(noise_audio) > len(speech_audio):\n noise_audio = noise_audio[0: len(speech_audio)]\n \n # Extract spectrogram. \n mixed_complx_x = calc_sp(noise_audio, mode='complex')\n speech_x = calc_sp(speech_audio, mode='magnitude')\n\n # Write out features. \n out_feat_path = os.path.join(workspace, \"features\", \"spectrogram\", \n data_type, dir_name, \"%s.p\" % wav_name_reverb)\n create_folder(os.path.dirname(out_feat_path))\n data = [mixed_complx_x, speech_x, wav_name_reverb]\n pickle.dump(data, open(out_feat_path, 'wb'), protocol=pickle.HIGHEST_PROTOCOL)\n \n # Print. \n if cnt % 100 == 0:\n print(cnt)\n # print(mixed_complx_x)\n # print(speech_x)\n \n cnt += 1\n\n print(\"Extracting feature time: %s\" % (time.time() - t1))","def cleanTask(self, blTaskName):\n return self._genericCommand('clean', blTaskName, 'all')","def cleanTokenVocab(tokenVocab, corpus, freqTaux=1):\n if configuration['embedding']['compactVocab']:\n if configuration['others']['verbose']:\n sys.stdout.write(tabs + 'Compact Vocabulary cleaning:' + doubleSep)\n sys.stdout.write(tabs + 'Before : {0}\\n'.format(len(tokenVocab)))\n for k in tokenVocab.keys():\n if k not in [empty, unk, number] and k.lower() not in corpus.mweTokenDictionary and '_' not in k:\n del tokenVocab[k]\n if configuration['others']['verbose']:\n sys.stdout.write(tabs + 'After : {0}\\n'.format(len(tokenVocab)))\n\n else:\n if configuration['others']['verbose']:\n sys.stdout.write(tabs + 'Non frequent word cleaning:' + doubleSep)\n sys.stdout.write(tabs + 'Before : {0}\\n'.format(len(tokenVocab)))\n for k in tokenVocab.keys():\n if tokenVocab[k] <= freqTaux and '_' not in k and k.lower() not in corpus.mweTokenDictionary:\n if uniform(0, 1) < configuration['constants']['alpha']:\n del tokenVocab[k]\n if configuration['others']['verbose']:\n sys.stdout.write(tabs + 'After : {0}\\n'.format(len(tokenVocab)))\n\n return tokenVocab","def test_all(data_wave, data_flux, data_unc, model_dict, params,\n smooth=False,resolution=None,shortname=''):\n\n #logging.debug(data_wave.unit.to_string('fits'))\n #logging.debug(data_unc.unit.to_string('fits'))\n #logging.debug(model_dict['wavelength'].unit.to_string('fits'))\n if data_wave.unit!=model_dict['wavelength'].unit:\n logging.debug('changing units')\n data_wave = data_wave.to(model_dict['wavelength'].unit)\n #logging.debug(data_wave.unit.to_string('fits'))\n\n if ((len(model_dict['wavelength'])==len(data_wave)) and \n (np.sum(model_dict['wavelength']-data_wave)<(model_dict['wavelength'].unit*1e-12))):\n interp = False\n logging.info('calc_chisq.test_all: NO INTERPOLATION')\n else:\n interp = True\n logging.info('calc_chisq.test_all: INTERPOLATION NEEDED')\n\n\n ndim = len(params)\n\n num_models = len(model_dict['flux'])\n\n chisq = np.ones(num_models)*(99e15)\n\t\t\n save_chisq = []\n \n for i in range(num_models):\n# logging.debug('%d %d %f %f',i, num_models, model_dict['logg'][i], \n# model_dict['teff'][i])\n if smooth:\n mod_flux = falt2(model_dict['wavelength'],model_dict['flux'][i],resolution)\n else:\n mod_flux = model_dict['flux'][i]\n #logging.debug('shape flux {} mf {}'.format(np.shape(model_dict['flux']), np.shape(mod_flux)))\n\n #logging.debug('lengths dw {} modw {} modf {}'.format(\n # len(data_wave),len(model_dict['wavelength']),len(mod_flux)))\n if interp:\n mod_flux = np.interp(data_wave,model_dict['wavelength'],mod_flux)\n# mod_flux=mod_flux*u.erg/u.AA/u.cm**2/u.s\n# logging.debug(str(mod_flux[100:110]))\n# logging.debug('stdev %f', np.std(mod_flux))\n# \n mult1 = data_flux*mod_flux\n bad = np.isnan(mult1)\n mult = np.sum(mult1[~bad])\n sq1 = mod_flux**2\n square = np.sum(sq1[~bad])\n ck = mult/square\n mod_flux = mod_flux*ck\n# mult1 = data_flux*mod_flux/(data_unc**2)\n# bad = np.isnan(mult1)\n# mult = np.sum(mult1[~bad])\n# sq1 = mod_flux*mod_flux/(data_unc**2)\n# mult2 = float(sum(sq1[~bad]))\n# ck = mult/mult2\n# mod_flux=mod_flux*ck\n\n chisq[i] = calc_chisq(data_flux, data_unc, mod_flux)\n foo = plt.scatter(model_dict['teff'][i],chisq[i],c=model_dict['logg'][i],cmap=new_cmap,edgecolor='None',vmin=2.75,vmax=5.75)\n params_list = []\n for p in params:\n params_list.append(model_dict[p][i])\n save_chisq.append([params_list,chisq[i]]) \n \n min_loc = np.argmin(chisq)\n# logging.debug('min_loc %d', min_loc)\n best_params = np.array([])\n for p in params:\n best_params = np.append(best_params,model_dict[p][min_loc])\n \n plt.xlabel('$T_{eff}$',fontsize='x-large')\n plt.ylabel('Goodness of Fit',fontsize='x-large')\n plt.annotate('{}, {}'.format(shortname,best_params),xy=(0.5,0.95),xycoords='axes fraction')\n fig = plt.gcf()\n labels = np.arange(3.0,6.0,0.5)\n fig.subplots_adjust(right=0.8)\n cbar_ax = fig.add_axes([0.85, 0.15, 0.03, 0.7])\n cbar = fig.colorbar(foo, cax=cbar_ax, ticks=labels)\n cbar.set_label(label='$log(g)$',size=18)\n plt.savefig('/Users/paigegiorla/Desktop/Teff_goodnesses_{}'.format(shortname)+'.pdf')\n plt.clf()\n \n \n fb = open('/Users/paigegiorla/Desktop/chisquares.pkl','wb')\n pickle.dump(save_chisq,fb)\n fb.close()\n return best_params,min(chisq)","def clean(self):\n files = ['CHG', 'CHGCAR', 'POSCAR', 'INCAR', 'CONTCAR',\n 'DOSCAR', 'EIGENVAL', 'IBZKPT', 'KPOINTS', 'OSZICAR',\n 'OUTCAR', 'PCDAT', 'POTCAR', 'vasprun.xml',\n 'WAVECAR', 'XDATCAR', 'PROCAR', 'ase-sort.dat',\n 'LOCPOT', 'AECCAR0', 'AECCAR1', 'AECCAR2',\n 'WAVECAR.GTO', 'vasp.out', 'vasp.err']\n for f in files:\n try:\n os.remove(f)\n except OSError:\n pass","def test_text_classifier_del_testing_samples_all(self):\n pass","def clean(notebook, execute):\n nb = select_notebook(notebook)\n nb.clean_assets(delete=execute)","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"],"string":"[\n \"def clean(args):\\n with_dataset(args, Dataset._clean)\",\n \"def test_clean_line_target(cfg, spw, ext=None, iterzero=False, fullcube=False,\\n parallel=False):\\n imagename = cfg.get_basename(spw, ext=ext)\\n spw_id = cfg.get_spw_id(spw)\\n log_post(':: Running clean for {0}'.format(imagename))\\n niter = 0 if iterzero else int(1e6)\\n if not fullcube and spw.line_win != -1:\\n start = int(spw.nchan / 2) - spw.line_win\\n nchan = spw.line_win * 2\\n else:\\n start = -1\\n nchan = -1\\n delete_all_extensions(imagename)\\n tclean(\\n vis=cfg.vis,\\n imagename=imagename,\\n field=cfg.targ.name,\\n spw=spw_id,\\n specmode='cube',\\n outframe='lsrk',\\n veltype='radio',\\n restfreq=spw.restfreq,\\n start=start,\\n nchan=nchan,\\n imsize=cfg.array_config.imsize,\\n cell=cfg.array_config.cell,\\n # gridder parameters\\n gridder=cfg.array_config.gridder,\\n # deconvolver parameters\\n deconvolver='multiscale',\\n scales=[0, 9, 18, 36], # delta, 1, 2, 4 beam hpbw's\\n smallscalebias=0.6,\\n restoringbeam='common',\\n weighting='briggs',\\n robust=1.0,\\n niter=niter,\\n nsigma=2.0,\\n pblimit=-0.001,\\n interactive=False,\\n parallel=parallel,\\n # automasking parameters\\n usemask='auto-multithresh', # ALMA joint values\\n noisethreshold=4.25,\\n sidelobethreshold=2.0,\\n lownoisethreshold=1.0,\\n minbeamfrac=0.3,\\n pbmask=0.0,\\n negativethreshold=0.0,\\n verbose=True,\\n pbcor=True,\\n )\\n workdir = '{0}.workdirectory'.format(imagename)\\n if os.path.exists(workdir):\\n shutil.rmtree(workdir)\",\n \"def test_clean(self):\\n\\n arg_parser = arguments.get_parser()\\n\\n args = arg_parser.parse_args([\\n 'run',\\n '-H', 'this',\\n 'clean_test'\\n ])\\n run_cmd = commands.get_command(args.command_name)\\n run_cmd.silence()\\n run_cmd.run(self.pav_cfg, args)\\n\\n for test in run_cmd.last_tests:\\n test.wait(timeout=10)\\n\\n args = arg_parser.parse_args([\\n 'clean'\\n ])\\n\\n clean_cmd = commands.get_command(args.command_name)\\n clean_cmd.silence()\\n\\n self.assertEqual(clean_cmd.run(self.pav_cfg, args), 0)\",\n \"def clean(c):\",\n \"def clean():\\n filter_phase_data()\\n combine_phase_data()\\n remove_duplicates_phase_data()\",\n \"def clean(args):\\n log = 'removing tmp dir %s ' % (args.tmpdir)\\n if args.tmpdir.endswith('STAR'):\\n cmd = ['rm -rf %s' % (args.tmpdir)]\\n run_subprocess(cmd,args,log)\\n log = \\\"remove tmp files from output dir\\\"\\n cmd = ['mv %s/crick_joinedLog.final.out %s/Crick_joinedLog.final.out' % (args.output_dir, args.output_dir)]\\n run_subprocess(cmd, args, log)\\n cmd = ['mv %s/watson_joinedLog.final.out %s/Watson_joinedLog.final.out' % (args.output_dir, args.output_dir)]\\n run_subprocess(cmd, args, log)\\n cmd = ['mv %s/crick_mergedLog.final.out %s/Crick_mergedLog.final.out' % (args.output_dir, args.output_dir)]\\n run_subprocess(cmd, args, log)\\n cmd = ['mv %s/watson_mergedLog.final.out %s/Watson_mergedLog.final.out' % (args.output_dir, args.output_dir)]\\n run_subprocess(cmd, args, log)\\n cmd = ['rm -rf %s/crick_*' % args.output_dir]\\n run_subprocess(cmd, args, log)\\n cmd = ['rm -rf %s/watson_*' % args.output_dir]\\n run_subprocess(cmd, args, log)\\n cmd = ['rm -rf %s/joined* header.sam' % args.output_dir]\\n run_subprocess(cmd, args, log)\",\n \"def _clean_objects(*args):\\n\\n for arg in args:\\n attrs = dir(arg)\\n # QuadContourSet\\n if 'collections' in attrs:\\n for item in arg.collections: item.remove()\\n # Wind barbs and contour labels\\n elif '__len__' in attrs:\\n for item in arg:\\n item.remove()\\n # Text strings and everything else\\n elif 'get_text' in attrs: arg.remove()\",\n \"def clean_leftovers(tests):\\n for test in tests:\\n test.clean()\",\n \"def Clean(self, targets, arguments):\\n raise NotImplementedError('Must be overridden.')\",\n \"def clean(working_directory=None, args=None):\\n\\n from .cleanme import main\\n if args is None:\\n args = []\\n return main(working_directory, args)\",\n \"def clean_tests(c, tox=False): # pylint: disable=unused-argument\\n _delete_file(COVERAGE_FILE)\\n if tox:\\n shutil.rmtree(TOX_DIR, ignore_errors=True)\\n shutil.rmtree(COVERAGE_DIR, ignore_errors=True)\",\n \"def test_clean_cont_target(targ, ext=None, iterzero=False, restart=False,\\n parallel=False):\\n log_post(':: Running clean ({0}, continuum)'.format(targ.name))\\n imagename = 'images/{0}/{0}_contfull'.format(targ.name)\\n if ext is not None:\\n imagename = '{0}_{1}'.format(imagename, ext)\\n # restart parameters\\n niter = 0 if iterzero else int(1e6)\\n calcpsf = not restart # ie True when not restarting\\n calcres = not restart\\n cont_spws = get_spw_list(targ, kind='cont')\\n linefree = fitspw_from_spws(cont_spws)\\n #spws = '40:5~60' # XXX\\n delete_all_extensions(imagename)\\n tclean(\\n vis=[get_vis_name(targ)],\\n imagename=imagename,\\n field=targ.name,\\n spw=linefree,\\n specmode='mfs',\\n nterms=2,\\n imsize=[1472, 1472], # 189.3 as, efficient size?\\n cell='0.1286arcsec', # 0.9 as / 7\\n # gridder parameters\\n gridder='standard',\\n # deconvolver parameters\\n deconvolver='mtmfs',\\n scales=[0, 7, 14], # point, 1, 2 beam hpbw's\\n smallscalebias=0.6,\\n weighting='briggs',\\n robust=1.0,\\n niter=niter,\\n threshold='9.0uJy', # 30uJy for one SPW, 5 uJy for all SPWs XXX\\n interactive=True,\\n parallel=parallel,\\n # automasking parameters\\n usemask='auto-multithresh',\\n noisethreshold=5.0,\\n sidelobethreshold=3.0,\\n lownoisethreshold=2.0,\\n minbeamfrac=0.3,\\n negativethreshold=0.0,\\n verbose=True,\\n # restart parameters\\n restart=restart,\\n calcpsf=calcpsf,\\n calcres=calcres,\\n #savemodel='modelcolumn',\\n )\\n workdir = '{0}.workdirectory'.format(imagename)\\n if os.path.exists(workdir):\\n shutil.rmtree(workdir)\",\n \"def polyClean(*args, caching: bool=True, cleanEdges: bool=True, cleanPartialUVMapping:\\n bool=True, cleanUVs: bool=True, cleanVertices: bool=True, constructionHistory:\\n bool=True, frozen: bool=True, name: AnyStr=\\\"\\\", nodeState: Union[int, bool]=0,\\n q=True, query=True, e=True, edit=True, **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def clean_tests(c):\\n for test_path in TEST_PATHS:\\n print(f'Running `make clean` for {test_path}...')\\n _run(c, f'cd {test_path} && make clean', hide='out')\",\n \"def clean(options, project_directory=None):\\n if options.help:\\n print clean.__doc__\\n sys.exit(1)\\n\\n if not project_directory:\\n project_directory = os.getcwd()\\n action_clean(project_directory)\",\n \"def main():\\n\\targs = read_inputs()\\n\\tCase(args.path)\\n\\n\\tprint 'case path: %s' % Case.path\\n\\n\\tprint '[info]: cleaning mesh and force coefficients'\\n\\tos.system('rm -f '+Case.path+'/*.dat')\\n\\n\\tprint '[info]: cleaning solution folders'\\n\\tfor i in xrange(10):\\n\\t\\tos.system('rm -rf '+Case.path+'/'+str(i)+'*')\\n\\n\\tprint '[info]: cleaning images'\\n\\tos.system('rm -rf '+Case.images)\",\n \"def clean_object(metadata, analysistype):\\n for sample in metadata:\\n try:\\n delattr(sample[analysistype], \\\"targetnames\\\")\\n except AttributeError:\\n pass\\n try:\\n delattr(sample[analysistype], \\\"targets\\\")\\n except AttributeError:\\n pass\\n try:\\n delattr(sample[analysistype], \\\"dnaseq\\\")\\n except AttributeError:\\n pass\\n try:\\n delattr(sample[analysistype], \\\"protseq\\\")\\n except AttributeError:\\n pass\",\n \"def clean(_context):\",\n \"def clean():\\n clean_files()\",\n \"def clean(ctx, so=False, cache=False):\\n for name in ctx.shell.files('.', '.coverage*', recursive=False):\\n ctx.shell.rm(name)\\n for name in ctx.shell.files('bench', '.out.*', recursive=False):\\n ctx.shell.rm(name)\\n ctx.shell.rm_rf(\\n 'docs/coverage',\\n 'docs/gcov',\\n 'build',\\n 'dist',\\n 'wheel/dist',\\n ctx.doc.userdoc,\\n 'docs/_userdoc/_build',\\n ctx.doc.website.source,\\n ctx.doc.website.target,\\n )\\n if cache:\\n cacheclean(ctx)\\n if so:\\n soclean(ctx)\",\n \"def clean():\\n user_init.clean_setup()\",\n \"def clean_mesh(self, scale, rescaling_type):\\n self._remove_bad_tris()\\n self._remove_unreferenced_vertices()\\n self._standardize_pose()\\n self._rescale_vertices(scale, rescaling_type)\",\n \"def dev_clean():\\n clean_files(\\\"csv\\\", True)\\n clean_files(\\\"jsontxt\\\", True)\",\n \"def clean_line_with_uvtaper(cfg, spw, fullcube=False, parallel=True):\\n log_post(':: Running clean with uv-taper ({0}, {1})'.format(targ.name, spw.name))\\n imagename = cfg.get_basename(spw, ext='uvtaper')\\n spw_id = cfg.get_spw_id(spw)\\n # restart parameters\\n if not fullcube and spw.line_win != -1:\\n start = spw.nchan // 2 - spw.line_win\\n nchan = spw.line_win * 2\\n else:\\n start = -1\\n nchan = -1\\n delete_all_extensions(imagename)\\n tclean(\\n vis=cfg.vis,\\n imagename=imagename,\\n field=targ.name,\\n spw=spw_id,\\n specmode='cube',\\n outframe='lsrk',\\n veltype='radio',\\n restfreq=spw.restfreq,\\n start=start,\\n nchan=nchan,\\n imsize=cfg.array_config.imsize,\\n cell=cfg.array_config.cell,\\n # gridder parameters\\n gridder='standard',\\n uvtaper='5arcsec',\\n # deconvolver parameters\\n deconvolver='hogbom',\\n restoringbeam='common',\\n weighting='briggs',\\n robust=2.0,\\n niter=int(1e6),\\n nsigma=2.0,\\n interactive=False,\\n parallel=parallel,\\n # automasking parameters\\n usemask='auto-multithresh', # use ALMA 12m(short) values\\n noisethreshold=3.0,\\n sidelobethreshold=3.0,\\n lownoisethreshold=2.0,\\n minbeamfrac=0.3,\\n negativethreshold=1000.0,\\n verbose=True,\\n )\\n workdir = '{0}.workdirectory'.format(imagename)\\n if os.path.exists(workdir):\\n shutil.rmtree(workdir)\",\n \"def clean_line_with_uvt_mask(cfg, spw, fullcube=False, parallel=True):\\n log_post(':: Running clean with uv-taper ({0}, {1})'.format(targ.name, spw.name))\\n imagename = cfg.get_basename(spw, ext='smask')\\n maskname = cfg.get_basename(spw, ext='uvtaper') + '.image.smask'\\n spw_id = cfg.get_spw_id(spw)\\n # restart parameters\\n if not fullcube and spw.line_win != -1:\\n start = spw.nchan // 2 - spw.line_win\\n nchan = spw.line_win * 2\\n else:\\n start = -1\\n nchan = -1\\n delete_all_extensions(imagename)\\n tclean(\\n vis=cfg.vis,\\n imagename=imagename,\\n field=targ.name,\\n spw=spw_id,\\n specmode='cube',\\n outframe='lsrk',\\n veltype='radio',\\n restfreq=spw.restfreq,\\n start=start,\\n nchan=nchan,\\n imsize=cfg.array_config.imsize,\\n cell=cfg.array_config.cell,\\n # gridder parameters\\n gridder='standard',\\n # deconvolver parameters\\n deconvolver='multiscale',\\n scales=[0, 5, 10], # point, 1, 2 beam hpbw's\\n smallscalebias=0.6,\\n restoringbeam='common',\\n weighting='briggs',\\n robust=2.0,\\n niter=int(1e6),\\n nsigma=2.0,\\n interactive=False,\\n parallel=parallel,\\n # mask from smoothed uv-taper\\n usemask='user',\\n mask=maskname,\\n verbose=True,\\n )\\n workdir = '{0}.workdirectory'.format(imagename)\\n if os.path.exists(workdir):\\n shutil.rmtree(workdir)\",\n \"def clean(session):\\n clean_dirs = (\\n get_path(\\\".cache\\\"),\\n get_path(\\\".coverage\\\"),\\n get_path(\\\".pytest_cache\\\"),\\n get_path(\\\"__pycache__\\\"),\\n get_path(\\\"build\\\"),\\n get_path(\\\"dist\\\"),\\n get_path(\\\"docs\\\", \\\"__pycache__\\\"),\\n get_path(\\\"docs\\\", \\\"build\\\"),\\n get_path(\\\"scripts\\\", \\\"macos\\\", \\\"__pycache__\\\"),\\n get_path(\\\"src\\\", \\\"python\\\", \\\"bezier.egg-info\\\"),\\n get_path(\\\"src\\\", \\\"python\\\", \\\"bezier\\\", \\\"__pycache__\\\"),\\n get_path(\\\"tests\\\", \\\"__pycache__\\\"),\\n get_path(\\\"tests\\\", \\\"functional\\\", \\\"__pycache__\\\"),\\n get_path(\\\"tests\\\", \\\"unit\\\", \\\"__pycache__\\\"),\\n get_path(\\\"tests\\\", \\\"unit\\\", \\\"hazmat\\\", \\\"__pycache__\\\"),\\n get_path(\\\"wheelhouse\\\"),\\n )\\n clean_globs = (\\n get_path(\\\".coverage\\\"),\\n get_path(\\\"*.mod\\\"),\\n get_path(\\\"*.pyc\\\"),\\n get_path(\\\"docs\\\", \\\"abi\\\", \\\"example\\\"),\\n get_path(\\\"src\\\", \\\"python\\\", \\\"bezier\\\", \\\"*.pyc\\\"),\\n get_path(\\\"src\\\", \\\"python\\\", \\\"bezier\\\", \\\"*.pyd\\\"),\\n get_path(\\\"src\\\", \\\"python\\\", \\\"bezier\\\", \\\"*.so\\\"),\\n get_path(\\\"src\\\", \\\"fortran\\\", \\\"*.o\\\"),\\n get_path(\\\"tests\\\", \\\"*.pyc\\\"),\\n get_path(\\\"tests\\\", \\\"functional\\\", \\\"*.pyc\\\"),\\n get_path(\\\"tests\\\", \\\"unit\\\", \\\"*.pyc\\\"),\\n )\\n for dir_path in clean_dirs:\\n session.run(shutil.rmtree, dir_path, ignore_errors=True)\\n for glob_path in clean_globs:\\n for filename in glob.glob(glob_path):\\n session.run(os.remove, filename)\",\n \"def hxlclean():\\n run_script(hxlclean_main)\",\n \"def filter_clear(self, samples=None, subset=None):\\n if samples is not None:\\n subset = self.make_subset(samples)\\n elif not hasattr(self, 'subsets'):\\n self.make_subset()\\n\\n if subset is None:\\n samples = self.subsets['All_Analyses']\\n else:\\n try:\\n samples = self.subsets[subset]\\n except:\\n raise ValueError((\\\"Subset '{:s}' does not .\\\".format(subset) +\\n \\\"exist.\\\\nRun 'make_subset' to create a\\\" +\\n \\\"subset.\\\"))\\n\\n for s in samples:\\n self.data_dict[s].filt.clear()\",\n \"def pyccel_clean_command():\\n parser = ArgumentParser(description='Tool for removing files generated by pyccel')\\n\\n parser.add_argument('folders', metavar='N', type=str, nargs='*',\\n help='The folders to be cleaned (default is the current folder')\\n parser.add_argument('-n', '--not-recursive', action='store_false',\\n help='Only run pyccel-clean in the current directory. Do not recurse into other folders')\\n parser.add_argument('-s', '--remove-libs', action='store_true',\\n help='Also remove any libraries generated by Python from the folder. Beware this may remove shared libraries generated by tools other than pyccel')\\n parser.add_argument('-p', '--remove-programs', action='store_true',\\n help='Also remove any programs from the folder. Beware this may remove programs unrelated to pyccel')\\n args = parser.parse_args()\\n\\n folders = args.folders\\n recursive = args.not_recursive\\n remove_libs = args.remove_libs\\n remove_programs = args.remove_programs\\n\\n if len(folders)==0:\\n pyccel_clean(None, recursive, remove_libs, remove_programs)\\n else:\\n for f in folders:\\n pyccel_clean(f, recursive, remove_libs, remove_programs)\",\n \"def test_parser_clean(parser):\\n parser.parse_args(['--destroy'])\",\n \"def do_clean(VERBOSE=0):\\r\\n thisdir = os.getcwd()\\r\\n tempdir = \\\"TEMP\\\"\\r\\n\\r\\n if os.path.isdir(os.path.join(thisdir, \\\"TEMP\\\")):\\r\\n tempdir = os.path.join(thisdir, \\\"TEMP\\\")\\r\\n elif os.path.isdir(os.path.join(thisdir, \\\"..\\\", \\\"TEMP\\\")):\\r\\n tempdir = os.path.join(thisdir, \\\"..\\\", \\\"TEMP\\\")\\r\\n\\r\\n if os.path.isdir(tempdir):\\r\\n os.chdir(tempdir)\\r\\n if VERBOSE > 0:\\r\\n print \\\" cleaning temporary directory '%s'\\\" % tempdir\\r\\n filestogo = glob.glob(\\\"*.*\\\")\\r\\n gonecount = 0\\r\\n for fg in filestogo:\\r\\n try:\\r\\n os.remove(fg)\\r\\n gonecount = gonecount +1\\r\\n except:\\r\\n if VERBOSE > 0:\\r\\n print \\\" !!! COULDN@T DELETE FILE '%s'\\\" % fg\\r\\n else:\\r\\n pass\\r\\n if VERBOSE > 0:\\r\\n print \\\" Deleted %s files\\\" % gonecount\\r\\n print\\r\\n os.chdir(thisdir)\",\n \"def trim(args) :\\n from trimmer import trim_reads\\n trim_reads(args)\",\n \"def cleanup(options=None):\\n if options is None:\\n for f in glob.glob(\\\"*.grmpy.*\\\"):\\n os.remove(f)\\n elif options == 'regression':\\n for f in glob.glob(\\\"*.grmpy.*\\\"):\\n if f.startswith('regression'):\\n pass\\n else:\\n os.remove(f)\",\n \"def clean(self, bbci_set_cnt, ignore_chans=False):\\n if self.low_cut_hz is not None:\\n assert self.low_cut_hz > 0\\n if self.high_cut_hz is not None:\\n assert self.high_cut_hz < int(bbci_set_cnt.fs / 2), (\\\"Frequency \\\"\\n \\\"should be below Nyquist frequency.\\\")\\n if self.low_cut_hz is not None and self.high_cut_hz is not None:\\n assert self.low_cut_hz < self.high_cut_hz\\n \\n cleaner = Cleaner(\\n bbci_set_cnt, \\n self.eog_set, \\n rejection_blink_ival=self.rejection_blink_ival, \\n max_min=self.max_min, \\n rejection_var_ival=self.rejection_var_ival, \\n whisker_percent=self.whisker_percent, \\n whisker_length=self.whisker_length,\\n low_cut_hz=self.low_cut_hz,\\n high_cut_hz=self.high_cut_hz,\\n filt_order=4,\\n marker_def=self.marker_def,\\n ignore_chans=ignore_chans)\\n cleaner.clean()\\n \\n clean_result = CleanResult(rejected_chan_names=cleaner.rejected_chan_names,\\n rejected_trials=cleaner.rejected_trials,\\n clean_trials=cleaner.clean_trials,\\n rejected_max_min=cleaner.rejected_max_min,\\n rejected_var=cleaner.rejected_var)\\n \\n \\n return clean_result\",\n \"def clean(self):\",\n \"def main():\\n\\n parser = argparse.ArgumentParser(prog='clean_questions')\\n\\n parser.add_argument('-f', '--force', dest='force_write',\\n action='store_true', default=False,\\n help=\\\"If true, rsmtool will not check if the \\\"\\n \\\"output directory already contains the \\\"\\n \\\"output of another rsmtool experiment. \\\")\\n\\n parser.add_argument('input_file',\\n help=\\\"The path to the input file (.txt). \\\"\\n \\\"Should have one line per question.\\\")\\n\\n parser.add_argument('output_file',\\n help=\\\"The path to the output file (.txt or .xlsx). \\\"\\n \\\"If .txt, then write out the cleaned text. \\\"\\n \\\"If .xlsx, then write out both original and cleaned text.\\\")\\n\\n parser.add_argument('-c', '--min_char_len', dest='min_char_len',\\n type=int, default=2,\\n help=\\\"The minimum number of characters to consider, \\\"\\n \\\"when determining whether to remove text\\\")\\n\\n parser.add_argument('-t', '--min_word_threshold', dest='min_word_threshold',\\n type=float, default=0.20,\\n help=\\\"The proportion of actual words to consider, \\\"\\n \\\"when determining whether to remove text.\\\")\\n\\n parser.add_argument('-w', '--max_word_len', dest='max_word_len',\\n type=int, default=100,\\n help=\\\"The maximum number of words before we decided \\\"\\n \\\"to take the last sentence.\\\")\\n\\n parser.add_argument('-r', '--removed_token', dest='removed_token',\\n default=\\\"<REMOVED>\\\",\\n help=\\\"A token to use in place of removed text.\\\")\\n\\n args = parser.parse_args()\\n\\n path_to_questions = Path(args.input_file)\\n\\n error_msg = f'The `input_file`, {args.input_file}, does not exist.'\\n assert path_to_questions.exists(), error_msg\\n\\n with open(path_to_questions) as fb:\\n questions = [line.strip() for line in fb.readlines()]\\n\\n # loop through all of the questions and perform cleaning\\n cleaned_questions = []\\n for question in tqdm(questions):\\n cleaned_questions.append(clean_text(question,\\n min_char_len=args.min_char_len,\\n min_word_threshold=args.min_word_threshold,\\n max_word_len=args.max_word_len,\\n removed_token=args.removed_token))\\n\\n # if the output file is Excel, then write out a formatted file\\n # with both the original and cleaned questions in separate columns\\n if args.output_file.lower().endswith('xlsx'):\\n\\n df_output = pd.DataFrame({'original': questions, 'cleaned': cleaned_questions})\\n\\n writer = pd.ExcelWriter(args.output_file, engine='xlsxwriter')\\n df_output.to_excel(writer, sheet_name='questions', index=False, encoding='utf-8')\\n\\n workbook = writer.book\\n worksheet = writer.sheets['questions']\\n formatting = workbook.add_format({'text_wrap': True, 'font_size': 18})\\n\\n worksheet.set_column('A:A', 100, formatting)\\n worksheet.set_column('B:B', 100, formatting)\\n worksheet.freeze_panes(1, 0)\\n\\n writer.save()\\n\\n # otherwise, just put the cleaned questions in each row\\n else:\\n\\n df_output = pd.DataFrame({'questions': cleaned_questions})\\n df_output.to_csv(args.output_file, index=False, header=False)\",\n \"def test_clear_just_cheated_bad_argument(self):\\n\\n bad_args = [23.7, \\\"barf\\\", ['b', 3]]\\n for bad_arg in bad_args:\\n self._test_clear_just_cheated_bad_argument(bad_arg)\",\n \"def Cleanup(benchmark_spec):\\n pass\",\n \"def __call__(self, **kwargs):\\n if self._update:\\n self._debug('update target')\\n self.update(**kwargs)\\n self._debug('clean target')\\n self.clean(**kwargs)\",\n \"def clean(text, cls=None, **kwargs):\\n cls = cls or Desensitize\\n scrubber = cls()\\n return scrubber.clean(text, **kwargs)\",\n \"def cleanup(*args, **kwargs): # real signature unknown\\n pass\",\n \"def clean(c):\\n clean_docker(c)\\n clean_repo(c)\",\n \"def cleanup(self):\\n\\n self.PLC['1'].set_plc_mode(0)\\n self.PLC['1'].plc_clear('all')\\n super(Test200SmartSanityClear005, self).cleanup()\",\n \"def actionClean():\\n result = NO_ERROR\\n\\n Logger.printStartActionMessage(ACTION_CLEAN)\\n #Init cleanup logger\\n Cleanup.init()\\n\\n for action in Settings.cleanupOptions['actions']:\\n if action == 'cleanOutput':\\n for target in Settings.cleanupOptions['targets']:\\n for platform in Settings.cleanupOptions['platforms']:\\n for cpu in Settings.cleanupOptions['cpus']:\\n for configuration in Settings.cleanupOptions['configurations']:\\n #Clean up output folders for specific target, platform, cpu and configuration\\n result = Cleanup.run(action, target, platform, cpu, configuration)\\n else:\\n #Perform other cleanup acrions that are not dependent of target ...\\n result = Cleanup.run(action)\\n if result == NO_ERROR:\\n Logger.printEndActionMessage(ACTION_CLEAN)\\n else:\\n Logger.printEndActionMessage('Cleanup failed!',ColoredFormatter.RED)\\n System.stopExecution(result)\",\n \"def cleanUp():\\n pass\",\n \"def main():\\n results_dir = 'results/macros/cube/'\\n filename = glob.glob(results_dir+'macro-results.pickle')[-1]\\n with open(filename, 'rb') as file:\\n search_results = pickle.load(file)\\n best_n = search_results[-1]\\n best_n = [(score, [a[0] for a in macro]) for score, macro in best_n]\\n\\n n_macros = len(expert.macros)\\n\\n clean_macros = []\\n for _, macro in best_n:\\n if macro != [] and ' '.join(macro) not in primitive_actions:\\n clean_macros.append(macro)\\n clean_macros = clean_macros[-n_macros:]\\n\\n #%% Save the results\\n os.makedirs('results/macros/cube', exist_ok=True)\\n with open('results/macros/cube/clean_macros.pickle', 'wb') as file:\\n pickle.dump(clean_macros, file)\",\n \"def test_quartet():\\n test_path = tempfile.mkdtemp()\\n x_train, metadata = quartet(test_path)\\n try:\\n assert x_train.shape == (11, 6)\\n except:\\n shutil.rmtree(test_path)\\n raise()\",\n \"def clean(times,signal, f0=None, fn=None, df=None, freqbins=None, niter=10.,\\n gain=1.0):\\n T = times.ptp()\\n n = len(times)\\n if freqbins is None:\\n freqbins = [f0,fn]\\n \\n startfreqs = np.array(freqbins[0::2])\\n endfreqs = np.array(freqbins[1::2])\\n nbins = len(freqbins)-1\\n \\n nf = int(fn/df)\\n \\n #-- do clean computation, seems not so straightforward to thread cleaning\\n f,wpow,wpha = pyclean.main_clean(times,signal,fn,nf,gain,niter,nbins,\\\\\\n startfreqs,endfreqs)\\n \\n return f,wpow\",\n \"def clean_continuum(imc, linefree=False, remove_existing=True, export=False):\\n if linefree:\\n vis = imc.vislf\\n spw = ''\\n imagename = imc.path_base\\n else:\\n vis = imc.vis\\n spw = imc.get_cont_spw()\\n imagename = imc.path_base +'_single'\\n if remove_existing:\\n check_delete_image_files(imagename)\\n print(':: Running clean')\\n tclean(vis=vis,\\n imagename=imagename,\\n spw=spw,\\n specmode='mfs',\\n imsize=imc.imsize,\\n cell=imc.cell,\\n gridder=imc.gridder,\\n deconvolver=imc.deconvolver,\\n restoringbeam='common',\\n weighting='briggs',\\n robust=imc.robust,\\n niter=100000,\\n interactive=True)\\n if export:\\n export_fits(imagename+'.image')\",\n \"def clean(ctx):\\n header(clean.__doc__)\\n with ctx.cd(ROOT):\\n for pattern in CLEAN_PATTERNS:\\n info(\\\"Removing {0}\\\", pattern)\\n ctx.run(\\\"rm -rf {0}\\\".format(pattern))\",\n \"def teardown_module(module):\\n cf.delete_from_table(idm.SURVEY_SUBSAMPLE_TABLE, 'RUN_ID', '=', RUN_ID)\\n\\n # List of tables to cleanse where [RUN_ID] = RUN_ID\\n tables_to_cleanse = ['[dbo].[PROCESS_VARIABLE_PY]',\\n '[dbo].[PROCESS_VARIABLE_TESTING]',\\n '[dbo].[TRAFFIC_DATA]',\\n '[dbo].[SHIFT_DATA]',\\n '[dbo].[NON_RESPONSE_DATA]',\\n '[dbo].[UNSAMPLED_OOH_DATA]',\\n idm.SURVEY_SUBSAMPLE_TABLE]\\n\\n # Try to delete from each table in list where condition. If exception occurs,\\n # assume table is already empty, and continue deleting from tables in list.\\n for table in tables_to_cleanse:\\n try:\\n cf.delete_from_table(table, 'RUN_ID', '=', RUN_ID)\\n except Exception:\\n continue\\n\\n print(\\\"Duration: {}\\\".format(time.strftime(\\\"%H:%M:%S\\\", time.gmtime(time.time() - START_TIME))))\",\n \"def cleancosmeticdir(rootdir):\\n for subdir in [t120.t120_ofst_dir,t120.t120_flat_dir,t120.t120_dark_dir]:\\n tocleandir = rootdir + t120.t120_ofst_dir\\n t120.log.info('tocleandir: '+tocleandir)\\n pattern = tocleandir+'master*.fit*'\\n tocleanlist = glob.glob(pattern)\\n if len(tocleanlist):\\n for tocleanfile in tocleanlist:\\n t120.log.info('Now removing file: '+tocleanfile)\\n os.remove(tocleanfile)\\n return\",\n \"def clean():\\n clean_flatbuffer_binaries()\\n clean_webp_textures()\",\n \"def __call__( self, top ):\\n\\t\\tsuper( CleanAction, self )( top, \\\"after\\\", self.clean )\",\n \"def clean():\\n\\tprint(\\\"Started cleaning....\\\")\\n\\trc = call(\\\"./clean.sh\\\", shell=True)\\n\\tprint(\\\"Cleaning done.\\\")\",\n \"def test_text_cleaning(basic_multilingual, clean_multilingual):\\n docs = [\\\"Bonjour le monde! #thisisfrench #ilovefrance\\\",\\n \\\"Bonjour le monde! https://t.co/U0Zjp3tusD\\\"]\\n docs = [Document([], text=text) for text in docs]\\n \\n basic_multilingual(docs)\\n assert [doc.lang for doc in docs] == [\\\"it\\\", \\\"it\\\"]\\n \\n assert clean_multilingual.processors[\\\"langid\\\"]._clean_text\\n clean_multilingual(docs)\\n assert [doc.lang for doc in docs] == [\\\"fr\\\", \\\"fr\\\"]\",\n \"def clean(data, skip_transformations=False, target=False):\\n data = convert_type(data)\\n data = category_grouping(data)\\n if target:\\n target = data[['Target']]\\n data = data.drop(columns='Target')\\n x_train, x_test, y_train, y_test = f.train_test(data, target)\\n x_train, y_train = resample_vals(x_train, y_train)\\n x_train = x_train.assign(Train=lambda x: 1)\\n x_test = x_test.assign(Train=lambda x: 0)\\n data = pd.concat([x_train, x_test])\\n data = onehot_features(data)\\n data = log_trans(data, test=True)\\n data = cap_outliers(data, test=True)\\n data = scale(data, test=True)\\n x_train = data.loc[data['Train'] == 1]\\n x_test = data.loc[data['Train'] == 0]\\n return x_train, x_test, y_train, y_test\\n data = onehot_features(data)\\n if skip_transformations:\\n return data\\n data = log_trans(data)\\n data = cap_outliers(data)\\n data = scale(data)\\n return data\",\n \"def cli(argv):\\r\\n argv.append(\\\"--exhaust-materials\\\")\\r\\n cltestbench.cli(argv)\",\n \"def clean(self):\\n self._raw_execute(\\\"clean\\\", {\\\"job_id\\\": self.job_id})\",\n \"def clean_raw_input(successful, pks_calcs, dry_run=False):\\n from aiida.orm import load_node\\n from aiida_kkr.calculations import KkrimpCalculation\\n if successful:\\n for pk in pks_calcs:\\n node = load_node(pk)\\n # clean only nodes that are KkrimpCalculations\\n if node.process_class == KkrimpCalculation:\\n raw_input_folder = node._raw_input_folder\\n # clean potential and shapefun files\\n for filename in [KkrimpCalculation._POTENTIAL, KkrimpCalculation._SHAPEFUN]:\\n if filename in raw_input_folder.get_content_list():\\n if dry_run:\\n print(f'clean {filename}')\\n else:\\n raw_input_folder.remove_path(filename)\\n elif dry_run:\\n print('no raw_inputs to clean')\",\n \"def clearAll(*args):\\n\\n pi.openScene = \\\"\\\"\\n pi.openSceneFullPath = \\\"\\\"\\n\\n #shot lists and variants\\n cmds.textScrollList(widgets[\\\"shotListTSL\\\"], e=True, ra =True)\\n cmds.textScrollList(widgets[\\\"anmVariationsTSL\\\"], e=True, ra =True)\\n cmds.textScrollList(widgets[\\\"lgtVariationsTSL\\\"], e=True, ra =True)\\n cmds.textScrollList(widgets[\\\"fxVariationsTSL\\\"], e=True, ra =True) \\n cmds.text(widgets[\\\"shotInfoNameText\\\"], e=True, l=\\\"\\\")\\n cmds.text(widgets[\\\"shotInfoVariantText\\\"], e=True, l=\\\"\\\") \\n #anm\\n cmds.textFieldGrp(widgets[\\\"anmLastWSTFG\\\"], e=True, tx = \\\"\\\")\\n cmds.textFieldGrp(widgets[\\\"anmLastMasterTFG\\\"], e=True, tx=\\\"\\\")\\n #lgt\\n cmds.textFieldGrp(widgets[\\\"lgtLastWSTFG\\\"], e=True, tx = \\\"\\\")\\n cmds.textFieldGrp(widgets[\\\"lgtLastMasterTFG\\\"], e=True, tx=\\\"\\\")\\n #fx\\n cmds.textFieldGrp(widgets[\\\"fxLastWSTFG\\\"], e=True, tx = \\\"\\\")\\n cmds.textFieldGrp(widgets[\\\"fxLastMasterTFG\\\"], e=True, tx=\\\"\\\")\\n cmds.textScrollList(widgets[\\\"shotAssListTSL\\\"], e=True, ra=True)\\n cmds.textScrollList(widgets[\\\"shotAssRigCharListTSL\\\"], e=True, ra=True) \\n cmds.textScrollList(widgets[\\\"shotAssRigPropListTSL\\\"], e=True, ra=True) \\n cmds.textScrollList(widgets[\\\"shotAssRigSetListTSL\\\"], e=True, ra=True) \\n cmds.textScrollList(widgets[\\\"shotAnmMstListTSL\\\"], e=True, ra=True) \\n #shot info\\n cmds.image(widgets[\\\"shotInfoPic\\\"], e=True, image = \\\"{0}/noImage.jpg\\\".format(pi.images))\\n cmds.textScrollList(widgets[\\\"shotAssListTSL\\\"], e=True, ra=True)\",\n \"def free_intermediate_arrays(self):\\n self._mgx = None\\n self._mgy = None\\n self._mgz = None\\n self._vander = None\\n self._bkg_cube = None\\n self._bkg_cube_dirty = True\",\n \"def remove_biases_in_cube(DataCube,no_channels=32,time=None,do_LSQmedian_correction=-99999,array_size=2048):\\n # Convert to float, just incase it is something else like uint\\n if DataCube.dtype not in [np.float, np.float_, np.float16, np.float32, np.float64, np.float128]:\\n DataCube = DataCube.astype(np.float) \\n\\n # Step 1: Subtract the pedestal bias levels.\\n # Removing these first is important to improve the accuracy of estimates of \\n # various statistics in later steps.\\n DataCube -= DataCube[0,:,:].copy()\\n \\n # Step 2: Estimate bias values from top and bottom reference pixels and subtract them for each channel strip.\\n # Step 3: Estimate bias value fluctuation in Vertical direction during the readout time, and subtract them from each strip.\\n DataCube = np.array([subtract_reference_pixels(ndr,no_channels=no_channels,array_size=array_size) for ndr in DataCube])\\n\\n DataCube[0,:,:] = 0 # Just incase it becomes nan in bias subtraction\\n\\n if do_LSQmedian_correction > robust_median_from_percentiles(DataCube[-1,:,:]):\\n # Step 4: After the previous step the errors in the bias corrections are Gaussian, since it comes \\n # from the error in estimate of bias from small number of reference pixels.\\n # So, in the next step we shall fit straight line to the full median image sections of each strip and estimate residual bias corrections.\\n DataCube = subtract_median_bias_residue(DataCube,no_channels=no_channels,time=time,array_size=array_size)\\n\\n return DataCube\",\n \"def hxlclean_main(args, stdin=STDIN, stdout=sys.stdout, stderr=sys.stderr):\\n\\n parser = make_args('Clean data in a HXL file by standardising formats.')\\n parser.add_argument(\\n '-w',\\n '--whitespace',\\n help='Comma-separated list of tag patterns for whitespace normalisation.',\\n metavar='tag,tag...',\\n type=hxl.model.TagPattern.parse_list\\n )\\n parser.add_argument(\\n '-u',\\n '--upper',\\n help='Comma-separated list of tag patterns for uppercase conversion.',\\n metavar='tag,tag...',\\n type=hxl.model.TagPattern.parse_list\\n )\\n parser.add_argument(\\n '-l',\\n '--lower',\\n help='Comma-separated list of tag patterns for lowercase conversion.',\\n metavar='tag,tag...',\\n type=hxl.model.TagPattern.parse_list\\n )\\n parser.add_argument(\\n '-d',\\n '--date',\\n help='Comma-separated list of tag patterns for date normalisation.',\\n metavar='tag,tag...',\\n type=hxl.model.TagPattern.parse_list\\n )\\n parser.add_argument(\\n '--date-format',\\n help='Date formatting string in strftime format (defaults to %%Y-%%m-%%d).',\\n default=None,\\n metavar='format',\\n )\\n parser.add_argument(\\n '-n',\\n '--number',\\n help='Comma-separated list of tag patternss for number normalisation.',\\n metavar='tag,tag...',\\n type=hxl.model.TagPattern.parse_list\\n )\\n parser.add_argument(\\n '--number-format',\\n help='Number formatting string in printf format (without leading %%).',\\n default=None,\\n metavar='format',\\n )\\n parser.add_argument(\\n '--latlon',\\n help='Comma-separated list of tag patterns for lat/lon normalisation.',\\n metavar='tag,tag...',\\n type=hxl.model.TagPattern.parse_list\\n )\\n parser.add_argument(\\n '-p',\\n '--purge',\\n help='Purge unparseable dates, numbers, and lat/lon during cleaning.',\\n action='store_const',\\n const=True,\\n default=False\\n )\\n add_queries_arg(parser, 'Clean only rows matching at least one query.')\\n\\n args = parser.parse_args(args)\\n\\n do_common_args(args)\\n\\n with make_source(args, stdin) as source, make_output(args, stdout) as output:\\n\\n filter = hxl.filters.CleanDataFilter(\\n source, whitespace=args.whitespace, upper=args.upper, lower=args.lower,\\n date=args.date, date_format=args.date_format, number=args.number, number_format=args.number_format,\\n latlon=args.latlon, purge=args.purge, queries=args.query\\n )\\n hxl.input.write_hxl(output.output, filter, show_headers=not args.remove_headers, show_tags=not args.strip_tags)\\n\\n return EXIT_OK\",\n \"def clearScript(subarray=DEFAULT) :\\n scriptClear(subarray=subarray)\",\n \"def test_3dtproject_temporal_filter_wf_scrubs(self):\\n\\n self.wf = build_3dtproject_temporal_filter(\\n bpHigh= .9, bpLow= 0.005, tr=2,\\n scrub_targets=True,\\n import_file=self.sample_raw_image,\\n export_file=self.export_path,\\n base_dir=self.test_path, crashdump_dir=self.test_path,\\n mask_file=self.sample_raw_image_mask\\n )\\n scrub_targets = [1] * 100\\n scrub_targets[46:52] = [0] * 6\\n self.highlight_ranges = [(45.5, 52.5)]\\n self.wf.inputs.inputnode.scrub_targets = scrub_targets\",\n \"def devclean():\\n click.echo(\\\"start clean your output folder...\\\")\\n rm(OUTPUTDIR, recursive=True)\",\n \"def test_t_tide_demo(matlab):\\n cmd = \\\"\\\"\\\"[b,a] = butter(6,0.2); % Butterworth filter design\\n h = filter(b,a,[1 zeros(1,100)]); % Filter data using above filter\\n [bb,aa] = stmcb(h,4,4);\\n \\\"\\\"\\\"\\n out = matlab.eval(cmd)\\n print \\\"Printing output\\\"\\n print out\\n print \\\"bb is:\\\"\\n bb = matlab.get('bb')\\n print bb\\n del(out)\",\n \"def clear(context):\\n\\n log.log(level=0, msg=\\\"clear !\\\")\\n log.log(level=0, msg=\\\"controller set\\\")\\n log.log(level=0, msg=\\\"mesh set\\\")\\n log.log(level=0, msg=\\\"joint set\\\")\\n\\n # node = pm.PyNode(node)\\n #\\n # for script in info[const.POSTSCRIPTS]:\\n # mod = importlib.import_module(script)\\n # mod.PrePost.run(context)\",\n \"def Cleanup(benchmark_spec):\\n del benchmark_spec # unused\",\n \"def Cleanup(benchmark_spec):\\n del benchmark_spec # unused\",\n \"def cleaning (data):\",\n \"def clean_file(file_to_clean):\\n\\n logging.info(f'Cleaning file = {file_to_clean}')\\n new_file_name = (file_to_clean.split('/')[-1]).split('.')[0]\\n text = open(f\\\"{new_file_name}\\\", \\\"w\\\")\\n lecture = open(f\\\"{file_to_clean}\\\", \\\"r\\\")\\n for line in lecture:\\n if not ('[' in line):\\n line = line.replace('#', '')\\n text.write(line)\\n text.close()\\n lecture.close()\\n logging.info(f'File = {file_to_clean} Cleaned')\\n synthesis_file(new_file_name)\",\n \"def teardown(self):\\n del self.testC, self.bounds, self.one_d_vars, self.unequal_one_d_vars\\n del self.testI\\n\\n return\",\n \"def test_cpoy_clean():\\n home_dir = \\\"/home/xyz\\\"\\n result_root = \\\"tq-data01\\\"\\n root_folder = \\\"sentinel1_GRD\\\"\\n local_path = \\\"/home/xyz/data_pool/test_data/sentinel_GRD/77\\\"\\n suffix_pattern = suffix_pattern = [\\\"/*.data\\\", \\\"/*.dim\\\", \\\"/*.SAFE\\\"]\\n\\n logger.info(\\\"Delete test\\\")\\n res_path, flag = CCL.copy_clean_local(\\n home_dir, result_root, root_folder, local_path, suffix_pattern\\n )\\n logger.info(\\\"%s, %s\\\", res_path, flag)\",\n \"def rmclean_loop(rmsynth_pixel, rmsf, rmsf_double, phi, rmclean_gain, niter, \\\\\\n clean_threshold, cellsize, rmsf_std):\\n # Empty list of clean components:\\n cclist = []\\n ccpeak = []\\n # Loop over niter iterations:\\n for i in range(niter):\\n # If the max in Q/U spectra is less than 3sigma, then stop cleaning:\\n maxq = np.amax(np.abs(np.real(rmsynth_pixel)))\\n maxu = np.amax(np.abs(np.imag(rmsynth_pixel)))\\n if (maxq < 3.0*clean_threshold) and (maxu < 3.0*clean_threshold):\\n break\\n else:\\n # Cross-correlate the signal:\\n faraday_peak = correlate_signal(rmsynth_pixel, rmsf)\\n # Identify the clean component:\\n ccomp = form_clean_components(rmsynth_pixel, faraday_peak,\\n rmclean_gain)\\n # Shift and scale the rmsf:\\n rmsf_shifted = shift_scale_rmsf(rmsf_double, phi, cellsize,\\n ccomp, faraday_peak)\\n # Subtract the dirty beam from the data:\\n rmsynth_pixel = rmsynth_pixel-rmsf_shifted\\n # Save the clean component:\\n cclist.append(ccomp)\\n ccpeak.append(faraday_peak)\\n cclist = np.array(cclist)\\n ccpeak = np.array(ccpeak)\\n # Restore all of the clean components, convolved with the clean beam:\\n restored = np.array([[cclist[i]*np.exp(((-((phi[z] - \\\\\\n phi[ccpeak[i]])**2))/rmsf_std)) \\\\\\n for z in range(len(phi))]\\n for i in range(len(ccpeak))])\\n # Sum all of the restored clean components and add into the residuals:\\n rmsynth_pixel += np.sum(restored, axis=0)\\n return rmsynth_pixel\",\n \"def clean(self, args):\\n for j in self.jobs:\\n j.clean(args)\",\n \"def clean(all):\\n docker_clean(all)\",\n \"def do_clear(self, args):\\n if (len(args.split()) > 0):\\n self.__bad_arguments(\\\"clear\\\")\\n else:\\n os.system('clear')\",\n \"def test_cleanup():\\n os.remove(test_file[:-4] + \\\"_no_grave.h5m\\\")\",\n \"def clear_temp(remove_all=True):\\n tf_list = []\\n\\n if remove_all:\\n temp_dir = _get_temp_dir(False)\\n temp_dir += (\\n os.path.sep if os.path.sep not in temp_dir[len(temp_dir) - 1] else \\\"\\\"\\n )\\n tf_list = glob.glob(\\\"{0}TESS_*\\\".format(temp_dir))\\n else:\\n global _tempfiles\\n\\n tf_list = list(_tempfiles)\\n _tempfiles.clear()\\n\\n for tf in tf_list:\\n if os.path.isfile(tf):\\n _remove_file(tf)\",\n \"def clean(self):\\n self.clean_rally_conf()\\n rally.RallyBase.clean_rally_logs()\\n if self.image_alt:\\n self.cloud.delete_image(self.image_alt)\\n if self.flavor_alt:\\n self.orig_cloud.delete_flavor(self.flavor_alt.id)\\n super().clean()\",\n \"def clean(self):\\n self.clean_rally_conf()\\n self.clean_rally_logs()\\n if self.flavor_alt:\\n self.orig_cloud.delete_flavor(self.flavor_alt.id)\\n super().clean()\",\n \"def set_clean_raw_text(raw_text):\\n\\tlogger.debug('Cleaning Text')\\n\\n\\t#tokenize and lower sentence\\n\\ttokenizer = RegexpTokenizer(r'\\\\w+')\\n\\ttokens = tokenizer.tokenize(raw_text.lower())\\t\\t# tokens = nltk.word_tokenize(corpus.lower()) # without removing punctiation\\n\\n\\t#remove stop words\\n\\ttokens = [w for w in tokens if not is_stopword(w)]\\n\\n\\t#remove punctuation\\n\\ttokens = [w for w in tokens if not is_punctuation(w)]\\n\\n\\t#remove short \\n\\ttokens = [w for w in tokens if not is_shorter(w)]\\n\\n\\t#remove number\\n\\ttokens = [w for w in tokens if not is_number(w)]\\n\\n\\t#stem words\\n\\ttokens = map(stem, tokens)\\n\\n\\tlogger.debug('Cleaning Text Complete')\\n\\treturn set(tokens)\",\n \"def clean(self, context):\\n pass\",\n \"def clean_trial(src_loc: Path, test_cmds: List[str]) -> timedelta:\\n cache.remove_existing_cache_files(src_loc)\\n\\n LOGGER.info(\\\"Running clean trial\\\")\\n\\n # clean trial will show output all the time for diagnostic purposes\\n start = datetime.now()\\n clean_run = subprocess.run(test_cmds, capture_output=False)\\n end = datetime.now()\\n\\n if clean_run.returncode != 0:\\n raise BaselineTestException(\\n f\\\"Clean trial does not pass, mutant tests will be meaningless.\\\\n\\\"\\n f\\\"Output: {str(clean_run.stdout)}\\\"\\n )\\n\\n return end - start\",\n \"def _clean(base_dir):\\n # remove the snakemake cache\\n shutil.rmtree(os.path.join(base_dir, \\\".snakemake\\\"), ignore_errors=True)\\n\\n # remove seq2science caches\\n shutil.rmtree(os.path.expanduser(os.path.join(xdg.XDG_CACHE_HOME, \\\"seq2science\\\")), ignore_errors=True)\\n\\n # remove historic seq2science cache location\\n shutil.rmtree(os.path.expanduser(f\\\"~/.config/seq2science/\\\"), ignore_errors=True)\\n\\n print(\\\"All cleaned up!\\\")\",\n \"def clean():\\n click.secho(\\\"-\\\" * 88)\\n click.secho(\\\"Cleaning - Start\\\\n\\\")\\n click.secho(\\n \\\"Unnecessary files in the repository can cause errors while building the\\\\n\\\"\\n \\\"building the package. Check for some known issues.\\\\n\\\"\\n )\\n\\n # Check for environments in .tox.\\n tox_envs = list(Path(\\\".\\\", \\\".tox\\\").glob(\\\"*\\\"))\\n if tox_envs and click.confirm(\\n \\\"Do you want to remove all tests environments under .tox?\\\"\\n ):\\n for path in tox_envs:\\n subprocess.run(f\\\"conda env remove -p {path}\\\", shell=True)\\n shutil.rmtree(\\\".tox\\\")\\n\\n # Check for temporary files and folders which can be deleted.\\n for path in TEMPORARY_FOLDERS:\\n if path.is_dir():\\n shutil.rmtree(path)\\n elif path.is_file():\\n path.unlink()\\n else:\\n pass\\n\\n # Check for uncommitted and untracked files.\\n files = subprocess.run(\\n \\\"git status --porcelain\\\", shell=True, stdout=subprocess.PIPE\\n ).stdout.decode(\\\"utf-8\\\")\\n if files:\\n click.secho(\\n \\\"There are some uncommitted or untracked files. Please manually clean \\\\n\\\"\\n \\\"them up or move them somewhere else before proceeding.\\\\n\\\",\\n color=\\\"yellow\\\",\\n )\\n click.secho(files, color=\\\"yellow\\\")\\n raise click.Abort\\n\\n click.secho(\\\"Cleaning - End\\\")\\n click.secho(\\\"-\\\" * 88 + \\\"\\\\n\\\")\",\n \"def clean(working_directory):\\n\\n clean_directories(working_directory, (\\\"temp\\\", \\\"_build\\\"))\\n clean_files(working_directory, \\\".DS_Store\\\")\\n return 0\",\n \"def clean(raw_file,clean_path,results_path):\\n clean_file = clean_path + 'clean.pkl'\\n stats_file = results_path + 'corpus_stats.pkl' \\n raw_text = load_raw_text(raw_file) \\n clean_docs = list()\\n nlp = spacy.load('en')\\n i = 0\\n print('Cleaning documents...')\\n for text in raw_text: \\n words = nlp(text)\\n raw_count = len(words)\\n words = [w for w in words if not w.is_stop]\\n words = [w for w in words if w.ent_type_ != 'PERSON' and w.pos_ != 'PROPN']\\n words = [w for w in words if w.is_alpha and not w.is_digit]\\n words = [w.lemma_ for w in words if w.text != '-PRON-']\\n word_string = ' '.join(words)\\n word_string = word_string.lower()\\n doc = Document(word_string)\\n doc.clean_count = len(words)\\n doc.raw_count = raw_count\\n clean_docs.append(doc)\\n if i%10 == 0:\\n print('Document: ' + str(i))\\n i += 1\\n clean_corpus = Corpus(clean_docs)\\n clean_corpus.save_corpus_text(clean_file)\\n clean_corpus.save_corpus_stats(stats_file)\\n return clean_corpus\",\n \"def removevars(self,subset): # 3\\n num_ = None\\n if num_ is None:\\n num_ = len(subset)\\n elif num_ != len(subset):\\n raise IndexError(\\\"Inconsistent length of array subset\\\")\\n if num_ is None: num_ = 0\\n if subset is None: raise TypeError(\\\"Invalid type for argument subset\\\")\\n if subset is None:\\n subset_ = None\\n else:\\n try:\\n subset_ = memoryview(subset)\\n except TypeError:\\n try:\\n _tmparr_subset = array.array(\\\"i\\\",subset)\\n except TypeError:\\n raise TypeError(\\\"Argument subset has wrong type\\\")\\n else:\\n subset_ = memoryview(_tmparr_subset)\\n \\n else:\\n if subset_.format != \\\"i\\\":\\n subset_ = memoryview(array.array(\\\"i\\\",subset))\\n \\n res = self.__obj.removevars(num_,subset_)\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\",\n \"def clean_dataset(args, min_class_count=5):\\n classes_count = get_classes_count(args)\\n print(f\\\"cleaning dataset of {len(args)} arguments\\\")\\n classes_to_remove = []\\n for c in classes_count.keys():\\n if classes_count[c] < min_class_count:\\n classes_to_remove.append(c)\\n\\n clean_args = [a for a in args if a.frame_id not in classes_to_remove]\\n removed_args = [a for a in args if a.frame_id in classes_to_remove]\\n print(f\\\"removed {len(removed_args)} arguments from dataset. {len(clean_args)} remaining.\\\")\\n return clean_args, removed_args\",\n \"def calculate_mixture_features(args):\\n workspace = args.workspace\\n speech_dir = args.speech_dir\\n noise_dir = args.noise_dir\\n data_type = args.data_type\\n fs = cfg.sample_rate\\n dir_name = args.dir_name\\n\\n fid_clean = open(speech_dir, 'r')\\n lines_clean = fid_clean.readlines()\\n fid_clean.close()\\n\\n fid_reverb = open(noise_dir, 'r')\\n lines_reverb = fid_reverb.readlines()\\n fid_reverb.close()\\n\\n for files_clean, files_reverb in zip(lines_clean, lines_reverb):\\n\\n files_clean = files_clean.strip('\\\\n')\\n files_reverb = files_reverb.strip('\\\\n')\\n\\n fid = open(files_clean,'r')\\n wavLines_clean = fid.readlines()\\n fid.close()\\n fid = open(files_reverb,'r')\\n wavLines_reverb = fid.readlines()\\n fid.close()\\n\\n cnt = 0 \\n\\n for wavs_clean, wavs_reverb in zip(wavLines_clean, wavLines_reverb):\\n \\n t1 = time.time()\\n # cnt = 0\\n\\n wav_name_clean, wav_path_clean = wavs_clean.split()\\n wav_name_reverb, wav_path_reverb = wavs_reverb.split()\\n \\n # Read clean speech audio. \\n (speech_audio, _) = read_audio(wav_path_clean, target_fs=fs)\\n \\n # Read reverb speech audio. \\n (noise_audio, _) = read_audio(wav_path_reverb, target_fs=fs)\\n \\n # Cut reverb speech to the same length as clean speech. \\n if len(noise_audio) > len(speech_audio):\\n noise_audio = noise_audio[0: len(speech_audio)]\\n \\n # Extract spectrogram. \\n mixed_complx_x = calc_sp(noise_audio, mode='complex')\\n speech_x = calc_sp(speech_audio, mode='magnitude')\\n\\n # Write out features. \\n out_feat_path = os.path.join(workspace, \\\"features\\\", \\\"spectrogram\\\", \\n data_type, dir_name, \\\"%s.p\\\" % wav_name_reverb)\\n create_folder(os.path.dirname(out_feat_path))\\n data = [mixed_complx_x, speech_x, wav_name_reverb]\\n pickle.dump(data, open(out_feat_path, 'wb'), protocol=pickle.HIGHEST_PROTOCOL)\\n \\n # Print. \\n if cnt % 100 == 0:\\n print(cnt)\\n # print(mixed_complx_x)\\n # print(speech_x)\\n \\n cnt += 1\\n\\n print(\\\"Extracting feature time: %s\\\" % (time.time() - t1))\",\n \"def cleanTask(self, blTaskName):\\n return self._genericCommand('clean', blTaskName, 'all')\",\n \"def cleanTokenVocab(tokenVocab, corpus, freqTaux=1):\\n if configuration['embedding']['compactVocab']:\\n if configuration['others']['verbose']:\\n sys.stdout.write(tabs + 'Compact Vocabulary cleaning:' + doubleSep)\\n sys.stdout.write(tabs + 'Before : {0}\\\\n'.format(len(tokenVocab)))\\n for k in tokenVocab.keys():\\n if k not in [empty, unk, number] and k.lower() not in corpus.mweTokenDictionary and '_' not in k:\\n del tokenVocab[k]\\n if configuration['others']['verbose']:\\n sys.stdout.write(tabs + 'After : {0}\\\\n'.format(len(tokenVocab)))\\n\\n else:\\n if configuration['others']['verbose']:\\n sys.stdout.write(tabs + 'Non frequent word cleaning:' + doubleSep)\\n sys.stdout.write(tabs + 'Before : {0}\\\\n'.format(len(tokenVocab)))\\n for k in tokenVocab.keys():\\n if tokenVocab[k] <= freqTaux and '_' not in k and k.lower() not in corpus.mweTokenDictionary:\\n if uniform(0, 1) < configuration['constants']['alpha']:\\n del tokenVocab[k]\\n if configuration['others']['verbose']:\\n sys.stdout.write(tabs + 'After : {0}\\\\n'.format(len(tokenVocab)))\\n\\n return tokenVocab\",\n \"def test_all(data_wave, data_flux, data_unc, model_dict, params,\\n smooth=False,resolution=None,shortname=''):\\n\\n #logging.debug(data_wave.unit.to_string('fits'))\\n #logging.debug(data_unc.unit.to_string('fits'))\\n #logging.debug(model_dict['wavelength'].unit.to_string('fits'))\\n if data_wave.unit!=model_dict['wavelength'].unit:\\n logging.debug('changing units')\\n data_wave = data_wave.to(model_dict['wavelength'].unit)\\n #logging.debug(data_wave.unit.to_string('fits'))\\n\\n if ((len(model_dict['wavelength'])==len(data_wave)) and \\n (np.sum(model_dict['wavelength']-data_wave)<(model_dict['wavelength'].unit*1e-12))):\\n interp = False\\n logging.info('calc_chisq.test_all: NO INTERPOLATION')\\n else:\\n interp = True\\n logging.info('calc_chisq.test_all: INTERPOLATION NEEDED')\\n\\n\\n ndim = len(params)\\n\\n num_models = len(model_dict['flux'])\\n\\n chisq = np.ones(num_models)*(99e15)\\n\\t\\t\\n save_chisq = []\\n \\n for i in range(num_models):\\n# logging.debug('%d %d %f %f',i, num_models, model_dict['logg'][i], \\n# model_dict['teff'][i])\\n if smooth:\\n mod_flux = falt2(model_dict['wavelength'],model_dict['flux'][i],resolution)\\n else:\\n mod_flux = model_dict['flux'][i]\\n #logging.debug('shape flux {} mf {}'.format(np.shape(model_dict['flux']), np.shape(mod_flux)))\\n\\n #logging.debug('lengths dw {} modw {} modf {}'.format(\\n # len(data_wave),len(model_dict['wavelength']),len(mod_flux)))\\n if interp:\\n mod_flux = np.interp(data_wave,model_dict['wavelength'],mod_flux)\\n# mod_flux=mod_flux*u.erg/u.AA/u.cm**2/u.s\\n# logging.debug(str(mod_flux[100:110]))\\n# logging.debug('stdev %f', np.std(mod_flux))\\n# \\n mult1 = data_flux*mod_flux\\n bad = np.isnan(mult1)\\n mult = np.sum(mult1[~bad])\\n sq1 = mod_flux**2\\n square = np.sum(sq1[~bad])\\n ck = mult/square\\n mod_flux = mod_flux*ck\\n# mult1 = data_flux*mod_flux/(data_unc**2)\\n# bad = np.isnan(mult1)\\n# mult = np.sum(mult1[~bad])\\n# sq1 = mod_flux*mod_flux/(data_unc**2)\\n# mult2 = float(sum(sq1[~bad]))\\n# ck = mult/mult2\\n# mod_flux=mod_flux*ck\\n\\n chisq[i] = calc_chisq(data_flux, data_unc, mod_flux)\\n foo = plt.scatter(model_dict['teff'][i],chisq[i],c=model_dict['logg'][i],cmap=new_cmap,edgecolor='None',vmin=2.75,vmax=5.75)\\n params_list = []\\n for p in params:\\n params_list.append(model_dict[p][i])\\n save_chisq.append([params_list,chisq[i]]) \\n \\n min_loc = np.argmin(chisq)\\n# logging.debug('min_loc %d', min_loc)\\n best_params = np.array([])\\n for p in params:\\n best_params = np.append(best_params,model_dict[p][min_loc])\\n \\n plt.xlabel('$T_{eff}$',fontsize='x-large')\\n plt.ylabel('Goodness of Fit',fontsize='x-large')\\n plt.annotate('{}, {}'.format(shortname,best_params),xy=(0.5,0.95),xycoords='axes fraction')\\n fig = plt.gcf()\\n labels = np.arange(3.0,6.0,0.5)\\n fig.subplots_adjust(right=0.8)\\n cbar_ax = fig.add_axes([0.85, 0.15, 0.03, 0.7])\\n cbar = fig.colorbar(foo, cax=cbar_ax, ticks=labels)\\n cbar.set_label(label='$log(g)$',size=18)\\n plt.savefig('/Users/paigegiorla/Desktop/Teff_goodnesses_{}'.format(shortname)+'.pdf')\\n plt.clf()\\n \\n \\n fb = open('/Users/paigegiorla/Desktop/chisquares.pkl','wb')\\n pickle.dump(save_chisq,fb)\\n fb.close()\\n return best_params,min(chisq)\",\n \"def clean(self):\\n files = ['CHG', 'CHGCAR', 'POSCAR', 'INCAR', 'CONTCAR',\\n 'DOSCAR', 'EIGENVAL', 'IBZKPT', 'KPOINTS', 'OSZICAR',\\n 'OUTCAR', 'PCDAT', 'POTCAR', 'vasprun.xml',\\n 'WAVECAR', 'XDATCAR', 'PROCAR', 'ase-sort.dat',\\n 'LOCPOT', 'AECCAR0', 'AECCAR1', 'AECCAR2',\\n 'WAVECAR.GTO', 'vasp.out', 'vasp.err']\\n for f in files:\\n try:\\n os.remove(f)\\n except OSError:\\n pass\",\n \"def test_text_classifier_del_testing_samples_all(self):\\n pass\",\n \"def clean(notebook, execute):\\n nb = select_notebook(notebook)\\n nb.clean_assets(delete=execute)\",\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]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6328925","0.5590112","0.55339396","0.5511219","0.5465729","0.5374298","0.5327649","0.528877","0.526185","0.5248659","0.5220694","0.52137625","0.5190913","0.5170219","0.51530504","0.5150577","0.5133238","0.5131207","0.51212543","0.5066113","0.5057564","0.50250113","0.50106","0.5001389","0.4998821","0.49773732","0.49461597","0.49226782","0.4919465","0.4914035","0.49115303","0.4896438","0.48927048","0.4889507","0.4889357","0.48744354","0.48743796","0.48592004","0.48500225","0.48472345","0.48298496","0.48191792","0.48155665","0.48103902","0.48012415","0.47955406","0.47784734","0.47752756","0.47746274","0.47700426","0.4749633","0.47414893","0.47409862","0.4734687","0.4731262","0.4715891","0.47117874","0.4709674","0.46886536","0.4687704","0.46864188","0.46788648","0.46780676","0.4639619","0.46329787","0.46326563","0.46309778","0.46260715","0.46123272","0.46121663","0.46121663","0.46081996","0.46073484","0.46042842","0.4602681","0.4588771","0.45837012","0.4578395","0.45777923","0.45553225","0.45552152","0.45539147","0.45495692","0.45489195","0.4544895","0.4543578","0.45395708","0.45318073","0.45299318","0.45199773","0.4508059","0.45079532","0.45005703","0.44984168","0.4496222","0.44958398","0.44944206","0.44931307","0.44917846","0.44861853"],"string":"[\n \"0.6328925\",\n \"0.5590112\",\n \"0.55339396\",\n \"0.5511219\",\n \"0.5465729\",\n \"0.5374298\",\n \"0.5327649\",\n \"0.528877\",\n \"0.526185\",\n \"0.5248659\",\n \"0.5220694\",\n \"0.52137625\",\n \"0.5190913\",\n \"0.5170219\",\n \"0.51530504\",\n \"0.5150577\",\n \"0.5133238\",\n \"0.5131207\",\n \"0.51212543\",\n \"0.5066113\",\n \"0.5057564\",\n \"0.50250113\",\n \"0.50106\",\n \"0.5001389\",\n \"0.4998821\",\n \"0.49773732\",\n \"0.49461597\",\n \"0.49226782\",\n \"0.4919465\",\n \"0.4914035\",\n \"0.49115303\",\n \"0.4896438\",\n \"0.48927048\",\n \"0.4889507\",\n \"0.4889357\",\n \"0.48744354\",\n \"0.48743796\",\n \"0.48592004\",\n \"0.48500225\",\n \"0.48472345\",\n \"0.48298496\",\n \"0.48191792\",\n \"0.48155665\",\n \"0.48103902\",\n \"0.48012415\",\n \"0.47955406\",\n \"0.47784734\",\n \"0.47752756\",\n \"0.47746274\",\n \"0.47700426\",\n \"0.4749633\",\n \"0.47414893\",\n \"0.47409862\",\n \"0.4734687\",\n \"0.4731262\",\n \"0.4715891\",\n \"0.47117874\",\n \"0.4709674\",\n \"0.46886536\",\n \"0.4687704\",\n \"0.46864188\",\n \"0.46788648\",\n \"0.46780676\",\n \"0.4639619\",\n \"0.46329787\",\n \"0.46326563\",\n \"0.46309778\",\n \"0.46260715\",\n \"0.46123272\",\n \"0.46121663\",\n \"0.46121663\",\n \"0.46081996\",\n \"0.46073484\",\n \"0.46042842\",\n \"0.4602681\",\n \"0.4588771\",\n \"0.45837012\",\n \"0.4578395\",\n \"0.45777923\",\n \"0.45553225\",\n \"0.45552152\",\n \"0.45539147\",\n \"0.45495692\",\n \"0.45489195\",\n \"0.4544895\",\n \"0.4543578\",\n \"0.45395708\",\n \"0.45318073\",\n \"0.45299318\",\n \"0.45199773\",\n \"0.4508059\",\n \"0.45079532\",\n \"0.45005703\",\n \"0.44984168\",\n \"0.4496222\",\n \"0.44958398\",\n \"0.44944206\",\n \"0.44931307\",\n \"0.44917846\",\n \"0.44861853\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.539494"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":93183,"cells":{"query":{"kind":"string","value":"A utility function that converts an attribute name string into the corresponding attribute tag."},"document":{"kind":"string","value":"def convert_attribute_name_to_tag(value):\n if not isinstance(value, six.string_types):\n raise ValueError(\"The attribute name must be a string.\")\n\n for entry in attribute_name_tag_table:\n if value == entry[0]:\n return entry[1]\n\n raise ValueError(\"Unrecognized attribute name: '{}'\".format(value))"},"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 convert_attribute_tag_to_name(value):\n if not isinstance(value, Tags):\n raise ValueError(\"The attribute tag must be a Tags enumeration.\")\n\n for entry in attribute_name_tag_table:\n if value == entry[1]:\n return entry[0]\n\n raise ValueError(\"Unrecognized attribute tag: {}\".format(value))","def attribute_name(name: str) -> str:\n return text.snake_case(utils.safe_snake(name))","def _AttributeName(self, param_name, attribute_config, anchor=False):\n if attribute_config.attribute_name:\n return attribute_config.attribute_name\n if anchor:\n return 'name'\n return param_name.replace('Id', '_id').lower()","def rewrite_attribute_name(name, default_namespace='html'):\n\n # Handle any namespaces (just in case someday we support XHTML)\n if ':' in name:\n ns, name = name.split(':', 1)\n elif '__' in name:\n ns, name = name.split('__', 1)\n elif name == 'xmlns':\n ns = ''\n else:\n ns = default_namespace\n\n name.replace('__', '-')\n if ns == 'html':\n # We have an HTML attribute, fix according to DTD\n if name == 'content_type': # MIME type such as in <a> and <link> elements\n name = 'type'\n elif name == 'content_id': # moin historical convention\n name = 'id'\n elif name in ('css_class', 'css'): # to avoid python word 'class'\n name = 'class'\n elif name.startswith('on'): # event handler hook\n name = name.lower()\n return ns, name","def format_attr(attr: str) -> str:\r\n prefix = query_params[Toml.REMOVE_PREFIX]\r\n suffix = query_params[Toml.REMOVE_SUFFIX]\r\n prefix_len = len(prefix)\r\n suffix_len = len(suffix)\r\n stripped = attr.strip()\r\n if stripped[:prefix_len] == prefix:\r\n stripped = stripped[prefix_len:]\r\n if stripped[-suffix_len:] == suffix:\r\n stripped = stripped[:-suffix_len]\r\n return constcase(stripped).replace('__', '_')","def openTagAtt ( x, attName, attVal ):\n assert str(type(x)) == \"<type 'str'>\"\n assert str(type(attName)) == \"<type 'str'>\"\n assert str(type(attVal)) == \"<type 'str'>\"\n tag = \"<\" + str ( x ) + \" \" + str ( attName ) + \"='\" + str ( attVal ) +\"'>\"\n assert str ( type ( tag ) ) == \"<type 'str'>\"\n return tag","def Attribute(name, value=None):\r\n if value:\r\n return '{}=\"{}\"'.format(name, value)\r\n else:\r\n return ''","def render_attr(key, value, attr_format='{key}=\"{value}\"'):\n\n if not key or ' ' in key:\n raise InvalidAttribute('Invalid name \"{}\"'.format(key))\n\n if value:\n if type(value) is RawNode:\n value = str(value)\n else:\n value = html.escape(str(value))\n\n return attr_format.format(key=key, value=value)\n\n return key","def strpatt(self, name):\n return name.replace(\"att.\", \"\")","def closeTagAtt ( x, attName, attVal ):\n assert str(type(x)) == \"<type 'str'>\"\n assert str(type(attName)) == \"<type 'str'>\"\n assert str(type(attVal)) == \"<type 'str'>\"\n tag = \"<\" + str ( x ) + \" \" + str ( attName ) + \"='\" + str ( attVal ) +\"'/>\"\n assert str ( type ( tag ) ) == \"<type 'str'>\"\n return tag","def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])","def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])","def _convert_attribute_to_tag(key, attr):\n if isinstance(attr, bool):\n return jaeger.Tag(key=key, vBool=attr, vType=jaeger.TagType.BOOL)\n if isinstance(attr, str):\n return jaeger.Tag(key=key, vStr=attr, vType=jaeger.TagType.STRING)\n if isinstance(attr, int):\n return jaeger.Tag(key=key, vLong=attr, vType=jaeger.TagType.LONG)\n if isinstance(attr, float):\n return jaeger.Tag(key=key, vDouble=attr, vType=jaeger.TagType.DOUBLE)\n logger.warning(\"Could not serialize attribute %s:%r to tag\", key, attr)\n return None","def back_to_tag(tag, attrs):\n sol = '<' + tag\n for (prop, val) in attrs:\n sol += ' ' + prop + '=\"' + val + '\"'\n sol += '>'\n return sol","def _get_custom_attribute_field_name(self, attribute):\n return 'attribute_{0}'.format(attribute.id)","def str_attr(attr):\n return str(attr)","def _safe_attr(attr, camel_killer=False, replacement_char='x'):\n allowed = string.ascii_letters + string.digits + '_'\n attr = _safe_key(attr)\n if camel_killer:\n attr = _camel_killer(attr)\n attr = attr.replace(' ', '_')\n out = ''\n for character in attr:\n out += character if character in allowed else '_'\n out = out.strip('_')\n try:\n int(out[0])\n except (ValueError, IndexError):\n pass\n else:\n out = '{0}{1}'.format(replacement_char, out)\n if out in kwlist:\n out = '{0}{1}'.format(replacement_char, out)\n return re.sub('_+', '_', out)","def atttyp(att: str) -> str:\r\n\r\n return att[0:1]","def attr_namer(name, renames=renames):\n if name in renames:\n return renames[name]\n return name","def AttributeName(self, param_name):\n for attribute_name, p in six.iteritems(self.attribute_to_params_map):\n if p == param_name:\n return attribute_name","def attr(node: md.Document, name: str) -> str:\n return node.getAttribute(name)","def tag(\n name: str, value: str, *, attributes: dict = {}, namespace: str = None\n ) -> str:\n attributes_str = \" \".join(f'{k}=\"{v}\"' for k, v in attributes.items())\n ns = f\"{namespace}:\" if namespace else \"\"\n if attributes_str:\n attributes_str = \" \" + attributes_str\n if value:\n return f\"<{ns}{name}{attributes_str}>{value}</{ns}{name}>\"\n return f\"<{ns}{name}{attributes_str} />\"","def attr(*attrs: ATTRIBUTE) -> str:\n return PyHTML.attr(*attrs)","def create_attribute(owner_name, att_name, context=ast.Load(), line=0, column=0):\n attribute = ast.Attribute()\n attribute.attr = att_name\n attribute.ctx = context\n attribute.lineno = line\n attribute.col_offset = column\n\n if isinstance(owner_name, str):\n attribute_name = ast.Name()\n attribute_name.ctx = ast.Load()\n attribute_name.id = owner_name\n attribute_name.lineno = line\n attribute_name.col_offset = column\n\n attribute.value = attribute_name\n else:\n attribute.value = owner_name\n\n return attribute","def _arg_attr(identifier, attr1, attr2):\n return attr1 if identifier.startswith('t') else attr2","def get_attribute(self, attribute: str) -> str:\n pass","def attr(elem, attr):\n try:\n return elem[attr]\n except:\n return \"\"","def attr(elem, attr):\n try:\n return elem[attr]\n except:\n return \"\"","def get_attribute_by_name(attributes, attributeName):\n for attrib in attributes:\n if attrib['name'] == attributeName:\n return attrib\n return None","def AttributeString(self) -> str:","def AttributeString(self) -> str:","def _mangle_attr(name):\n return 'm_' + name","def attributeName(*args, leaf: bool=True, long: bool=True, nice: bool=True, short: bool=True,\n **kwargs)->AnyStr:\n pass","def renameAttr(*args, **kwargs)->AnyStr:\n pass","def queryAttributeNames(name):\n\n header, rows = querySciDB(\"attributes(%s)\" % name)\n return [row[1].translate(None, \"\\\"\") for row in rows]","def getAttrName(self, *args):\n return _libsbml.XMLToken_getAttrName(self, *args)","def construct_attribute(name: str, value: Any, tag: IppTag = None) -> bytes:\n bs = b\"\"\n\n if not tag:\n tag = ATTRIBUTE_TAG_MAP.get(name, None)\n\n if not tag:\n return bs\n\n if isinstance(value, (list, tuple, set)):\n for index, v in enumerate(value):\n bs += struct.pack(\">b\", tag.value)\n\n if index == 0:\n bs += struct.pack(\">h\", len(name))\n bs += name.encode(\"utf-8\")\n else:\n bs += struct.pack(\">h\", 0)\n\n bs += __construct_attibute_values(tag, v)\n else:\n bs = struct.pack(\">b\", tag.value)\n\n bs += struct.pack(\">h\", len(name))\n bs += name.encode(\"utf-8\")\n\n bs += __construct_attibute_values(tag, value)\n\n return bs","def _wrap_attr(attr):\n return '={0},'.format(attr)","def attr(*attrs: ATTRIBUTE) -> str:\n formatted = []\n for attr_ in attrs:\n if isinstance(attr_, str):\n formatted.append(attr_)\n elif isinstance(attr_, tuple) and len(attr_) == 2:\n formatted.append(f'{attr_[0]}=\"{attr_[1]}\"')\n else:\n raise ValueError(f\"Bad attribute: {attr_}\")\n return \" \".join(formatted)","def get_attr(attributes, name):\n try:\n return attributes.getValue(name)\n except KeyError:\n return None","def fix_attributes(string):\n defs = re.compile('<dl class=\"attribute\">(?P<descrip>.*?)</dl>',flags=re.DOTALL)\n name = re.compile('<code class=\"descclassname\">(?P<name>[^<]*)</code>')\n prefix = ''\n remain = string\n \n match = defs.search(remain)\n while match:\n prefix += remain[:match.start(1)]\n prefsub = ''\n remnsub = remain[match.start(1):match.end(1)]\n descrip = name.search(remnsub)\n if descrip:\n prefix += remnsub[:descrip.start()]\n prefix += remnsub[descrip.end():]\n prefix += remain[match.end(1):match.end(0)]\n else:\n prefix += remain[match.start(1):match.end(0)]\n remain = remain[match.end(0):]\n match = defs.search(remain)\n return prefix+remain","def map_field_name_to_attribute() -> typing.Dict:\n return {\n \"tag\": \"tag\",\n \"contact\": \"contact\",\n }","def extract_attrs(attr_string):\n attributes = {}\n for name, val in FIND_ATTRS.findall(attr_string):\n val = (\n val.replace(\"<\", \"<\")\n .replace(\">\", \">\")\n .replace(\""\", '\"')\n .replace(\"&\", \"&\")\n )\n attributes[name] = val\n return attributes","def xmlname_t(name):\n if not re.match(r'^L1Menu_\\w+', name):\n raise ValueError(\"not a valid menu name: '{name}'\".format(**locals()))\n return name","def _getatt(attrs, key, ns=None, default=None):\n keytuple = (ns, unicode(key))\n if attrs.has_key(keytuple):\n result = attrs[keytuple]\n else:\n result = default\n return result","def get_xml_attrib(el, key):\n for k in el.attrib.keys():\n if key == re.sub(\"^{.*}\", \"\", k):\n return el.attrib[k]","def visit_Attribute(self, node):\n new_node = ast.Name(\"%s.%s\" % (node.value.id, node.attr), node.ctx)\n return ast.copy_location(new_node, node)","def replaces_attribute(func: Callable[..., Tuple[str]], classname: str, attr_name: str):\n Replacements._attr_rep[(classname, attr_name)] = func\n return func","def apply_mapping_attr_name(self, attr_name, domain_taxon_set, range_taxon_set=None):\n return self.apply_mapping_func(lambda x: getattr(x, attr_name), domain_taxon_set=domain_taxon_set, range_taxon_set=range_taxon_set)","def getattr(parser, token):\n # This version uses a regular expression to parse tag contents.\n try:\n # Splitting by None == splitting by spaces.\n tag_name, arg = token.contents.split(None, 1)\n except ValueError:\n raise template.TemplateSyntaxError, \"%r needs arguments\" % token.contents.split()[0]\n m = re.search(r'(\\S+) (\\S+) as (.+)', arg)\n if not m:\n m = re.search(r'(\\S+) (\\S+)', arg.strip())\n if not m: \n raise template.TemplateSyntaxError,\\\n \"%r tag had invalid arguments\" % tag_name\n var_name, var_attr = m.groups()\n return GetAttrNode(var_name, var_attr,) \n var_name, var_attr, var_new = m.groups()\n return GetAttrNode(var_name, var_attr, var_new)","def get_attribute(self, name):\n\n pass","def string_for_attrs(attrs):\n if not attrs: return ''\n return ''.join(' %s=\"%s\"' % (attr, value) for attr, value in attrs)","def tagify(parsedtag):\n tag = \"\"\n for t in parsedtag:\n if t == '':\n t = '_'\n tag = tag+t\n return tag","def split_name_and_attrs(cls, tag_name):\n # transform `key=\"value\"` to `(key, value)`\n def to_pair(s):\n removed_quote = ''.join(ch for ch in s if ch not in ('\"', \"'\"))\n return removed_quote.split('=')\n\n name_parts = tag_name.split()\n name = name_parts[0]\n raw_attrs = [w for w in name_parts if \"=\" in w]\n tag_attrs = dict(to_pair(w) for w in raw_attrs)\n return name, tag_attrs","def _mk_tag(ns, tag):\n return '{%s}%s' % (ns, tag) if ns else tag","def getAttr(self, name, *args):\n if len(args) > 0:\n return self.attrs.get( name, args[0] )\n return self.attrs[name]","def visit_Attribute(self, node):\n self.generic_visit(node)\n if isinstance(node.ctx, ast.Load):\n args = [ node.value, ast.Str(node.attr) ]\n return to_call(to_name('getattr'), args)\n return node","def parse_attribute(self,attr,table):\n \n attr_dict = {}\n \n for child in attr:\n name = child.attrib['name']\n \n #attributes can either have string or bool as the value we need\n #checking for boolean\n if 'val' in child[0].attrib:\n val = child[0].attrib['val']\n \n if val == 'true':\n flag = True\n else:\n flag = False\n \n attr_dict[name] = flag\n \n #else it's string stroed as text\n else:\n attr_dict[name] = super(DatabaseUmlParser,self).stripHashtags(child[0].text)\n \n attr = db_attribute.DbAttribute(table,attr_dict)\n \n return attr","def get_activity_name(activity):\n for key in activity.attrib.keys():\n if key.endswith(\"name\"):\n return activity.attrib[key]","def _get_xml_tag(doc):\n tag = type(doc).type_key.split('.')[3]\n tag = convert.str_to_camel_case(tag)\n\n return tag","def process(name, attr):\n\t\t\t\n\t\t\t# If no name has been defined, define it declaratively.\n\t\t\tif not getattr(attr, '__name__', None):\n\t\t\t\tattr.__name__ = name\n\t\t\t\n\t\t\t# If this attribute existed previously, clone the sequence number to preserve order.\n\t\t\tif name in overridden_sequence:\n\t\t\t\tattr.__sequence__ = overridden_sequence[name]\n\t\t\t\n\t\t\t# We give attributes a chance to perform additional work.\n\t\t\tif hasattr(attr, '__fixup__'):\n\t\t\t\tfixups.append(attr) # Record the attribute to prevent __get__ transformation later.\n\t\t\t\n\t\t\treturn name, attr","def validate_string_attribute(tag, attribute_name, attribute_value):\n if not attribute_value:\n return\n\n if not isinstance(attribute_value, str):\n raise AttributeValueError('<{tag}>: {attribute_name} should be a '\n 'string value.'\n .format(tag=tag,\n attribute_name=attribute_name))","def __h5_attr(self, attr_name, ds_name):\n if ds_name is not None:\n dset = self.fid['/PRODUCT/{}'.format(ds_name)]\n if attr_name not in dset.attrs.keys():\n return None\n\n attr = dset.attrs[attr_name]\n else:\n if attr_name not in self.fid.attrs:\n return None\n\n attr = self.fid.attrs[attr_name]\n\n if isinstance(attr, bytes):\n return attr.decode('ascii')\n\n return attr","def make_tag(tag_name, text='', tag_attr=None):\n if tag_attr is None:\n tag_attr = {}\n\n doc = xml.dom.minidom.Document()\n element = doc.createElement(tag_name)\n if tag_attr:\n for k, v in izip(list(tag_attr.keys()), list(tag_attr.values())):\n element.setAttribute(unicode(k), unicode(v))\n if text:\n text_node = doc.createTextNode(text.strip())\n element.appendChild(text_node)\n return element","def html_simple_element(string, tag, attr_str=\"\"):\n if attr_str != \"\":\n attr_str = \" \" + attr_str\n return \"<\" + tag + attr_str + \">\" + string + \"</\" + tag + \">\"","def parse_any_attribute(cls, value: str, ns_map: Dict) -> str:\n prefix, suffix = text.split(value)\n if prefix and prefix in ns_map and not suffix.startswith(\"//\"):\n value = build_qname(ns_map[prefix], suffix)\n\n return value","def load_element_attribute(element, attribute_name):\n attribute_value = element.get(attribute_name)\n return convert_to_int_if_numeric(attribute_value)","def gen_tag_attrs(self, *a, **kw):\n return gen_tag_attrs(self, *a, **kw)","def getAttr(node, name):\n path = \"./attributelist/attribute[@name='%s']/@value\" % name\n n = node.xpathEval2(path)\n if len(n):\n return n[0].content\n else:\n return None","def _get_key(var_type, attr):\n if attr is None:\n return var_type\n return f'{var_type}{SEP}{attr}'","def __getitem__(self, attribute_name: str) -> Attribute:\n return self._attributes_by_name[attribute_name]","def mineral_attr(attribute):\n return attribute[0]","def attrs(*attributes):\n return ';'.join([ str(i) for i in attributes ])","def _normalize_element_name(some_str, element_aliases_dict=None):\n some_str = _lowercase_despace_depunctuate(some_str)\n if element_aliases_dict:\n for key in element_aliases_dict.keys():\n if key == some_str:\n some_str = element_aliases_dict[key]\n return some_str","def _xml_escape_attr(attr, skip_single_quote=True):\r\n escaped = (attr\r\n .replace('&', '&')\r\n .replace('\"', '"')\r\n .replace('<', '<')\r\n .replace('>', '>'))\r\n if not skip_single_quote:\r\n escaped = escaped.replace(\"'\", \"'\")\r\n return escaped","def html_attrs(attrs):\n html = \"\"\n for a in attrs.items():\n if a[1]:\n html = html + \"%s=\\\"%s\\\" \"%(a)\n return html","def get_attribute_by_name(self, name):\n if name in self._attributes:\n return self._attributes[name]","def find_attribute_id(self, attribute_name):\n attribute_id = None\n pr = self.layer.dataProvider()\n for field_id, field in enumerate(pr.fields()):\n if field.name() == attribute_name:\n attribute_id = field_id\n return attribute_id\n # In case the attribute has not been found, raise exception\n raise AttributeError('Attribute name %s not found' % attribute_name)","def render_name(name_att_list):\n res = ['']\n for k, v in name_att_list:\n v = dn_escape(v)\n res.append(\"%s=%s\" % (k, v))\n res.append('')\n return '/'.join(res)","def name2label(name):\n if name.endswith('_id'):\n name = name[:-3]\n return ' '.join([s.capitalize() for s in\n re.findall(r'([A-Z][a-z0-9]+|[a-z0-9]+|[A-Z0-9]+)', name)])","def get_attrs(str):\n return _scanner.scan(str)[0]","def attribute_key(self) -> str:\n return pulumi.get(self, \"attribute_key\")","def attr(self, name, value=None):\n name = force_str(name)\n if value is None:\n return self.get(name, None)\n elif name == 'class':\n self.add_class(value)\n else:\n self[name] = value","def str(self, att):\n for (k, v) in self.__dict__.items():\n if att == v:\n return k.replace(\"_\", \" \")\n raise AttributeError","def get_attribute_from_attid(self, attid):\n if len(self.hash_oid_name.keys()) == 0:\n self._populate_oid_attid()\n if self.get_oid_from_attid(attid) in self.hash_oid_name:\n return self.hash_oid_name[self.get_oid_from_attid(attid)]\n else:\n return None","def _parseAttributeString(self, line):\n attribute, value = line.partition(' ')[::2]\n self._setAttribute(attribute, value)","def canon(raw_attr_name: str) -> str:\n if raw_attr_name: # do not dereference None, and \"\" is already canonical\n return raw_attr_name.replace(\" \", \"\").lower()\n return raw_attr_name","def getAttribute(self, name):\n \n return self[self._name][name]","def _quoteattr(self, attr):\n attr = xml_safe(attr)\n if isinstance(attr, str) and not UNICODE_STRINGS:\n attr = attr.encode(self.encoding)\n return saxutils.quoteattr(attr)","def getAttrName(self, context):\r\n return self.attr if self.attr is not None else context.attr","def __getattr__(self, attr: str) -> str:\n\n if attr not in self.raw:\n raise AttributeError(\"unknown attribute '{}'\".format(attr))\n\n return self[attr]","def get_attribute(tdesc, attr_name, required=True):\n # Fields stored in hex format by default.\n default_hex = ('cipher_text', 'iv', 'key')\n\n data = tdesc.find(attr_name)\n if data is None:\n if required:\n raise subcmd.TpmTestError('node \"%s\" does not have attribute \"%s\"' %\n (tdesc.get('name'), attr_name))\n return ''\n\n # Attribute is present, does it have to be decoded from hex?\n cell_format = data.get('format')\n if not cell_format:\n if attr_name in default_hex:\n cell_format = 'hex'\n else:\n cell_format = 'ascii'\n elif cell_format not in ('hex', 'ascii'):\n raise subcmd.TpmTestError('%s:%s, unrecognizable format \"%s\"' %\n (tdesc.get('name'), attr_name, cell_format))\n\n text = ' '.join(x.strip() for x in data.text.splitlines() if x)\n if cell_format == 'ascii':\n return text\n\n # Drop spaces from hex representation.\n text = text.replace(' ', '')\n if len(text) & 3:\n raise subcmd.TpmTestError('%s:%s %swrong hex number size' %\n (tdesc.get('name'), attr_name, utils.hex_dump(text)))\n # Convert text to binary\n value = ''\n for x in range(len(text)/8):\n try:\n value += struct.pack('<I', int('0x%s' % text[8*x:8*(x+1)], 16))\n except ValueError:\n raise subcmd.TpmTestError('%s:%s %swrong hex value' %\n (tdesc.get('name'), attr_name, utils.hex_dump(text)))\n return value","def get_attr(self, attr_name, ds_name=None):\n if self.science_product:\n return self.__nc_attr(attr_name, ds_name)\n\n return self.__h5_attr(attr_name, ds_name)","def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)","def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)","def _quoteattr(self, attr):\n attr = xml_safe(attr)\n if isinstance(attr, unicode) and not UNICODE_STRINGS:\n attr = attr.encode(self.encoding)\n return saxutils.quoteattr(attr)","def attrsToString(self, attrs):\n string = \"\"\n # for every attribut\n for attr in attrs:\n # converts its name and value to string and adds this to string\n string += \" {}=\\\"{}\\\"\".format(attr[0], attr[1])\n # no exception!\n print(\"Das Attribut ist zu lang!\") if len(attr) > 2 else None\n return string","def prepare_attributes(attributes):\n new_attributes = []\n for attribute in attributes:\n new_attributes.append(\"e_\" + attribute)\n return new_attributes","def get_attribute(self, name):\n return self.element.get_attribute(name)","def _camel_killer(attr):\n try:\n attr = str(attr)\n except UnicodeEncodeError:\n attr = attr.encode('utf-8', 'ignore')\n s1 = _first_cap_re.sub('\\\\1_\\\\2', attr)\n s2 = _all_cap_re.sub('\\\\1_\\\\2', s1)\n return re.sub('_+', '_', s2.casefold() if hasattr(s2, 'casefold') else s2.lower())"],"string":"[\n \"def convert_attribute_tag_to_name(value):\\n if not isinstance(value, Tags):\\n raise ValueError(\\\"The attribute tag must be a Tags enumeration.\\\")\\n\\n for entry in attribute_name_tag_table:\\n if value == entry[1]:\\n return entry[0]\\n\\n raise ValueError(\\\"Unrecognized attribute tag: {}\\\".format(value))\",\n \"def attribute_name(name: str) -> str:\\n return text.snake_case(utils.safe_snake(name))\",\n \"def _AttributeName(self, param_name, attribute_config, anchor=False):\\n if attribute_config.attribute_name:\\n return attribute_config.attribute_name\\n if anchor:\\n return 'name'\\n return param_name.replace('Id', '_id').lower()\",\n \"def rewrite_attribute_name(name, default_namespace='html'):\\n\\n # Handle any namespaces (just in case someday we support XHTML)\\n if ':' in name:\\n ns, name = name.split(':', 1)\\n elif '__' in name:\\n ns, name = name.split('__', 1)\\n elif name == 'xmlns':\\n ns = ''\\n else:\\n ns = default_namespace\\n\\n name.replace('__', '-')\\n if ns == 'html':\\n # We have an HTML attribute, fix according to DTD\\n if name == 'content_type': # MIME type such as in <a> and <link> elements\\n name = 'type'\\n elif name == 'content_id': # moin historical convention\\n name = 'id'\\n elif name in ('css_class', 'css'): # to avoid python word 'class'\\n name = 'class'\\n elif name.startswith('on'): # event handler hook\\n name = name.lower()\\n return ns, name\",\n \"def format_attr(attr: str) -> str:\\r\\n prefix = query_params[Toml.REMOVE_PREFIX]\\r\\n suffix = query_params[Toml.REMOVE_SUFFIX]\\r\\n prefix_len = len(prefix)\\r\\n suffix_len = len(suffix)\\r\\n stripped = attr.strip()\\r\\n if stripped[:prefix_len] == prefix:\\r\\n stripped = stripped[prefix_len:]\\r\\n if stripped[-suffix_len:] == suffix:\\r\\n stripped = stripped[:-suffix_len]\\r\\n return constcase(stripped).replace('__', '_')\",\n \"def openTagAtt ( x, attName, attVal ):\\n assert str(type(x)) == \\\"<type 'str'>\\\"\\n assert str(type(attName)) == \\\"<type 'str'>\\\"\\n assert str(type(attVal)) == \\\"<type 'str'>\\\"\\n tag = \\\"<\\\" + str ( x ) + \\\" \\\" + str ( attName ) + \\\"='\\\" + str ( attVal ) +\\\"'>\\\"\\n assert str ( type ( tag ) ) == \\\"<type 'str'>\\\"\\n return tag\",\n \"def Attribute(name, value=None):\\r\\n if value:\\r\\n return '{}=\\\"{}\\\"'.format(name, value)\\r\\n else:\\r\\n return ''\",\n \"def render_attr(key, value, attr_format='{key}=\\\"{value}\\\"'):\\n\\n if not key or ' ' in key:\\n raise InvalidAttribute('Invalid name \\\"{}\\\"'.format(key))\\n\\n if value:\\n if type(value) is RawNode:\\n value = str(value)\\n else:\\n value = html.escape(str(value))\\n\\n return attr_format.format(key=key, value=value)\\n\\n return key\",\n \"def strpatt(self, name):\\n return name.replace(\\\"att.\\\", \\\"\\\")\",\n \"def closeTagAtt ( x, attName, attVal ):\\n assert str(type(x)) == \\\"<type 'str'>\\\"\\n assert str(type(attName)) == \\\"<type 'str'>\\\"\\n assert str(type(attVal)) == \\\"<type 'str'>\\\"\\n tag = \\\"<\\\" + str ( x ) + \\\" \\\" + str ( attName ) + \\\"='\\\" + str ( attVal ) +\\\"'/>\\\"\\n assert str ( type ( tag ) ) == \\\"<type 'str'>\\\"\\n return tag\",\n \"def flatatt(attrs):\\n return u''.join([u' %s=\\\"%s\\\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])\",\n \"def flatatt(attrs):\\n return u''.join([u' %s=\\\"%s\\\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])\",\n \"def _convert_attribute_to_tag(key, attr):\\n if isinstance(attr, bool):\\n return jaeger.Tag(key=key, vBool=attr, vType=jaeger.TagType.BOOL)\\n if isinstance(attr, str):\\n return jaeger.Tag(key=key, vStr=attr, vType=jaeger.TagType.STRING)\\n if isinstance(attr, int):\\n return jaeger.Tag(key=key, vLong=attr, vType=jaeger.TagType.LONG)\\n if isinstance(attr, float):\\n return jaeger.Tag(key=key, vDouble=attr, vType=jaeger.TagType.DOUBLE)\\n logger.warning(\\\"Could not serialize attribute %s:%r to tag\\\", key, attr)\\n return None\",\n \"def back_to_tag(tag, attrs):\\n sol = '<' + tag\\n for (prop, val) in attrs:\\n sol += ' ' + prop + '=\\\"' + val + '\\\"'\\n sol += '>'\\n return sol\",\n \"def _get_custom_attribute_field_name(self, attribute):\\n return 'attribute_{0}'.format(attribute.id)\",\n \"def str_attr(attr):\\n return str(attr)\",\n \"def _safe_attr(attr, camel_killer=False, replacement_char='x'):\\n allowed = string.ascii_letters + string.digits + '_'\\n attr = _safe_key(attr)\\n if camel_killer:\\n attr = _camel_killer(attr)\\n attr = attr.replace(' ', '_')\\n out = ''\\n for character in attr:\\n out += character if character in allowed else '_'\\n out = out.strip('_')\\n try:\\n int(out[0])\\n except (ValueError, IndexError):\\n pass\\n else:\\n out = '{0}{1}'.format(replacement_char, out)\\n if out in kwlist:\\n out = '{0}{1}'.format(replacement_char, out)\\n return re.sub('_+', '_', out)\",\n \"def atttyp(att: str) -> str:\\r\\n\\r\\n return att[0:1]\",\n \"def attr_namer(name, renames=renames):\\n if name in renames:\\n return renames[name]\\n return name\",\n \"def AttributeName(self, param_name):\\n for attribute_name, p in six.iteritems(self.attribute_to_params_map):\\n if p == param_name:\\n return attribute_name\",\n \"def attr(node: md.Document, name: str) -> str:\\n return node.getAttribute(name)\",\n \"def tag(\\n name: str, value: str, *, attributes: dict = {}, namespace: str = None\\n ) -> str:\\n attributes_str = \\\" \\\".join(f'{k}=\\\"{v}\\\"' for k, v in attributes.items())\\n ns = f\\\"{namespace}:\\\" if namespace else \\\"\\\"\\n if attributes_str:\\n attributes_str = \\\" \\\" + attributes_str\\n if value:\\n return f\\\"<{ns}{name}{attributes_str}>{value}</{ns}{name}>\\\"\\n return f\\\"<{ns}{name}{attributes_str} />\\\"\",\n \"def attr(*attrs: ATTRIBUTE) -> str:\\n return PyHTML.attr(*attrs)\",\n \"def create_attribute(owner_name, att_name, context=ast.Load(), line=0, column=0):\\n attribute = ast.Attribute()\\n attribute.attr = att_name\\n attribute.ctx = context\\n attribute.lineno = line\\n attribute.col_offset = column\\n\\n if isinstance(owner_name, str):\\n attribute_name = ast.Name()\\n attribute_name.ctx = ast.Load()\\n attribute_name.id = owner_name\\n attribute_name.lineno = line\\n attribute_name.col_offset = column\\n\\n attribute.value = attribute_name\\n else:\\n attribute.value = owner_name\\n\\n return attribute\",\n \"def _arg_attr(identifier, attr1, attr2):\\n return attr1 if identifier.startswith('t') else attr2\",\n \"def get_attribute(self, attribute: str) -> str:\\n pass\",\n \"def attr(elem, attr):\\n try:\\n return elem[attr]\\n except:\\n return \\\"\\\"\",\n \"def attr(elem, attr):\\n try:\\n return elem[attr]\\n except:\\n return \\\"\\\"\",\n \"def get_attribute_by_name(attributes, attributeName):\\n for attrib in attributes:\\n if attrib['name'] == attributeName:\\n return attrib\\n return None\",\n \"def AttributeString(self) -> str:\",\n \"def AttributeString(self) -> str:\",\n \"def _mangle_attr(name):\\n return 'm_' + name\",\n \"def attributeName(*args, leaf: bool=True, long: bool=True, nice: bool=True, short: bool=True,\\n **kwargs)->AnyStr:\\n pass\",\n \"def renameAttr(*args, **kwargs)->AnyStr:\\n pass\",\n \"def queryAttributeNames(name):\\n\\n header, rows = querySciDB(\\\"attributes(%s)\\\" % name)\\n return [row[1].translate(None, \\\"\\\\\\\"\\\") for row in rows]\",\n \"def getAttrName(self, *args):\\n return _libsbml.XMLToken_getAttrName(self, *args)\",\n \"def construct_attribute(name: str, value: Any, tag: IppTag = None) -> bytes:\\n bs = b\\\"\\\"\\n\\n if not tag:\\n tag = ATTRIBUTE_TAG_MAP.get(name, None)\\n\\n if not tag:\\n return bs\\n\\n if isinstance(value, (list, tuple, set)):\\n for index, v in enumerate(value):\\n bs += struct.pack(\\\">b\\\", tag.value)\\n\\n if index == 0:\\n bs += struct.pack(\\\">h\\\", len(name))\\n bs += name.encode(\\\"utf-8\\\")\\n else:\\n bs += struct.pack(\\\">h\\\", 0)\\n\\n bs += __construct_attibute_values(tag, v)\\n else:\\n bs = struct.pack(\\\">b\\\", tag.value)\\n\\n bs += struct.pack(\\\">h\\\", len(name))\\n bs += name.encode(\\\"utf-8\\\")\\n\\n bs += __construct_attibute_values(tag, value)\\n\\n return bs\",\n \"def _wrap_attr(attr):\\n return '={0},'.format(attr)\",\n \"def attr(*attrs: ATTRIBUTE) -> str:\\n formatted = []\\n for attr_ in attrs:\\n if isinstance(attr_, str):\\n formatted.append(attr_)\\n elif isinstance(attr_, tuple) and len(attr_) == 2:\\n formatted.append(f'{attr_[0]}=\\\"{attr_[1]}\\\"')\\n else:\\n raise ValueError(f\\\"Bad attribute: {attr_}\\\")\\n return \\\" \\\".join(formatted)\",\n \"def get_attr(attributes, name):\\n try:\\n return attributes.getValue(name)\\n except KeyError:\\n return None\",\n \"def fix_attributes(string):\\n defs = re.compile('<dl class=\\\"attribute\\\">(?P<descrip>.*?)</dl>',flags=re.DOTALL)\\n name = re.compile('<code class=\\\"descclassname\\\">(?P<name>[^<]*)</code>')\\n prefix = ''\\n remain = string\\n \\n match = defs.search(remain)\\n while match:\\n prefix += remain[:match.start(1)]\\n prefsub = ''\\n remnsub = remain[match.start(1):match.end(1)]\\n descrip = name.search(remnsub)\\n if descrip:\\n prefix += remnsub[:descrip.start()]\\n prefix += remnsub[descrip.end():]\\n prefix += remain[match.end(1):match.end(0)]\\n else:\\n prefix += remain[match.start(1):match.end(0)]\\n remain = remain[match.end(0):]\\n match = defs.search(remain)\\n return prefix+remain\",\n \"def map_field_name_to_attribute() -> typing.Dict:\\n return {\\n \\\"tag\\\": \\\"tag\\\",\\n \\\"contact\\\": \\\"contact\\\",\\n }\",\n \"def extract_attrs(attr_string):\\n attributes = {}\\n for name, val in FIND_ATTRS.findall(attr_string):\\n val = (\\n val.replace(\\\"<\\\", \\\"<\\\")\\n .replace(\\\">\\\", \\\">\\\")\\n .replace(\\\""\\\", '\\\"')\\n .replace(\\\"&\\\", \\\"&\\\")\\n )\\n attributes[name] = val\\n return attributes\",\n \"def xmlname_t(name):\\n if not re.match(r'^L1Menu_\\\\w+', name):\\n raise ValueError(\\\"not a valid menu name: '{name}'\\\".format(**locals()))\\n return name\",\n \"def _getatt(attrs, key, ns=None, default=None):\\n keytuple = (ns, unicode(key))\\n if attrs.has_key(keytuple):\\n result = attrs[keytuple]\\n else:\\n result = default\\n return result\",\n \"def get_xml_attrib(el, key):\\n for k in el.attrib.keys():\\n if key == re.sub(\\\"^{.*}\\\", \\\"\\\", k):\\n return el.attrib[k]\",\n \"def visit_Attribute(self, node):\\n new_node = ast.Name(\\\"%s.%s\\\" % (node.value.id, node.attr), node.ctx)\\n return ast.copy_location(new_node, node)\",\n \"def replaces_attribute(func: Callable[..., Tuple[str]], classname: str, attr_name: str):\\n Replacements._attr_rep[(classname, attr_name)] = func\\n return func\",\n \"def apply_mapping_attr_name(self, attr_name, domain_taxon_set, range_taxon_set=None):\\n return self.apply_mapping_func(lambda x: getattr(x, attr_name), domain_taxon_set=domain_taxon_set, range_taxon_set=range_taxon_set)\",\n \"def getattr(parser, token):\\n # This version uses a regular expression to parse tag contents.\\n try:\\n # Splitting by None == splitting by spaces.\\n tag_name, arg = token.contents.split(None, 1)\\n except ValueError:\\n raise template.TemplateSyntaxError, \\\"%r needs arguments\\\" % token.contents.split()[0]\\n m = re.search(r'(\\\\S+) (\\\\S+) as (.+)', arg)\\n if not m:\\n m = re.search(r'(\\\\S+) (\\\\S+)', arg.strip())\\n if not m: \\n raise template.TemplateSyntaxError,\\\\\\n \\\"%r tag had invalid arguments\\\" % tag_name\\n var_name, var_attr = m.groups()\\n return GetAttrNode(var_name, var_attr,) \\n var_name, var_attr, var_new = m.groups()\\n return GetAttrNode(var_name, var_attr, var_new)\",\n \"def get_attribute(self, name):\\n\\n pass\",\n \"def string_for_attrs(attrs):\\n if not attrs: return ''\\n return ''.join(' %s=\\\"%s\\\"' % (attr, value) for attr, value in attrs)\",\n \"def tagify(parsedtag):\\n tag = \\\"\\\"\\n for t in parsedtag:\\n if t == '':\\n t = '_'\\n tag = tag+t\\n return tag\",\n \"def split_name_and_attrs(cls, tag_name):\\n # transform `key=\\\"value\\\"` to `(key, value)`\\n def to_pair(s):\\n removed_quote = ''.join(ch for ch in s if ch not in ('\\\"', \\\"'\\\"))\\n return removed_quote.split('=')\\n\\n name_parts = tag_name.split()\\n name = name_parts[0]\\n raw_attrs = [w for w in name_parts if \\\"=\\\" in w]\\n tag_attrs = dict(to_pair(w) for w in raw_attrs)\\n return name, tag_attrs\",\n \"def _mk_tag(ns, tag):\\n return '{%s}%s' % (ns, tag) if ns else tag\",\n \"def getAttr(self, name, *args):\\n if len(args) > 0:\\n return self.attrs.get( name, args[0] )\\n return self.attrs[name]\",\n \"def visit_Attribute(self, node):\\n self.generic_visit(node)\\n if isinstance(node.ctx, ast.Load):\\n args = [ node.value, ast.Str(node.attr) ]\\n return to_call(to_name('getattr'), args)\\n return node\",\n \"def parse_attribute(self,attr,table):\\n \\n attr_dict = {}\\n \\n for child in attr:\\n name = child.attrib['name']\\n \\n #attributes can either have string or bool as the value we need\\n #checking for boolean\\n if 'val' in child[0].attrib:\\n val = child[0].attrib['val']\\n \\n if val == 'true':\\n flag = True\\n else:\\n flag = False\\n \\n attr_dict[name] = flag\\n \\n #else it's string stroed as text\\n else:\\n attr_dict[name] = super(DatabaseUmlParser,self).stripHashtags(child[0].text)\\n \\n attr = db_attribute.DbAttribute(table,attr_dict)\\n \\n return attr\",\n \"def get_activity_name(activity):\\n for key in activity.attrib.keys():\\n if key.endswith(\\\"name\\\"):\\n return activity.attrib[key]\",\n \"def _get_xml_tag(doc):\\n tag = type(doc).type_key.split('.')[3]\\n tag = convert.str_to_camel_case(tag)\\n\\n return tag\",\n \"def process(name, attr):\\n\\t\\t\\t\\n\\t\\t\\t# If no name has been defined, define it declaratively.\\n\\t\\t\\tif not getattr(attr, '__name__', None):\\n\\t\\t\\t\\tattr.__name__ = name\\n\\t\\t\\t\\n\\t\\t\\t# If this attribute existed previously, clone the sequence number to preserve order.\\n\\t\\t\\tif name in overridden_sequence:\\n\\t\\t\\t\\tattr.__sequence__ = overridden_sequence[name]\\n\\t\\t\\t\\n\\t\\t\\t# We give attributes a chance to perform additional work.\\n\\t\\t\\tif hasattr(attr, '__fixup__'):\\n\\t\\t\\t\\tfixups.append(attr) # Record the attribute to prevent __get__ transformation later.\\n\\t\\t\\t\\n\\t\\t\\treturn name, attr\",\n \"def validate_string_attribute(tag, attribute_name, attribute_value):\\n if not attribute_value:\\n return\\n\\n if not isinstance(attribute_value, str):\\n raise AttributeValueError('<{tag}>: {attribute_name} should be a '\\n 'string value.'\\n .format(tag=tag,\\n attribute_name=attribute_name))\",\n \"def __h5_attr(self, attr_name, ds_name):\\n if ds_name is not None:\\n dset = self.fid['/PRODUCT/{}'.format(ds_name)]\\n if attr_name not in dset.attrs.keys():\\n return None\\n\\n attr = dset.attrs[attr_name]\\n else:\\n if attr_name not in self.fid.attrs:\\n return None\\n\\n attr = self.fid.attrs[attr_name]\\n\\n if isinstance(attr, bytes):\\n return attr.decode('ascii')\\n\\n return attr\",\n \"def make_tag(tag_name, text='', tag_attr=None):\\n if tag_attr is None:\\n tag_attr = {}\\n\\n doc = xml.dom.minidom.Document()\\n element = doc.createElement(tag_name)\\n if tag_attr:\\n for k, v in izip(list(tag_attr.keys()), list(tag_attr.values())):\\n element.setAttribute(unicode(k), unicode(v))\\n if text:\\n text_node = doc.createTextNode(text.strip())\\n element.appendChild(text_node)\\n return element\",\n \"def html_simple_element(string, tag, attr_str=\\\"\\\"):\\n if attr_str != \\\"\\\":\\n attr_str = \\\" \\\" + attr_str\\n return \\\"<\\\" + tag + attr_str + \\\">\\\" + string + \\\"</\\\" + tag + \\\">\\\"\",\n \"def parse_any_attribute(cls, value: str, ns_map: Dict) -> str:\\n prefix, suffix = text.split(value)\\n if prefix and prefix in ns_map and not suffix.startswith(\\\"//\\\"):\\n value = build_qname(ns_map[prefix], suffix)\\n\\n return value\",\n \"def load_element_attribute(element, attribute_name):\\n attribute_value = element.get(attribute_name)\\n return convert_to_int_if_numeric(attribute_value)\",\n \"def gen_tag_attrs(self, *a, **kw):\\n return gen_tag_attrs(self, *a, **kw)\",\n \"def getAttr(node, name):\\n path = \\\"./attributelist/attribute[@name='%s']/@value\\\" % name\\n n = node.xpathEval2(path)\\n if len(n):\\n return n[0].content\\n else:\\n return None\",\n \"def _get_key(var_type, attr):\\n if attr is None:\\n return var_type\\n return f'{var_type}{SEP}{attr}'\",\n \"def __getitem__(self, attribute_name: str) -> Attribute:\\n return self._attributes_by_name[attribute_name]\",\n \"def mineral_attr(attribute):\\n return attribute[0]\",\n \"def attrs(*attributes):\\n return ';'.join([ str(i) for i in attributes ])\",\n \"def _normalize_element_name(some_str, element_aliases_dict=None):\\n some_str = _lowercase_despace_depunctuate(some_str)\\n if element_aliases_dict:\\n for key in element_aliases_dict.keys():\\n if key == some_str:\\n some_str = element_aliases_dict[key]\\n return some_str\",\n \"def _xml_escape_attr(attr, skip_single_quote=True):\\r\\n escaped = (attr\\r\\n .replace('&', '&')\\r\\n .replace('\\\"', '"')\\r\\n .replace('<', '<')\\r\\n .replace('>', '>'))\\r\\n if not skip_single_quote:\\r\\n escaped = escaped.replace(\\\"'\\\", \\\"'\\\")\\r\\n return escaped\",\n \"def html_attrs(attrs):\\n html = \\\"\\\"\\n for a in attrs.items():\\n if a[1]:\\n html = html + \\\"%s=\\\\\\\"%s\\\\\\\" \\\"%(a)\\n return html\",\n \"def get_attribute_by_name(self, name):\\n if name in self._attributes:\\n return self._attributes[name]\",\n \"def find_attribute_id(self, attribute_name):\\n attribute_id = None\\n pr = self.layer.dataProvider()\\n for field_id, field in enumerate(pr.fields()):\\n if field.name() == attribute_name:\\n attribute_id = field_id\\n return attribute_id\\n # In case the attribute has not been found, raise exception\\n raise AttributeError('Attribute name %s not found' % attribute_name)\",\n \"def render_name(name_att_list):\\n res = ['']\\n for k, v in name_att_list:\\n v = dn_escape(v)\\n res.append(\\\"%s=%s\\\" % (k, v))\\n res.append('')\\n return '/'.join(res)\",\n \"def name2label(name):\\n if name.endswith('_id'):\\n name = name[:-3]\\n return ' '.join([s.capitalize() for s in\\n re.findall(r'([A-Z][a-z0-9]+|[a-z0-9]+|[A-Z0-9]+)', name)])\",\n \"def get_attrs(str):\\n return _scanner.scan(str)[0]\",\n \"def attribute_key(self) -> str:\\n return pulumi.get(self, \\\"attribute_key\\\")\",\n \"def attr(self, name, value=None):\\n name = force_str(name)\\n if value is None:\\n return self.get(name, None)\\n elif name == 'class':\\n self.add_class(value)\\n else:\\n self[name] = value\",\n \"def str(self, att):\\n for (k, v) in self.__dict__.items():\\n if att == v:\\n return k.replace(\\\"_\\\", \\\" \\\")\\n raise AttributeError\",\n \"def get_attribute_from_attid(self, attid):\\n if len(self.hash_oid_name.keys()) == 0:\\n self._populate_oid_attid()\\n if self.get_oid_from_attid(attid) in self.hash_oid_name:\\n return self.hash_oid_name[self.get_oid_from_attid(attid)]\\n else:\\n return None\",\n \"def _parseAttributeString(self, line):\\n attribute, value = line.partition(' ')[::2]\\n self._setAttribute(attribute, value)\",\n \"def canon(raw_attr_name: str) -> str:\\n if raw_attr_name: # do not dereference None, and \\\"\\\" is already canonical\\n return raw_attr_name.replace(\\\" \\\", \\\"\\\").lower()\\n return raw_attr_name\",\n \"def getAttribute(self, name):\\n \\n return self[self._name][name]\",\n \"def _quoteattr(self, attr):\\n attr = xml_safe(attr)\\n if isinstance(attr, str) and not UNICODE_STRINGS:\\n attr = attr.encode(self.encoding)\\n return saxutils.quoteattr(attr)\",\n \"def getAttrName(self, context):\\r\\n return self.attr if self.attr is not None else context.attr\",\n \"def __getattr__(self, attr: str) -> str:\\n\\n if attr not in self.raw:\\n raise AttributeError(\\\"unknown attribute '{}'\\\".format(attr))\\n\\n return self[attr]\",\n \"def get_attribute(tdesc, attr_name, required=True):\\n # Fields stored in hex format by default.\\n default_hex = ('cipher_text', 'iv', 'key')\\n\\n data = tdesc.find(attr_name)\\n if data is None:\\n if required:\\n raise subcmd.TpmTestError('node \\\"%s\\\" does not have attribute \\\"%s\\\"' %\\n (tdesc.get('name'), attr_name))\\n return ''\\n\\n # Attribute is present, does it have to be decoded from hex?\\n cell_format = data.get('format')\\n if not cell_format:\\n if attr_name in default_hex:\\n cell_format = 'hex'\\n else:\\n cell_format = 'ascii'\\n elif cell_format not in ('hex', 'ascii'):\\n raise subcmd.TpmTestError('%s:%s, unrecognizable format \\\"%s\\\"' %\\n (tdesc.get('name'), attr_name, cell_format))\\n\\n text = ' '.join(x.strip() for x in data.text.splitlines() if x)\\n if cell_format == 'ascii':\\n return text\\n\\n # Drop spaces from hex representation.\\n text = text.replace(' ', '')\\n if len(text) & 3:\\n raise subcmd.TpmTestError('%s:%s %swrong hex number size' %\\n (tdesc.get('name'), attr_name, utils.hex_dump(text)))\\n # Convert text to binary\\n value = ''\\n for x in range(len(text)/8):\\n try:\\n value += struct.pack('<I', int('0x%s' % text[8*x:8*(x+1)], 16))\\n except ValueError:\\n raise subcmd.TpmTestError('%s:%s %swrong hex value' %\\n (tdesc.get('name'), attr_name, utils.hex_dump(text)))\\n return value\",\n \"def get_attr(self, attr_name, ds_name=None):\\n if self.science_product:\\n return self.__nc_attr(attr_name, ds_name)\\n\\n return self.__h5_attr(attr_name, ds_name)\",\n \"def parse_tag_attrs(self, *a, **kw):\\n return parse_tag_attrs(*a, **kw)\",\n \"def parse_tag_attrs(self, *a, **kw):\\n return parse_tag_attrs(*a, **kw)\",\n \"def _quoteattr(self, attr):\\n attr = xml_safe(attr)\\n if isinstance(attr, unicode) and not UNICODE_STRINGS:\\n attr = attr.encode(self.encoding)\\n return saxutils.quoteattr(attr)\",\n \"def attrsToString(self, attrs):\\n string = \\\"\\\"\\n # for every attribut\\n for attr in attrs:\\n # converts its name and value to string and adds this to string\\n string += \\\" {}=\\\\\\\"{}\\\\\\\"\\\".format(attr[0], attr[1])\\n # no exception!\\n print(\\\"Das Attribut ist zu lang!\\\") if len(attr) > 2 else None\\n return string\",\n \"def prepare_attributes(attributes):\\n new_attributes = []\\n for attribute in attributes:\\n new_attributes.append(\\\"e_\\\" + attribute)\\n return new_attributes\",\n \"def get_attribute(self, name):\\n return self.element.get_attribute(name)\",\n \"def _camel_killer(attr):\\n try:\\n attr = str(attr)\\n except UnicodeEncodeError:\\n attr = attr.encode('utf-8', 'ignore')\\n s1 = _first_cap_re.sub('\\\\\\\\1_\\\\\\\\2', attr)\\n s2 = _all_cap_re.sub('\\\\\\\\1_\\\\\\\\2', s1)\\n return re.sub('_+', '_', s2.casefold() if hasattr(s2, 'casefold') else s2.lower())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74248964","0.71455866","0.6820382","0.6814265","0.6467705","0.6433419","0.63990474","0.6338518","0.6189894","0.60293674","0.6026002","0.6026002","0.6018459","0.5988461","0.5980702","0.59706277","0.5942196","0.5880535","0.58307683","0.58123","0.58119905","0.5810482","0.58099914","0.5782411","0.57416636","0.57398015","0.57208914","0.57208914","0.5659727","0.5659636","0.5659636","0.5651622","0.56192744","0.56029564","0.5601348","0.5566951","0.55590194","0.5548958","0.5545892","0.5543612","0.55239594","0.54762775","0.5445312","0.5400698","0.53785783","0.5374567","0.53733546","0.53690875","0.5365313","0.5330938","0.5328008","0.53235453","0.5314101","0.5310281","0.53058493","0.5260593","0.5257936","0.52447474","0.52358985","0.5235221","0.52257377","0.52134407","0.52072644","0.5201305","0.5195889","0.51914316","0.5183117","0.5177773","0.5159056","0.5157572","0.5149601","0.51371723","0.51352155","0.51297367","0.5126853","0.5123741","0.512045","0.5120106","0.5119972","0.51077497","0.5104306","0.51039046","0.51015264","0.5101514","0.51003736","0.50890946","0.50890744","0.50870633","0.50845426","0.5082164","0.5080612","0.5072215","0.5068785","0.5060603","0.5060603","0.5057165","0.5043689","0.503746","0.50347906","0.50316244"],"string":"[\n \"0.74248964\",\n \"0.71455866\",\n \"0.6820382\",\n \"0.6814265\",\n \"0.6467705\",\n \"0.6433419\",\n \"0.63990474\",\n \"0.6338518\",\n \"0.6189894\",\n \"0.60293674\",\n \"0.6026002\",\n \"0.6026002\",\n \"0.6018459\",\n \"0.5988461\",\n \"0.5980702\",\n \"0.59706277\",\n \"0.5942196\",\n \"0.5880535\",\n \"0.58307683\",\n \"0.58123\",\n \"0.58119905\",\n \"0.5810482\",\n \"0.58099914\",\n \"0.5782411\",\n \"0.57416636\",\n \"0.57398015\",\n \"0.57208914\",\n \"0.57208914\",\n \"0.5659727\",\n \"0.5659636\",\n \"0.5659636\",\n \"0.5651622\",\n \"0.56192744\",\n \"0.56029564\",\n \"0.5601348\",\n \"0.5566951\",\n \"0.55590194\",\n \"0.5548958\",\n \"0.5545892\",\n \"0.5543612\",\n \"0.55239594\",\n \"0.54762775\",\n \"0.5445312\",\n \"0.5400698\",\n \"0.53785783\",\n \"0.5374567\",\n \"0.53733546\",\n \"0.53690875\",\n \"0.5365313\",\n \"0.5330938\",\n \"0.5328008\",\n \"0.53235453\",\n \"0.5314101\",\n \"0.5310281\",\n \"0.53058493\",\n \"0.5260593\",\n \"0.5257936\",\n \"0.52447474\",\n \"0.52358985\",\n \"0.5235221\",\n \"0.52257377\",\n \"0.52134407\",\n \"0.52072644\",\n \"0.5201305\",\n \"0.5195889\",\n \"0.51914316\",\n \"0.5183117\",\n \"0.5177773\",\n \"0.5159056\",\n \"0.5157572\",\n \"0.5149601\",\n \"0.51371723\",\n \"0.51352155\",\n \"0.51297367\",\n \"0.5126853\",\n \"0.5123741\",\n \"0.512045\",\n \"0.5120106\",\n \"0.5119972\",\n \"0.51077497\",\n \"0.5104306\",\n \"0.51039046\",\n \"0.51015264\",\n \"0.5101514\",\n \"0.51003736\",\n \"0.50890946\",\n \"0.50890744\",\n \"0.50870633\",\n \"0.50845426\",\n \"0.5082164\",\n \"0.5080612\",\n \"0.5072215\",\n \"0.5068785\",\n \"0.5060603\",\n \"0.5060603\",\n \"0.5057165\",\n \"0.5043689\",\n \"0.503746\",\n \"0.50347906\",\n \"0.50316244\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.80393004"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93184,"cells":{"query":{"kind":"string","value":"A utility function that converts an attribute tag into the corresponding attribute name string."},"document":{"kind":"string","value":"def convert_attribute_tag_to_name(value):\n if not isinstance(value, Tags):\n raise ValueError(\"The attribute tag must be a Tags enumeration.\")\n\n for entry in attribute_name_tag_table:\n if value == entry[1]:\n return entry[0]\n\n raise ValueError(\"Unrecognized attribute tag: {}\".format(value))"},"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 convert_attribute_name_to_tag(value):\n if not isinstance(value, six.string_types):\n raise ValueError(\"The attribute name must be a string.\")\n\n for entry in attribute_name_tag_table:\n if value == entry[0]:\n return entry[1]\n\n raise ValueError(\"Unrecognized attribute name: '{}'\".format(value))","def attribute_name(name: str) -> str:\n return text.snake_case(utils.safe_snake(name))","def format_attr(attr: str) -> str:\r\n prefix = query_params[Toml.REMOVE_PREFIX]\r\n suffix = query_params[Toml.REMOVE_SUFFIX]\r\n prefix_len = len(prefix)\r\n suffix_len = len(suffix)\r\n stripped = attr.strip()\r\n if stripped[:prefix_len] == prefix:\r\n stripped = stripped[prefix_len:]\r\n if stripped[-suffix_len:] == suffix:\r\n stripped = stripped[:-suffix_len]\r\n return constcase(stripped).replace('__', '_')","def _AttributeName(self, param_name, attribute_config, anchor=False):\n if attribute_config.attribute_name:\n return attribute_config.attribute_name\n if anchor:\n return 'name'\n return param_name.replace('Id', '_id').lower()","def rewrite_attribute_name(name, default_namespace='html'):\n\n # Handle any namespaces (just in case someday we support XHTML)\n if ':' in name:\n ns, name = name.split(':', 1)\n elif '__' in name:\n ns, name = name.split('__', 1)\n elif name == 'xmlns':\n ns = ''\n else:\n ns = default_namespace\n\n name.replace('__', '-')\n if ns == 'html':\n # We have an HTML attribute, fix according to DTD\n if name == 'content_type': # MIME type such as in <a> and <link> elements\n name = 'type'\n elif name == 'content_id': # moin historical convention\n name = 'id'\n elif name in ('css_class', 'css'): # to avoid python word 'class'\n name = 'class'\n elif name.startswith('on'): # event handler hook\n name = name.lower()\n return ns, name","def str_attr(attr):\n return str(attr)","def _get_custom_attribute_field_name(self, attribute):\n return 'attribute_{0}'.format(attribute.id)","def strpatt(self, name):\n return name.replace(\"att.\", \"\")","def AttributeString(self) -> str:","def AttributeString(self) -> str:","def Attribute(name, value=None):\r\n if value:\r\n return '{}=\"{}\"'.format(name, value)\r\n else:\r\n return ''","def getAttrName(self, *args):\n return _libsbml.XMLToken_getAttrName(self, *args)","def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])","def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])","def render_attr(key, value, attr_format='{key}=\"{value}\"'):\n\n if not key or ' ' in key:\n raise InvalidAttribute('Invalid name \"{}\"'.format(key))\n\n if value:\n if type(value) is RawNode:\n value = str(value)\n else:\n value = html.escape(str(value))\n\n return attr_format.format(key=key, value=value)\n\n return key","def attr(elem, attr):\n try:\n return elem[attr]\n except:\n return \"\"","def attr(elem, attr):\n try:\n return elem[attr]\n except:\n return \"\"","def get_attribute(self, attribute: str) -> str:\n pass","def string_for_attrs(attrs):\n if not attrs: return ''\n return ''.join(' %s=\"%s\"' % (attr, value) for attr, value in attrs)","def atttyp(att: str) -> str:\r\n\r\n return att[0:1]","def attr(*attrs: ATTRIBUTE) -> str:\n formatted = []\n for attr_ in attrs:\n if isinstance(attr_, str):\n formatted.append(attr_)\n elif isinstance(attr_, tuple) and len(attr_) == 2:\n formatted.append(f'{attr_[0]}=\"{attr_[1]}\"')\n else:\n raise ValueError(f\"Bad attribute: {attr_}\")\n return \" \".join(formatted)","def back_to_tag(tag, attrs):\n sol = '<' + tag\n for (prop, val) in attrs:\n sol += ' ' + prop + '=\"' + val + '\"'\n sol += '>'\n return sol","def attr(node: md.Document, name: str) -> str:\n return node.getAttribute(name)","def getAttrName(self, context):\r\n return self.attr if self.attr is not None else context.attr","def attr(*attrs: ATTRIBUTE) -> str:\n return PyHTML.attr(*attrs)","def get_activity_name(activity):\n for key in activity.attrib.keys():\n if key.endswith(\"name\"):\n return activity.attrib[key]","def renameAttr(*args, **kwargs)->AnyStr:\n pass","def attrsToString(self, attrs):\n string = \"\"\n # for every attribut\n for attr in attrs:\n # converts its name and value to string and adds this to string\n string += \" {}=\\\"{}\\\"\".format(attr[0], attr[1])\n # no exception!\n print(\"Das Attribut ist zu lang!\") if len(attr) > 2 else None\n return string","def attr_namer(name, renames=renames):\n if name in renames:\n return renames[name]\n return name","def _safe_attr(attr, camel_killer=False, replacement_char='x'):\n allowed = string.ascii_letters + string.digits + '_'\n attr = _safe_key(attr)\n if camel_killer:\n attr = _camel_killer(attr)\n attr = attr.replace(' ', '_')\n out = ''\n for character in attr:\n out += character if character in allowed else '_'\n out = out.strip('_')\n try:\n int(out[0])\n except (ValueError, IndexError):\n pass\n else:\n out = '{0}{1}'.format(replacement_char, out)\n if out in kwlist:\n out = '{0}{1}'.format(replacement_char, out)\n return re.sub('_+', '_', out)","def _mangle_attr(name):\n return 'm_' + name","def attributeName(*args, leaf: bool=True, long: bool=True, nice: bool=True, short: bool=True,\n **kwargs)->AnyStr:\n pass","def to_str(element: ET.Element) -> str:\n attribs_as_str = \" \".join(\n f\"{key}={xml.sax.saxutils.quoteattr(value)}\"\n for key, value in element.attrib.items()\n )\n if attribs_as_str:\n return f\"<{element.tag} {attribs_as_str}>\"\n else:\n return f\"<{element.tag}>\"","def _wrap_attr(attr):\n return '={0},'.format(attr)","def str(self, att):\n for (k, v) in self.__dict__.items():\n if att == v:\n return k.replace(\"_\", \" \")\n raise AttributeError","def _get_attribs_string_from_schema(header_attributes):\n attrib_values = [f\"{attr}=\\\"{value}\\\"\" for attr, value in header_attributes.items()]\n final_attrib_string = \" \".join(attrib_values)\n return final_attrib_string","def openTagAtt ( x, attName, attVal ):\n assert str(type(x)) == \"<type 'str'>\"\n assert str(type(attName)) == \"<type 'str'>\"\n assert str(type(attVal)) == \"<type 'str'>\"\n tag = \"<\" + str ( x ) + \" \" + str ( attName ) + \"='\" + str ( attVal ) +\"'>\"\n assert str ( type ( tag ) ) == \"<type 'str'>\"\n return tag","def _get_xml_tag(doc):\n tag = type(doc).type_key.split('.')[3]\n tag = convert.str_to_camel_case(tag)\n\n return tag","def attribute_key(self) -> str:\n return pulumi.get(self, \"attribute_key\")","def tagify(parsedtag):\n tag = \"\"\n for t in parsedtag:\n if t == '':\n t = '_'\n tag = tag+t\n return tag","def namehack(field):\n if field.endswith((\"attribute\", \"views\")):\n return field + \"__name\"\n else:\n return field","def AttributeName(self, param_name):\n for attribute_name, p in six.iteritems(self.attribute_to_params_map):\n if p == param_name:\n return attribute_name","def _getatt(attrs, key, ns=None, default=None):\n keytuple = (ns, unicode(key))\n if attrs.has_key(keytuple):\n result = attrs[keytuple]\n else:\n result = default\n return result","def get_element_name(ielem):\n\n return interrogate_element_name(ielem)","def _convert_attribute_to_tag(key, attr):\n if isinstance(attr, bool):\n return jaeger.Tag(key=key, vBool=attr, vType=jaeger.TagType.BOOL)\n if isinstance(attr, str):\n return jaeger.Tag(key=key, vStr=attr, vType=jaeger.TagType.STRING)\n if isinstance(attr, int):\n return jaeger.Tag(key=key, vLong=attr, vType=jaeger.TagType.LONG)\n if isinstance(attr, float):\n return jaeger.Tag(key=key, vDouble=attr, vType=jaeger.TagType.DOUBLE)\n logger.warning(\"Could not serialize attribute %s:%r to tag\", key, attr)\n return None","def node2dottedname(node: Optional[ast.AST]) -> Optional[List[str]]:\n parts = []\n while isinstance(node, ast.Attribute):\n parts.append(node.attr)\n node = node.value\n if isinstance(node, ast.Name):\n parts.append(node.id)\n else:\n return None\n parts.reverse()\n return parts","def _get_key(var_type, attr):\n if attr is None:\n return var_type\n return f'{var_type}{SEP}{attr}'","def _arg_attr(identifier, attr1, attr2):\n return attr1 if identifier.startswith('t') else attr2","def get_xml_attrib(el, key):\n for k in el.attrib.keys():\n if key == re.sub(\"^{.*}\", \"\", k):\n return el.attrib[k]","def __id_attr_name(self):\n return self._attr_name()","def attrs(*attributes):\n return ';'.join([ str(i) for i in attributes ])","def queryAttributeNames(name):\n\n header, rows = querySciDB(\"attributes(%s)\" % name)\n return [row[1].translate(None, \"\\\"\") for row in rows]","def name(self):\n return (\n self._raw_data.get(ATTR_NAME_UNICODE)\n or self._raw_data.get(ATTR_NAME)\n or \"\"\n )","def attribute_key(self) -> Optional[str]:\n return pulumi.get(self, \"attribute_key\")","def canon(raw_attr_name: str) -> str:\n if raw_attr_name: # do not dereference None, and \"\" is already canonical\n return raw_attr_name.replace(\" \", \"\").lower()\n return raw_attr_name","def format_attributes(attributes):\n return ';'.join([k + '=' + v for k, v in attributes.items()])","def _get_tag(self, tag):\n return self.prefix + tag","def closeTagAtt ( x, attName, attVal ):\n assert str(type(x)) == \"<type 'str'>\"\n assert str(type(attName)) == \"<type 'str'>\"\n assert str(type(attVal)) == \"<type 'str'>\"\n tag = \"<\" + str ( x ) + \" \" + str ( attName ) + \"='\" + str ( attVal ) +\"'/>\"\n assert str ( type ( tag ) ) == \"<type 'str'>\"\n return tag","def elm_name(elm):\n if elm is not None:\n name = \"\"\n if 'class' in elm.attrib:\n name = \"'%s' \" % elm.attrib['class']\n if 'id' in elm.attrib:\n id = elm.attrib['id'].encode('ascii','ignore').decode('ascii')\n name += \"'%s' \" % id\n if not name:\n name = \"'\" + elm.tag + \"'\"\n if lxml:\n name += \" line \" + str(elm.sourceline)\n return name\n return \"\"","def adt_object_to_element_name(adt_object):\n\n objtype = adt_object.objtype\n return f'{objtype.xmlnamespace.name}:{objtype.xmlname}'","def domAttributesToString( node ):\n strOut = \"node has %d attribute(s):\\n\" % node.attributes.length;\n for i in range(node.attributes.length):\n attr = node.attributes.item(i);\n strOut += \"- %s:'%s'\\n\" % (attr.name, attr.value );\n return strOut;","def getName(self, *args):\n return _libsbml.XMLAttributes_getName(self, *args)","def tag(\n name: str, value: str, *, attributes: dict = {}, namespace: str = None\n ) -> str:\n attributes_str = \" \".join(f'{k}=\"{v}\"' for k, v in attributes.items())\n ns = f\"{namespace}:\" if namespace else \"\"\n if attributes_str:\n attributes_str = \" \" + attributes_str\n if value:\n return f\"<{ns}{name}{attributes_str}>{value}</{ns}{name}>\"\n return f\"<{ns}{name}{attributes_str} />\"","def _get_type_string(attr_type):\n if isinstance(attr_type, (list, tuple)):\n if len(attr_type) > 1:\n return (\n \", \".join([x.__name__ for x in attr_type[:-1]])\n + \" or \"\n + attr_type[-1].__name__\n )\n return attr_type[0].__name__\n return attr_type.__name__","def construct_attribute(name: str, value: Any, tag: IppTag = None) -> bytes:\n bs = b\"\"\n\n if not tag:\n tag = ATTRIBUTE_TAG_MAP.get(name, None)\n\n if not tag:\n return bs\n\n if isinstance(value, (list, tuple, set)):\n for index, v in enumerate(value):\n bs += struct.pack(\">b\", tag.value)\n\n if index == 0:\n bs += struct.pack(\">h\", len(name))\n bs += name.encode(\"utf-8\")\n else:\n bs += struct.pack(\">h\", 0)\n\n bs += __construct_attibute_values(tag, v)\n else:\n bs = struct.pack(\">b\", tag.value)\n\n bs += struct.pack(\">h\", len(name))\n bs += name.encode(\"utf-8\")\n\n bs += __construct_attibute_values(tag, value)\n\n return bs","def getAttrPrefixedName(self, *args):\n return _libsbml.XMLToken_getAttrPrefixedName(self, *args)","def make_string(attr_dict, create=False):\n # attr_dict follows to to_uml_json_* structure\n if create:\n ops_in_value = \"name\"\n else:\n ops_in_value = \"value\"\n if isinstance(attr_dict[\"ops\"][0][ops_in_value], list):\n e_a_value = attr_dict[\"ops\"][0][ops_in_value][0]\n else:\n e_a_value = attr_dict[\"ops\"][0][ops_in_value]\n return (\n str(attr_dict[\"id\"])\n + str(e_a_value)\n + str(attr_dict[\"ops\"][0][\"path\"])\n )","def __getattr__(self, attr: str) -> str:\n\n if attr not in self.raw:\n raise AttributeError(\"unknown attribute '{}'\".format(attr))\n\n return self[attr]","def attribute_type(attr: Attr, parents: List[str]) -> str:\n\n type_names: List[str] = []\n for attr_type in attr.types:\n name = class_name(attr_type.alias) if attr_type.alias else type_name(attr_type)\n\n if attr_type.forward and attr_type.circular:\n outer_str = \".\".join(map(class_name, parents))\n name = f'\"{outer_str}\"'\n elif attr_type.forward:\n outer_str = \".\".join(map(class_name, parents))\n name = f'\"{outer_str}.{name}\"'\n elif attr_type.circular:\n name = f'\"{name}\"'\n\n if name not in type_names:\n type_names.append(name)\n\n result = \", \".join(type_names)\n if len(type_names) > 1:\n result = f\"Union[{result}]\"\n\n if attr.is_list:\n result = f\"List[{result}]\"\n elif attr.is_map:\n result = f\"Dict[{result}]\"\n elif attr.default is None and \"Dict\" not in result:\n result = f\"Optional[{result}]\"\n\n return result","def mineral_attr(attribute):\n return attribute[0]","def get_subname(get, node):\n if isinstance(node, ast.Attribute) and get(node.value) == 'parent':\n return node.attr","def visit_Attribute(self, node):\n new_node = ast.Name(\"%s.%s\" % (node.value.id, node.attr), node.ctx)\n return ast.copy_location(new_node, node)","def _mk_tag(ns, tag):\n return '{%s}%s' % (ns, tag) if ns else tag","def __h5_attr(self, attr_name, ds_name):\n if ds_name is not None:\n dset = self.fid['/PRODUCT/{}'.format(ds_name)]\n if attr_name not in dset.attrs.keys():\n return None\n\n attr = dset.attrs[attr_name]\n else:\n if attr_name not in self.fid.attrs:\n return None\n\n attr = self.fid.attrs[attr_name]\n\n if isinstance(attr, bytes):\n return attr.decode('ascii')\n\n return attr","def fix_attributes(string):\n defs = re.compile('<dl class=\"attribute\">(?P<descrip>.*?)</dl>',flags=re.DOTALL)\n name = re.compile('<code class=\"descclassname\">(?P<name>[^<]*)</code>')\n prefix = ''\n remain = string\n \n match = defs.search(remain)\n while match:\n prefix += remain[:match.start(1)]\n prefsub = ''\n remnsub = remain[match.start(1):match.end(1)]\n descrip = name.search(remnsub)\n if descrip:\n prefix += remnsub[:descrip.start()]\n prefix += remnsub[descrip.end():]\n prefix += remain[match.end(1):match.end(0)]\n else:\n prefix += remain[match.start(1):match.end(0)]\n remain = remain[match.end(0):]\n match = defs.search(remain)\n return prefix+remain","def _quoteattr(self, attr):\n attr = xml_safe(attr)\n if isinstance(attr, str) and not UNICODE_STRINGS:\n attr = attr.encode(self.encoding)\n return saxutils.quoteattr(attr)","def _xml_escape_attr(attr, skip_single_quote=True):\r\n escaped = (attr\r\n .replace('&', '&')\r\n .replace('\"', '"')\r\n .replace('<', '<')\r\n .replace('>', '>'))\r\n if not skip_single_quote:\r\n escaped = escaped.replace(\"'\", \"'\")\r\n return escaped","def _quoteattr(self, attr):\n attr = xml_safe(attr)\n if isinstance(attr, unicode) and not UNICODE_STRINGS:\n attr = attr.encode(self.encoding)\n return saxutils.quoteattr(attr)","def render_name(name_att_list):\n res = ['']\n for k, v in name_att_list:\n v = dn_escape(v)\n res.append(\"%s=%s\" % (k, v))\n res.append('')\n return '/'.join(res)","def html_attrs(attrs):\n html = \"\"\n for a in attrs.items():\n if a[1]:\n html = html + \"%s=\\\"%s\\\" \"%(a)\n return html","def type_name(attr_type: AttrType) -> str:\n return attr_type.native_name or class_name(attr_type.name)","def parse_any_attribute(cls, value: str, ns_map: Dict) -> str:\n prefix, suffix = text.split(value)\n if prefix and prefix in ns_map and not suffix.startswith(\"//\"):\n value = build_qname(ns_map[prefix], suffix)\n\n return value","def get_new_name(attrs: Dict[str, str],\n mark_name: str = '',\n name_map: Optional[Dict[str, str]] = None) -> str:\n if 'name' in attrs:\n new_name = attrs['name']\n else:\n new_name = '_'.join((attrs['func'], attrs['type'], str(attrs['id'])))\n\n if name_map is not None:\n if new_name in name_map:\n return name_map[new_name]\n\n if f'{mark_name}:{new_name}' in name_map:\n return name_map[f'{mark_name}:{new_name}']\n\n return new_name","def element_name(argument):\n\n try:\n element = atomic_symbol(argument)\n name = Elements[element][\"name\"]\n except ValueError:\n raise ValueError(\"Unable to identify element in element_name\")\n except TypeError:\n raise TypeError(\"Invalid input to element_name\")\n\n return name","def tag_name(self) -> str:\n return pulumi.get(self, \"tag_name\")","def get_attribute_from_attid(self, attid):\n if len(self.hash_oid_name.keys()) == 0:\n self._populate_oid_attid()\n if self.get_oid_from_attid(attid) in self.hash_oid_name:\n return self.hash_oid_name[self.get_oid_from_attid(attid)]\n else:\n return None","def get_name(node) -> str:\n if 'name' in node.attrib:\n return node.attrib['name']\n for elem in node:\n if elem.tag == 'name':\n return elem.text\n return ''","def map_field_name_to_attribute() -> typing.Dict:\n return {\n \"tag\": \"tag\",\n \"contact\": \"contact\",\n }","def get_tag_name(self, xml):\r\n tag = etree.fromstring(xml).tag\r\n return tag","def _tag_of(entry: _LexiconEntry) -> str:\n return entry[\"tag\"].upper()","def get_attribute(self, name):\n\n pass","def attribute(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"attribute\")","def attribute(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"attribute\")","def get_attr(attributes, name):\n try:\n return attributes.getValue(name)\n except KeyError:\n return None","def XmlElementName(self) -> str:","def XmlElementName(self) -> str:","def _camel_killer(attr):\n try:\n attr = str(attr)\n except UnicodeEncodeError:\n attr = attr.encode('utf-8', 'ignore')\n s1 = _first_cap_re.sub('\\\\1_\\\\2', attr)\n s2 = _all_cap_re.sub('\\\\1_\\\\2', s1)\n return re.sub('_+', '_', s2.casefold() if hasattr(s2, 'casefold') else s2.lower())","def name(self) -> \"str\":\n return self._attrs.get(\"name\")","def name(self) -> \"str\":\n return self._attrs.get(\"name\")","def name(self) -> \"str\":\n return self._attrs.get(\"name\")"],"string":"[\n \"def convert_attribute_name_to_tag(value):\\n if not isinstance(value, six.string_types):\\n raise ValueError(\\\"The attribute name must be a string.\\\")\\n\\n for entry in attribute_name_tag_table:\\n if value == entry[0]:\\n return entry[1]\\n\\n raise ValueError(\\\"Unrecognized attribute name: '{}'\\\".format(value))\",\n \"def attribute_name(name: str) -> str:\\n return text.snake_case(utils.safe_snake(name))\",\n \"def format_attr(attr: str) -> str:\\r\\n prefix = query_params[Toml.REMOVE_PREFIX]\\r\\n suffix = query_params[Toml.REMOVE_SUFFIX]\\r\\n prefix_len = len(prefix)\\r\\n suffix_len = len(suffix)\\r\\n stripped = attr.strip()\\r\\n if stripped[:prefix_len] == prefix:\\r\\n stripped = stripped[prefix_len:]\\r\\n if stripped[-suffix_len:] == suffix:\\r\\n stripped = stripped[:-suffix_len]\\r\\n return constcase(stripped).replace('__', '_')\",\n \"def _AttributeName(self, param_name, attribute_config, anchor=False):\\n if attribute_config.attribute_name:\\n return attribute_config.attribute_name\\n if anchor:\\n return 'name'\\n return param_name.replace('Id', '_id').lower()\",\n \"def rewrite_attribute_name(name, default_namespace='html'):\\n\\n # Handle any namespaces (just in case someday we support XHTML)\\n if ':' in name:\\n ns, name = name.split(':', 1)\\n elif '__' in name:\\n ns, name = name.split('__', 1)\\n elif name == 'xmlns':\\n ns = ''\\n else:\\n ns = default_namespace\\n\\n name.replace('__', '-')\\n if ns == 'html':\\n # We have an HTML attribute, fix according to DTD\\n if name == 'content_type': # MIME type such as in <a> and <link> elements\\n name = 'type'\\n elif name == 'content_id': # moin historical convention\\n name = 'id'\\n elif name in ('css_class', 'css'): # to avoid python word 'class'\\n name = 'class'\\n elif name.startswith('on'): # event handler hook\\n name = name.lower()\\n return ns, name\",\n \"def str_attr(attr):\\n return str(attr)\",\n \"def _get_custom_attribute_field_name(self, attribute):\\n return 'attribute_{0}'.format(attribute.id)\",\n \"def strpatt(self, name):\\n return name.replace(\\\"att.\\\", \\\"\\\")\",\n \"def AttributeString(self) -> str:\",\n \"def AttributeString(self) -> str:\",\n \"def Attribute(name, value=None):\\r\\n if value:\\r\\n return '{}=\\\"{}\\\"'.format(name, value)\\r\\n else:\\r\\n return ''\",\n \"def getAttrName(self, *args):\\n return _libsbml.XMLToken_getAttrName(self, *args)\",\n \"def flatatt(attrs):\\n return u''.join([u' %s=\\\"%s\\\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])\",\n \"def flatatt(attrs):\\n return u''.join([u' %s=\\\"%s\\\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])\",\n \"def render_attr(key, value, attr_format='{key}=\\\"{value}\\\"'):\\n\\n if not key or ' ' in key:\\n raise InvalidAttribute('Invalid name \\\"{}\\\"'.format(key))\\n\\n if value:\\n if type(value) is RawNode:\\n value = str(value)\\n else:\\n value = html.escape(str(value))\\n\\n return attr_format.format(key=key, value=value)\\n\\n return key\",\n \"def attr(elem, attr):\\n try:\\n return elem[attr]\\n except:\\n return \\\"\\\"\",\n \"def attr(elem, attr):\\n try:\\n return elem[attr]\\n except:\\n return \\\"\\\"\",\n \"def get_attribute(self, attribute: str) -> str:\\n pass\",\n \"def string_for_attrs(attrs):\\n if not attrs: return ''\\n return ''.join(' %s=\\\"%s\\\"' % (attr, value) for attr, value in attrs)\",\n \"def atttyp(att: str) -> str:\\r\\n\\r\\n return att[0:1]\",\n \"def attr(*attrs: ATTRIBUTE) -> str:\\n formatted = []\\n for attr_ in attrs:\\n if isinstance(attr_, str):\\n formatted.append(attr_)\\n elif isinstance(attr_, tuple) and len(attr_) == 2:\\n formatted.append(f'{attr_[0]}=\\\"{attr_[1]}\\\"')\\n else:\\n raise ValueError(f\\\"Bad attribute: {attr_}\\\")\\n return \\\" \\\".join(formatted)\",\n \"def back_to_tag(tag, attrs):\\n sol = '<' + tag\\n for (prop, val) in attrs:\\n sol += ' ' + prop + '=\\\"' + val + '\\\"'\\n sol += '>'\\n return sol\",\n \"def attr(node: md.Document, name: str) -> str:\\n return node.getAttribute(name)\",\n \"def getAttrName(self, context):\\r\\n return self.attr if self.attr is not None else context.attr\",\n \"def attr(*attrs: ATTRIBUTE) -> str:\\n return PyHTML.attr(*attrs)\",\n \"def get_activity_name(activity):\\n for key in activity.attrib.keys():\\n if key.endswith(\\\"name\\\"):\\n return activity.attrib[key]\",\n \"def renameAttr(*args, **kwargs)->AnyStr:\\n pass\",\n \"def attrsToString(self, attrs):\\n string = \\\"\\\"\\n # for every attribut\\n for attr in attrs:\\n # converts its name and value to string and adds this to string\\n string += \\\" {}=\\\\\\\"{}\\\\\\\"\\\".format(attr[0], attr[1])\\n # no exception!\\n print(\\\"Das Attribut ist zu lang!\\\") if len(attr) > 2 else None\\n return string\",\n \"def attr_namer(name, renames=renames):\\n if name in renames:\\n return renames[name]\\n return name\",\n \"def _safe_attr(attr, camel_killer=False, replacement_char='x'):\\n allowed = string.ascii_letters + string.digits + '_'\\n attr = _safe_key(attr)\\n if camel_killer:\\n attr = _camel_killer(attr)\\n attr = attr.replace(' ', '_')\\n out = ''\\n for character in attr:\\n out += character if character in allowed else '_'\\n out = out.strip('_')\\n try:\\n int(out[0])\\n except (ValueError, IndexError):\\n pass\\n else:\\n out = '{0}{1}'.format(replacement_char, out)\\n if out in kwlist:\\n out = '{0}{1}'.format(replacement_char, out)\\n return re.sub('_+', '_', out)\",\n \"def _mangle_attr(name):\\n return 'm_' + name\",\n \"def attributeName(*args, leaf: bool=True, long: bool=True, nice: bool=True, short: bool=True,\\n **kwargs)->AnyStr:\\n pass\",\n \"def to_str(element: ET.Element) -> str:\\n attribs_as_str = \\\" \\\".join(\\n f\\\"{key}={xml.sax.saxutils.quoteattr(value)}\\\"\\n for key, value in element.attrib.items()\\n )\\n if attribs_as_str:\\n return f\\\"<{element.tag} {attribs_as_str}>\\\"\\n else:\\n return f\\\"<{element.tag}>\\\"\",\n \"def _wrap_attr(attr):\\n return '={0},'.format(attr)\",\n \"def str(self, att):\\n for (k, v) in self.__dict__.items():\\n if att == v:\\n return k.replace(\\\"_\\\", \\\" \\\")\\n raise AttributeError\",\n \"def _get_attribs_string_from_schema(header_attributes):\\n attrib_values = [f\\\"{attr}=\\\\\\\"{value}\\\\\\\"\\\" for attr, value in header_attributes.items()]\\n final_attrib_string = \\\" \\\".join(attrib_values)\\n return final_attrib_string\",\n \"def openTagAtt ( x, attName, attVal ):\\n assert str(type(x)) == \\\"<type 'str'>\\\"\\n assert str(type(attName)) == \\\"<type 'str'>\\\"\\n assert str(type(attVal)) == \\\"<type 'str'>\\\"\\n tag = \\\"<\\\" + str ( x ) + \\\" \\\" + str ( attName ) + \\\"='\\\" + str ( attVal ) +\\\"'>\\\"\\n assert str ( type ( tag ) ) == \\\"<type 'str'>\\\"\\n return tag\",\n \"def _get_xml_tag(doc):\\n tag = type(doc).type_key.split('.')[3]\\n tag = convert.str_to_camel_case(tag)\\n\\n return tag\",\n \"def attribute_key(self) -> str:\\n return pulumi.get(self, \\\"attribute_key\\\")\",\n \"def tagify(parsedtag):\\n tag = \\\"\\\"\\n for t in parsedtag:\\n if t == '':\\n t = '_'\\n tag = tag+t\\n return tag\",\n \"def namehack(field):\\n if field.endswith((\\\"attribute\\\", \\\"views\\\")):\\n return field + \\\"__name\\\"\\n else:\\n return field\",\n \"def AttributeName(self, param_name):\\n for attribute_name, p in six.iteritems(self.attribute_to_params_map):\\n if p == param_name:\\n return attribute_name\",\n \"def _getatt(attrs, key, ns=None, default=None):\\n keytuple = (ns, unicode(key))\\n if attrs.has_key(keytuple):\\n result = attrs[keytuple]\\n else:\\n result = default\\n return result\",\n \"def get_element_name(ielem):\\n\\n return interrogate_element_name(ielem)\",\n \"def _convert_attribute_to_tag(key, attr):\\n if isinstance(attr, bool):\\n return jaeger.Tag(key=key, vBool=attr, vType=jaeger.TagType.BOOL)\\n if isinstance(attr, str):\\n return jaeger.Tag(key=key, vStr=attr, vType=jaeger.TagType.STRING)\\n if isinstance(attr, int):\\n return jaeger.Tag(key=key, vLong=attr, vType=jaeger.TagType.LONG)\\n if isinstance(attr, float):\\n return jaeger.Tag(key=key, vDouble=attr, vType=jaeger.TagType.DOUBLE)\\n logger.warning(\\\"Could not serialize attribute %s:%r to tag\\\", key, attr)\\n return None\",\n \"def node2dottedname(node: Optional[ast.AST]) -> Optional[List[str]]:\\n parts = []\\n while isinstance(node, ast.Attribute):\\n parts.append(node.attr)\\n node = node.value\\n if isinstance(node, ast.Name):\\n parts.append(node.id)\\n else:\\n return None\\n parts.reverse()\\n return parts\",\n \"def _get_key(var_type, attr):\\n if attr is None:\\n return var_type\\n return f'{var_type}{SEP}{attr}'\",\n \"def _arg_attr(identifier, attr1, attr2):\\n return attr1 if identifier.startswith('t') else attr2\",\n \"def get_xml_attrib(el, key):\\n for k in el.attrib.keys():\\n if key == re.sub(\\\"^{.*}\\\", \\\"\\\", k):\\n return el.attrib[k]\",\n \"def __id_attr_name(self):\\n return self._attr_name()\",\n \"def attrs(*attributes):\\n return ';'.join([ str(i) for i in attributes ])\",\n \"def queryAttributeNames(name):\\n\\n header, rows = querySciDB(\\\"attributes(%s)\\\" % name)\\n return [row[1].translate(None, \\\"\\\\\\\"\\\") for row in rows]\",\n \"def name(self):\\n return (\\n self._raw_data.get(ATTR_NAME_UNICODE)\\n or self._raw_data.get(ATTR_NAME)\\n or \\\"\\\"\\n )\",\n \"def attribute_key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"attribute_key\\\")\",\n \"def canon(raw_attr_name: str) -> str:\\n if raw_attr_name: # do not dereference None, and \\\"\\\" is already canonical\\n return raw_attr_name.replace(\\\" \\\", \\\"\\\").lower()\\n return raw_attr_name\",\n \"def format_attributes(attributes):\\n return ';'.join([k + '=' + v for k, v in attributes.items()])\",\n \"def _get_tag(self, tag):\\n return self.prefix + tag\",\n \"def closeTagAtt ( x, attName, attVal ):\\n assert str(type(x)) == \\\"<type 'str'>\\\"\\n assert str(type(attName)) == \\\"<type 'str'>\\\"\\n assert str(type(attVal)) == \\\"<type 'str'>\\\"\\n tag = \\\"<\\\" + str ( x ) + \\\" \\\" + str ( attName ) + \\\"='\\\" + str ( attVal ) +\\\"'/>\\\"\\n assert str ( type ( tag ) ) == \\\"<type 'str'>\\\"\\n return tag\",\n \"def elm_name(elm):\\n if elm is not None:\\n name = \\\"\\\"\\n if 'class' in elm.attrib:\\n name = \\\"'%s' \\\" % elm.attrib['class']\\n if 'id' in elm.attrib:\\n id = elm.attrib['id'].encode('ascii','ignore').decode('ascii')\\n name += \\\"'%s' \\\" % id\\n if not name:\\n name = \\\"'\\\" + elm.tag + \\\"'\\\"\\n if lxml:\\n name += \\\" line \\\" + str(elm.sourceline)\\n return name\\n return \\\"\\\"\",\n \"def adt_object_to_element_name(adt_object):\\n\\n objtype = adt_object.objtype\\n return f'{objtype.xmlnamespace.name}:{objtype.xmlname}'\",\n \"def domAttributesToString( node ):\\n strOut = \\\"node has %d attribute(s):\\\\n\\\" % node.attributes.length;\\n for i in range(node.attributes.length):\\n attr = node.attributes.item(i);\\n strOut += \\\"- %s:'%s'\\\\n\\\" % (attr.name, attr.value );\\n return strOut;\",\n \"def getName(self, *args):\\n return _libsbml.XMLAttributes_getName(self, *args)\",\n \"def tag(\\n name: str, value: str, *, attributes: dict = {}, namespace: str = None\\n ) -> str:\\n attributes_str = \\\" \\\".join(f'{k}=\\\"{v}\\\"' for k, v in attributes.items())\\n ns = f\\\"{namespace}:\\\" if namespace else \\\"\\\"\\n if attributes_str:\\n attributes_str = \\\" \\\" + attributes_str\\n if value:\\n return f\\\"<{ns}{name}{attributes_str}>{value}</{ns}{name}>\\\"\\n return f\\\"<{ns}{name}{attributes_str} />\\\"\",\n \"def _get_type_string(attr_type):\\n if isinstance(attr_type, (list, tuple)):\\n if len(attr_type) > 1:\\n return (\\n \\\", \\\".join([x.__name__ for x in attr_type[:-1]])\\n + \\\" or \\\"\\n + attr_type[-1].__name__\\n )\\n return attr_type[0].__name__\\n return attr_type.__name__\",\n \"def construct_attribute(name: str, value: Any, tag: IppTag = None) -> bytes:\\n bs = b\\\"\\\"\\n\\n if not tag:\\n tag = ATTRIBUTE_TAG_MAP.get(name, None)\\n\\n if not tag:\\n return bs\\n\\n if isinstance(value, (list, tuple, set)):\\n for index, v in enumerate(value):\\n bs += struct.pack(\\\">b\\\", tag.value)\\n\\n if index == 0:\\n bs += struct.pack(\\\">h\\\", len(name))\\n bs += name.encode(\\\"utf-8\\\")\\n else:\\n bs += struct.pack(\\\">h\\\", 0)\\n\\n bs += __construct_attibute_values(tag, v)\\n else:\\n bs = struct.pack(\\\">b\\\", tag.value)\\n\\n bs += struct.pack(\\\">h\\\", len(name))\\n bs += name.encode(\\\"utf-8\\\")\\n\\n bs += __construct_attibute_values(tag, value)\\n\\n return bs\",\n \"def getAttrPrefixedName(self, *args):\\n return _libsbml.XMLToken_getAttrPrefixedName(self, *args)\",\n \"def make_string(attr_dict, create=False):\\n # attr_dict follows to to_uml_json_* structure\\n if create:\\n ops_in_value = \\\"name\\\"\\n else:\\n ops_in_value = \\\"value\\\"\\n if isinstance(attr_dict[\\\"ops\\\"][0][ops_in_value], list):\\n e_a_value = attr_dict[\\\"ops\\\"][0][ops_in_value][0]\\n else:\\n e_a_value = attr_dict[\\\"ops\\\"][0][ops_in_value]\\n return (\\n str(attr_dict[\\\"id\\\"])\\n + str(e_a_value)\\n + str(attr_dict[\\\"ops\\\"][0][\\\"path\\\"])\\n )\",\n \"def __getattr__(self, attr: str) -> str:\\n\\n if attr not in self.raw:\\n raise AttributeError(\\\"unknown attribute '{}'\\\".format(attr))\\n\\n return self[attr]\",\n \"def attribute_type(attr: Attr, parents: List[str]) -> str:\\n\\n type_names: List[str] = []\\n for attr_type in attr.types:\\n name = class_name(attr_type.alias) if attr_type.alias else type_name(attr_type)\\n\\n if attr_type.forward and attr_type.circular:\\n outer_str = \\\".\\\".join(map(class_name, parents))\\n name = f'\\\"{outer_str}\\\"'\\n elif attr_type.forward:\\n outer_str = \\\".\\\".join(map(class_name, parents))\\n name = f'\\\"{outer_str}.{name}\\\"'\\n elif attr_type.circular:\\n name = f'\\\"{name}\\\"'\\n\\n if name not in type_names:\\n type_names.append(name)\\n\\n result = \\\", \\\".join(type_names)\\n if len(type_names) > 1:\\n result = f\\\"Union[{result}]\\\"\\n\\n if attr.is_list:\\n result = f\\\"List[{result}]\\\"\\n elif attr.is_map:\\n result = f\\\"Dict[{result}]\\\"\\n elif attr.default is None and \\\"Dict\\\" not in result:\\n result = f\\\"Optional[{result}]\\\"\\n\\n return result\",\n \"def mineral_attr(attribute):\\n return attribute[0]\",\n \"def get_subname(get, node):\\n if isinstance(node, ast.Attribute) and get(node.value) == 'parent':\\n return node.attr\",\n \"def visit_Attribute(self, node):\\n new_node = ast.Name(\\\"%s.%s\\\" % (node.value.id, node.attr), node.ctx)\\n return ast.copy_location(new_node, node)\",\n \"def _mk_tag(ns, tag):\\n return '{%s}%s' % (ns, tag) if ns else tag\",\n \"def __h5_attr(self, attr_name, ds_name):\\n if ds_name is not None:\\n dset = self.fid['/PRODUCT/{}'.format(ds_name)]\\n if attr_name not in dset.attrs.keys():\\n return None\\n\\n attr = dset.attrs[attr_name]\\n else:\\n if attr_name not in self.fid.attrs:\\n return None\\n\\n attr = self.fid.attrs[attr_name]\\n\\n if isinstance(attr, bytes):\\n return attr.decode('ascii')\\n\\n return attr\",\n \"def fix_attributes(string):\\n defs = re.compile('<dl class=\\\"attribute\\\">(?P<descrip>.*?)</dl>',flags=re.DOTALL)\\n name = re.compile('<code class=\\\"descclassname\\\">(?P<name>[^<]*)</code>')\\n prefix = ''\\n remain = string\\n \\n match = defs.search(remain)\\n while match:\\n prefix += remain[:match.start(1)]\\n prefsub = ''\\n remnsub = remain[match.start(1):match.end(1)]\\n descrip = name.search(remnsub)\\n if descrip:\\n prefix += remnsub[:descrip.start()]\\n prefix += remnsub[descrip.end():]\\n prefix += remain[match.end(1):match.end(0)]\\n else:\\n prefix += remain[match.start(1):match.end(0)]\\n remain = remain[match.end(0):]\\n match = defs.search(remain)\\n return prefix+remain\",\n \"def _quoteattr(self, attr):\\n attr = xml_safe(attr)\\n if isinstance(attr, str) and not UNICODE_STRINGS:\\n attr = attr.encode(self.encoding)\\n return saxutils.quoteattr(attr)\",\n \"def _xml_escape_attr(attr, skip_single_quote=True):\\r\\n escaped = (attr\\r\\n .replace('&', '&')\\r\\n .replace('\\\"', '"')\\r\\n .replace('<', '<')\\r\\n .replace('>', '>'))\\r\\n if not skip_single_quote:\\r\\n escaped = escaped.replace(\\\"'\\\", \\\"'\\\")\\r\\n return escaped\",\n \"def _quoteattr(self, attr):\\n attr = xml_safe(attr)\\n if isinstance(attr, unicode) and not UNICODE_STRINGS:\\n attr = attr.encode(self.encoding)\\n return saxutils.quoteattr(attr)\",\n \"def render_name(name_att_list):\\n res = ['']\\n for k, v in name_att_list:\\n v = dn_escape(v)\\n res.append(\\\"%s=%s\\\" % (k, v))\\n res.append('')\\n return '/'.join(res)\",\n \"def html_attrs(attrs):\\n html = \\\"\\\"\\n for a in attrs.items():\\n if a[1]:\\n html = html + \\\"%s=\\\\\\\"%s\\\\\\\" \\\"%(a)\\n return html\",\n \"def type_name(attr_type: AttrType) -> str:\\n return attr_type.native_name or class_name(attr_type.name)\",\n \"def parse_any_attribute(cls, value: str, ns_map: Dict) -> str:\\n prefix, suffix = text.split(value)\\n if prefix and prefix in ns_map and not suffix.startswith(\\\"//\\\"):\\n value = build_qname(ns_map[prefix], suffix)\\n\\n return value\",\n \"def get_new_name(attrs: Dict[str, str],\\n mark_name: str = '',\\n name_map: Optional[Dict[str, str]] = None) -> str:\\n if 'name' in attrs:\\n new_name = attrs['name']\\n else:\\n new_name = '_'.join((attrs['func'], attrs['type'], str(attrs['id'])))\\n\\n if name_map is not None:\\n if new_name in name_map:\\n return name_map[new_name]\\n\\n if f'{mark_name}:{new_name}' in name_map:\\n return name_map[f'{mark_name}:{new_name}']\\n\\n return new_name\",\n \"def element_name(argument):\\n\\n try:\\n element = atomic_symbol(argument)\\n name = Elements[element][\\\"name\\\"]\\n except ValueError:\\n raise ValueError(\\\"Unable to identify element in element_name\\\")\\n except TypeError:\\n raise TypeError(\\\"Invalid input to element_name\\\")\\n\\n return name\",\n \"def tag_name(self) -> str:\\n return pulumi.get(self, \\\"tag_name\\\")\",\n \"def get_attribute_from_attid(self, attid):\\n if len(self.hash_oid_name.keys()) == 0:\\n self._populate_oid_attid()\\n if self.get_oid_from_attid(attid) in self.hash_oid_name:\\n return self.hash_oid_name[self.get_oid_from_attid(attid)]\\n else:\\n return None\",\n \"def get_name(node) -> str:\\n if 'name' in node.attrib:\\n return node.attrib['name']\\n for elem in node:\\n if elem.tag == 'name':\\n return elem.text\\n return ''\",\n \"def map_field_name_to_attribute() -> typing.Dict:\\n return {\\n \\\"tag\\\": \\\"tag\\\",\\n \\\"contact\\\": \\\"contact\\\",\\n }\",\n \"def get_tag_name(self, xml):\\r\\n tag = etree.fromstring(xml).tag\\r\\n return tag\",\n \"def _tag_of(entry: _LexiconEntry) -> str:\\n return entry[\\\"tag\\\"].upper()\",\n \"def get_attribute(self, name):\\n\\n pass\",\n \"def attribute(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"attribute\\\")\",\n \"def attribute(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"attribute\\\")\",\n \"def get_attr(attributes, name):\\n try:\\n return attributes.getValue(name)\\n except KeyError:\\n return None\",\n \"def XmlElementName(self) -> str:\",\n \"def XmlElementName(self) -> str:\",\n \"def _camel_killer(attr):\\n try:\\n attr = str(attr)\\n except UnicodeEncodeError:\\n attr = attr.encode('utf-8', 'ignore')\\n s1 = _first_cap_re.sub('\\\\\\\\1_\\\\\\\\2', attr)\\n s2 = _all_cap_re.sub('\\\\\\\\1_\\\\\\\\2', s1)\\n return re.sub('_+', '_', s2.casefold() if hasattr(s2, 'casefold') else s2.lower())\",\n \"def name(self) -> \\\"str\\\":\\n return self._attrs.get(\\\"name\\\")\",\n \"def name(self) -> \\\"str\\\":\\n return self._attrs.get(\\\"name\\\")\",\n \"def name(self) -> \\\"str\\\":\\n return self._attrs.get(\\\"name\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73351747","0.72900105","0.7044817","0.700109","0.6944922","0.6706183","0.66464186","0.6546524","0.6434635","0.6434635","0.6406859","0.63961947","0.63639677","0.63639677","0.6242204","0.6229339","0.6229339","0.62258285","0.6216158","0.62033","0.62025344","0.6152033","0.6076607","0.60394514","0.5972973","0.59496903","0.5905312","0.58897656","0.58884054","0.58842283","0.5843054","0.58305806","0.57955045","0.57820106","0.5781658","0.57709265","0.5743164","0.57297367","0.57069665","0.57051814","0.57037246","0.56661826","0.56391734","0.5620145","0.56105834","0.559985","0.5592847","0.5583064","0.558087","0.5556501","0.5533601","0.55118316","0.5509994","0.55075675","0.5501263","0.5496243","0.54927576","0.5477811","0.547633","0.54683924","0.54566276","0.5456024","0.5445087","0.5424865","0.5419213","0.54147196","0.54113626","0.5403867","0.5383702","0.53826016","0.53767","0.5373042","0.5366585","0.53587896","0.53538775","0.53487134","0.5347508","0.5341468","0.5341009","0.53320897","0.53252923","0.53217244","0.5321057","0.53034115","0.5300769","0.5291157","0.5280294","0.5274691","0.52669847","0.526321","0.5239684","0.5216053","0.5216053","0.52097857","0.52076024","0.52076024","0.520601","0.52053463","0.52053463","0.52053463"],"string":"[\n \"0.73351747\",\n \"0.72900105\",\n \"0.7044817\",\n \"0.700109\",\n \"0.6944922\",\n \"0.6706183\",\n \"0.66464186\",\n \"0.6546524\",\n \"0.6434635\",\n \"0.6434635\",\n \"0.6406859\",\n \"0.63961947\",\n \"0.63639677\",\n \"0.63639677\",\n \"0.6242204\",\n \"0.6229339\",\n \"0.6229339\",\n \"0.62258285\",\n \"0.6216158\",\n \"0.62033\",\n \"0.62025344\",\n \"0.6152033\",\n \"0.6076607\",\n \"0.60394514\",\n \"0.5972973\",\n \"0.59496903\",\n \"0.5905312\",\n \"0.58897656\",\n \"0.58884054\",\n \"0.58842283\",\n \"0.5843054\",\n \"0.58305806\",\n \"0.57955045\",\n \"0.57820106\",\n \"0.5781658\",\n \"0.57709265\",\n \"0.5743164\",\n \"0.57297367\",\n \"0.57069665\",\n \"0.57051814\",\n \"0.57037246\",\n \"0.56661826\",\n \"0.56391734\",\n \"0.5620145\",\n \"0.56105834\",\n \"0.559985\",\n \"0.5592847\",\n \"0.5583064\",\n \"0.558087\",\n \"0.5556501\",\n \"0.5533601\",\n \"0.55118316\",\n \"0.5509994\",\n \"0.55075675\",\n \"0.5501263\",\n \"0.5496243\",\n \"0.54927576\",\n \"0.5477811\",\n \"0.547633\",\n \"0.54683924\",\n \"0.54566276\",\n \"0.5456024\",\n \"0.5445087\",\n \"0.5424865\",\n \"0.5419213\",\n \"0.54147196\",\n \"0.54113626\",\n \"0.5403867\",\n \"0.5383702\",\n \"0.53826016\",\n \"0.53767\",\n \"0.5373042\",\n \"0.5366585\",\n \"0.53587896\",\n \"0.53538775\",\n \"0.53487134\",\n \"0.5347508\",\n \"0.5341468\",\n \"0.5341009\",\n \"0.53320897\",\n \"0.53252923\",\n \"0.53217244\",\n \"0.5321057\",\n \"0.53034115\",\n \"0.5300769\",\n \"0.5291157\",\n \"0.5280294\",\n \"0.5274691\",\n \"0.52669847\",\n \"0.526321\",\n \"0.5239684\",\n \"0.5216053\",\n \"0.5216053\",\n \"0.52097857\",\n \"0.52076024\",\n \"0.52076024\",\n \"0.520601\",\n \"0.52053463\",\n \"0.52053463\",\n \"0.52053463\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7753604"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93185,"cells":{"query":{"kind":"string","value":"A utility function that computes a bit mask from a collection of enumeration values."},"document":{"kind":"string","value":"def get_bit_mask_from_enumerations(enumerations):\n return functools.reduce(\n lambda x, y: x | y, [z.value for z in enumerations]\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_enumerations_from_bit_mask(enumeration, mask):\n return [x for x in enumeration if (x.value & mask) == x.value]","def parse_mask(value, mask_enum):\n masks = []\n for mask in mask_enum:\n if value & mask:\n masks.append(mask.name)\n value ^= mask\n if value:\n masks.append(hex(value))\n\n return masks","def bitmask(*args: Union[int, Sequence[int], Tuple[int, int]]) -> int:\n mask = 0\n\n for a in args:\n if isinstance(a, tuple):\n hi, lo = a\n mask |= ((1 << (hi - lo + 1)) - 1) << lo\n elif isinstance(a, (list, set)):\n mask |= reduce(operator.or_, ((1 << b) for b in a))\n elif isinstance(a, int):\n mask |= 1 << a\n\n return mask","def create_basic_flag_mask(*flags):\n\n out = np.ones(len(flags[0]), bool)\n for flag in flags:\n out &= (~flag)\n\n return out","def encode_flags(names):\n return reduce(operator.ior, (flag_masks[name] for name in names), 0)","def _generateResults_combosToBitmasks(self, all, want_combos):\n names = {}\n iter = enumerate(all)\n try:\n i, name = next(iter)\n while True:\n names[name] = (1 << i)\n i, name = next(iter)\n except StopIteration:\n pass\n print \"combosToBitmasks names:\", names\n results = []\n for combo in want_combos:\n mask = 0\n for name in combo:\n if name in names:\n mask |= names[name]\n results.append(mask)\n return results","def is_bit_mask(enumeration, potential_mask):\n if not isinstance(potential_mask, six.integer_types):\n return False\n\n mask_enumerations = (\n CryptographicUsageMask,\n ProtectionStorageMask,\n StorageStatusMask\n )\n if enumeration not in mask_enumerations:\n return False\n\n mask = 0\n for value in [e.value for e in enumeration]:\n if (value & potential_mask) == value:\n mask |= value\n\n if mask != potential_mask:\n return False\n\n return True","def flags(self):\n flags = self.Flags\n return [x for x in self.FLAGS_VALUES if flags & x]","def bits(byte: int) -> Sequence[bool]:\n assert byte < 0x100\n return [bool(byte & mask) for mask in bit_masks]","def from_value(cls, value):\n value = value if value else 0\n try:\n flags = [flag.name for flag in cls.enum_class if flag.value & value]\n except TypeError:\n flags = [flag.name for flag in cls.enum_class if flag.name == value]\n\n return cls(*flags)","def bits():\n for d in data:\n for i in [5, 4, 3, 2, 1, 0]:\n yield (d >> i) & 1","def get_flags(self):\n\n if self.raw.flags not in [0, 1, 2, 3]:\n raise ValueError(\"Invalid raw flags: {}\".format(self.raw.flags))\n\n flags = set()\n\n if (self.raw.flags & 0b010) > 0:\n flags.add(\"DF\")\n\n if (self.raw.flags & 0b001) > 0:\n flags.add(\"MF\")\n\n return frozenset(flags)","def _all_labels_to_bitmasks(all_labels):\n l_dict = {}\n for i, label in enumerate(all_labels):\n l_dict[label.name] = 1<<i\n return l_dict","def mask(self):\n return list(self._mask_generator())","def get_taxa_bitmask(self, **kwargs):\n if \"taxa\" in kwargs:\n taxa = kwargs[\"taxa\"]\n else:\n taxa = self.get_taxa(**kwargs)\n bitmask = 0\n for taxon in taxa:\n bitmask |= self.taxon_bitmask(taxon)\n return bitmask","def expand_mask(kind, value):\n result = []\n if value != 0:\n mask_values = zip(spirv.spv[kind].values(), spirv.spv[kind].keys())\n mask_values = sorted(mask_values, key=itemgetter(0))\n for mask_number, mask_token in mask_values:\n if (mask_number & value) != 0:\n result.append(mask_token)\n value = value ^ mask_number\n if value != 0:\n raise ParseError('Invalid mask value')\n return result","def test_build_mask(dq, bitvalues, expected):\n result = build_mask(dq, bitvalues)\n assert np.array_equal(result, expected)","def interpretMasks(masks,shape=None):\n if isinstance(masks,np.ndarray): return masks.astype(bool)\n # make iterable\n if not isinstance( masks, (list,tuple,np.ndarray) ): masks = (masks,)\n masks = [interpretMask(mask,shape) for mask in masks]\n # put them all together\n mask = masks[0]\n for m in masks[1:]:\n mask = np.logical_or(mask,m)\n return mask","def process_result_value(self, value, dialect):\n masks = list()\n if value:\n for e in enums.CryptographicUsageMask:\n if e.value & value:\n masks.append(e)\n return masks","def vertex_group_ids_to_bitmask(vertex):\n list = [x.group for x in vertex.groups]\n masked = 0\n for group in list:\n masked |= 1 << group\n return masked","def _flag_list_OR(self, wearable: Wearable, list_of_flags: list):\n\n result = wearable.data[self.invalid_col].apply(lambda x: list_of_flags[0] in InvCode.check_flag(x))\n for flag in list_of_flags[1:]:\n result |= wearable.data[self.invalid_col].apply(lambda x: flag in InvCode.check_flag(x))\n return result","def mask(self) -> list[int]:\n return self._mask","def getmask(\n self, mask: Union[List[dd.Series], UserList], inverse: bool = False\n ) -> List[dd.Series]:\n output = []\n for data, cond in zip(self.data, mask):\n if inverse:\n output.append(data[~cond])\n else:\n output.append(data[cond])\n\n return output","def pixinlist(img, valList):\n mask = numpy.zeros(img.shape, dtype=bool)\n for val in valList:\n mask[img==val] = True\n return mask","def smask(value, fields, width):\n try:\n value = reduce(__or__, [1 << i for i in value], 0)\n except TypeError:\n pass \n try:\n fields = reduce(__or__, [1 << i for i in fields], 0)\n except TypeError:\n pass\n assert width > 0 \n value &= (1 << width) - 1\n result = sum(value << (width * i)\n for i in range(INT_BITS//width) if (fields >> i) & 1)\n return result & ((1 << INT_BITS) - 1)","def all_bits_list(vals, width=16):\n return flatten_list([to_bit_list(val, width) for val in vals])","def set_flags(data):\n flag_status_bit = {\n \"flagfield_rf1\": np.array([1, 1, 2, 1, 2, 0, 0, 0]),\n \"flagfield_rf2\": np.array([2, 2, 0, 0, 0, 0, 0, 0]),\n \"flagfield_pl\": np.array([2, 2, 2, 2, 0, 0, 0, 0]),\n \"flagfield_gen1\": np.array([0, 2, 0, 0, 0, 0, 0, 0]),\n \"flagfield_gen2\": np.array([1, 0, 2, 0, 0, 0, 0, 0])\n }\n\n f_usable = np.zeros(data[\"flagfield_rf1\"].size, dtype=np.uint8)\n\n for flagfield, bitmask in flag_status_bit.items():\n subset = np.nonzero(data[flagfield])[0]\n\n if subset.size > 0:\n unpacked_bits = np.fliplr(\n np.unpackbits(data[flagfield][subset]).reshape(-1,\n 8).astype(bool))\n\n flag = np.ma.array(np.tile(bitmask,\n unpacked_bits.shape[0]).reshape(-1, 8),\n mask=~unpacked_bits,\n fill_value=0)\n\n f_usable[subset] = np.max(np.vstack(\n (f_usable[subset], flag.filled().max(axis=1))),\n axis=0)\n\n return f_usable","def _split_bits(i: int) -> typing.Tuple[bool, bool, bool, bool, bool, bool, bool, bool]:\n\t\n\tassert i in range(256)\n\treturn (\n\t\tbool(i & (1 << 7)),\n\t\tbool(i & (1 << 6)),\n\t\tbool(i & (1 << 5)),\n\t\tbool(i & (1 << 4)),\n\t\tbool(i & (1 << 3)),\n\t\tbool(i & (1 << 2)),\n\t\tbool(i & (1 << 1)),\n\t\tbool(i & (1 << 0)),\n\t)","def build_mask(dqarr, bitvalue):\n bitvalue = interpret_bit_flags(bitvalue, mnemonic_map=pixel)\n\n if bitvalue is None:\n return (np.ones(dqarr.shape, dtype=np.uint8))\n return np.logical_not(np.bitwise_and(dqarr, ~bitvalue)).astype(np.uint8)","def to_bit_list(val, width=16):\n return [(1 if val & (1<<n) else 0) for n in range(width)]","def bitfield(x, m):\n b = [1 if digit=='1' else 0 for digit in bin(x)[2:]]\n for i in range(len(b), m):\n b.insert(0, 0)\n return b","def encode_aurafilter(flags: List[str]) -> int:\n aurafilter = 0\n for name in flags:\n try:\n aurafilter |= AURAFILTER_FLAGS[name]\n except KeyError:\n raise ValueError(f\"Unknown AuraFilter flag name: {name!r}\") from None\n return aurafilter","def return_value_mask(actions):\n if hasattr(actions,'shape'):\n M = actions.shape[0]\n else:\n M = 1\n value_mask = torch.zeros(M,5)\n value_mask[torch.arange(M),actions] = 1\n value_mask = value_mask.bool()\n return value_mask.squeeze(0)","def bitlist(n):\n return [n >> i & 1 for i in range(7,-1,-1)]","def set_bitmask(self, value):\r\n self.__bitmask__ = value | 0xFF00","def set24_to_list(v):\n return [x for x in range(24) if v & (1 << x)]","def _encode_check_unknown(values, uniques, return_mask=False):\n uniques_set = set(uniques)\n diff = list(set(values) - uniques_set)\n if return_mask:\n if diff:\n valid_mask = [val in uniques_set for val in values]\n else:\n valid_mask = [True] * len(values)\n return diff, valid_mask\n else:\n return diff","def test_quality_mask():\n quality = np.array([0, 0, 1])\n assert np.all(KeplerQualityFlags.create_quality_mask(quality, bitmask=0))\n assert np.all(KeplerQualityFlags.create_quality_mask(quality, bitmask=None))\n assert np.all(KeplerQualityFlags.create_quality_mask(quality, bitmask='none'))\n assert (KeplerQualityFlags.create_quality_mask(quality, bitmask=1)).sum() == 2\n assert (KeplerQualityFlags.create_quality_mask(quality, bitmask='hardest')).sum() == 2\n # Do we see a ValueError if an invalid bitmask is passed?\n with pytest.raises(ValueError) as err:\n KeplerQualityFlags.create_quality_mask(quality, bitmask='invalidoption')\n assert \"not supported\" in err.value.args[0]","def get_bitmask(self):\r\n return self.__bitmask__","def convertToEnumItemSet(boolean: bool) -> cern.japc.value.EnumItemSet:\n ...","def gen_all_holds(hand):\n\n mask = sorted(gen_all_sequences((1,0), len(hand)))\n answer_set = []\n for current_mask in mask:\n temp = []\n for indx in range(len(current_mask)):\n if current_mask[indx] == 1:\n temp.append(hand[indx]);\n answer_set.append(tuple(temp))\n return set(answer_set)","def flagSet():\r\n for flag in flags:\r\n if flags[flag]:\r\n return True\r\n return False","def _generate_bitmask(n: int = 2, n_bits: int = 8) -> int:\n all_ones = 2 ** n_bits - 1\n cancel_bits = 2 ** n - 1\n return all_ones - cancel_bits","def list_to_set24(l):\n res = 0\n for x in l: res ^= 1 << x\n return res & 0xffffff","def bits(a,m):\r\n if isinstance(a, int):\r\n res = [None]*m\r\n for i in range(m):\r\n res[i] = a & 1\r\n a >>= 1\r\n else:\r\n res = []\r\n from Compiler.types import regint, cint\r\n while m > 0:\r\n aa = regint()\r\n convmodp(aa, a, bitlength=0)\r\n res += [cint(x) for x in aa.bit_decompose(min(64, m))]\r\n m -= 64\r\n if m > 0:\r\n aa = cint()\r\n shrci(aa, a, 64)\r\n a = aa\r\n return res","def _make_masks(ilens, olens):\n # (B, T_in)\n in_masks = make_non_pad_mask(ilens)\n # (B, T_out)\n out_masks = make_non_pad_mask(olens)\n # (B, T_out, T_in)\n\n return paddle.logical_and(\n out_masks.unsqueeze(-1), in_masks.unsqueeze(-2))","def get_mask(total, begin, end):\n mask = np.zeros([total]).astype(np.float32)\n mask[begin:end] = 1\n return np.array(mask, dtype=np.bool)","def ifc_subsets(me, ifc):\n return me._ifc_subs.get(ifc, frozenset())","def get_all_flags(options):\n flags = []\n if options.inputFlag:\n flags.append(try_to_int(options.inputFlag))\n if options.outputFlags:\n for flag in options.outputFlags:\n flags.append(try_to_int(flag))\n return flags","def __gen_bit_values(number):\n number = int(number)\n while number:\n yield number & 0x1\n number >>= 1","def check_mask(f):\n def wrapper(*args, **kwargs):\n data = args[0]\n try:\n mask = data.mask\n except AttributeError:\n data = np.ma.array(data, mask=np.zeros(data.shape, dtype=np.bool))\n mask = data.mask\n args = list(args)\n args[0] = data\n args = tuple(args)\n return f(*args, **kwargs)\n return wrapper","def mask(self):\n return type(self)(self.data.mask, self.bset)","def _fixed_masks_arg(mask):\n return [\"NULL\", mask]","def list_set_flags(self, include=frozenset(), exclude=frozenset()):\n for (name, desc) in self.list_flags():\n if name in exclude:\n continue\n if (name in include) or (desc.value is not desc.default):\n yield (name, desc)","def int_to_set(i):\n\ts = set()\n\tj = 1\n\twhile i != 0:\n\t\tif i & 1:\n\t\t\ts.add(j)\n\t\ti >>= 1\n\t\tj += 1\n\treturn s","def mask_codes_op(base_array, codes_array):\r\n result = numpy.empty(base_array.shape, dtype=numpy.int8)\r\n result[:] = mask_nodata\r\n valid_mask = base_array != base_nodata\r\n result[valid_mask] = numpy.isin(\r\n base_array[valid_mask], codes_array)\r\n return result","def input_mask(self):\n inputs = self.input\n if isinstance(inputs, list):\n return [getattr(x, '_keras_mask', None) for x in inputs]\n else:\n return getattr(inputs, '_keras_mask', None)","def box_flags(self, box):\n return [flag for flag in self.flags if flag.box == box]","def apply_masks(masks):\n masks = ee.List(masks) if isinstance(masks, list) else masks\n first = ee.Image.constant(0)\n\n def compute(mask, first):\n first = ee.Image(first)\n return first.Or(mask)\n\n bad_pixels = ee.Image(masks.iterate(compute, first))\n good_pixels = bad_pixels.Not()\n\n return good_pixels","def mask(self, *options: str):\n return reduce(lambda a, b: a | getattr(self, b), options, 0)","def convertMaskToWeights(mask):\n vals = np.unique(mask)\n for i in range(len(vals)):\n mask[mask==vals[i]]=i\n mask = mask.astype(int)\n w = mask.ravel() \n return w","def apply_mask(data, mask):\n if len(mask) != 4:\n raise ValueError(\"mask must contain 4 bytes\")\n\n return bytes(b ^ m for b, m in zip(data, itertools.cycle(mask)))","def allowed_mods():\n mods = [Mod.EZ, Mod.HD, Mod.HR, Mod.DT, Mod.HT, Mod.FL]\n mod_powerset = chain.from_iterable(combinations(mods, r) for r in range(len(mods) + 1))\n combos = []\n for p in mod_powerset:\n combined_mod = Mod(0)\n for m in p:\n combined_mod |= m\n combos.append(combined_mod)\n allowed = tuple(c for c in combos if valid_mod(c))\n return allowed","def GetActuatorsWithStatus(status_flags, status_helper, status_to_check):\n\n flag = 0\n for status in status_to_check:\n flag |= status_helper.Value(status)\n return [key for key, value in status_flags.iteritems() if value & flag]","def listFlag(flaglist):\n flag = 0\n for index, item in enumerate(flaglist):\n flag = setFlag(flag, index, item)\n return flag","def EvaluateFlags(flags: int) -> Dict[str, bool]:\n results = {}\n sumFlags = 0\n for flagName, flagMaskVal in RSEGeometryFlags.FLAG_MASKS.items():\n sumFlags += flagMaskVal\n if flagMaskVal & flags > 0:\n results[flagName] = True\n else:\n results[flagName] = False\n\n if flags > sumFlags:\n results[\"UnevaluatedFlags\"] = True\n else:\n results[\"UnevaluatedFlags\"] = False\n\n return results","def one_mask(self):\n accum = 0\n for i in range(self.data.itemsize):\n accum += (0xAA << (i << 3))\n return accum","def shiftr_bitmask(self):\r\n self.__bitmask__ = self.__bitmask__ >> 1","def _describe_bitmask(\n bits: int, table: Mapping[int, str], default: str = \"0\"\n) -> str:\n result = []\n for bit, name in table.items():\n if bit & bits:\n result.append(name)\n if not result:\n return default\n return \"|\".join(result)","def core_mask(self):\n mask = []\n for atom in self.atoms:\n if \"shell\" not in atom.atom_type.label:\n mask.append(True)\n else:\n mask.append(False)\n return mask","def rfi_flag(data, freqs=None):\n \n masks = Masks()\n\n # Record any nans\n masks.add(\"nan_mask\", np.isnan(data))\n\n if params.do_sum_threshold:\n try:\n to_flag\n except NameError:\n bpass = estimate_bandpass(data)\n to_flag = data / bpass\n \n to_flag.mask = sum_threshold(to_flag)\n to_flag.mask = flag_fraction(to_flag)\n to_flag.mask = flag_window(to_flag)\n\n masks.add(\"sum_threshold_mask\", to_flag.mask)\n \n if params.do_sigma_clip:\n try:\n to_flag\n except NameError:\n bpass = estimate_bandpass(data)\n to_flag = data / bpass\n \n to_flag.mask = clip2(to_flag)\n to_flag.mask = flag_fraction(to_flag)\n to_flag.mask = flag_window(to_flag)\n\n masks.add(\"clip_mask\", to_flag.mask)\n \n if params.do_dtv_flagging and freqs is not None:\n try:\n to_flag\n except NameError:\n bpass = estimate_bandpass(data)\n to_flag = data / bpass\n \n to_flag.mask, dtv_times = do_dtv_flagging2(to_flag, freqs) \n\n masks.add(\"dtv_mask\", to_flag.mask)\n\n dtv_times_mask = np.zeros_like(data, dtype=np.bool)\n dtv_times_mask[dtv_times] = True\t\n\tmasks.add(\"dtv_times_mask\", dtv_times_mask)\n masks.dtv_tms = dtv_times\n \n\n return masks","def _mask_to_cores(mask):\n cores = set()\n i = 0\n while mask:\n if mask % 2:\n cores.add(i)\n mask >>= 1\n i += 1\n return cores","def _regex_flags_from_bits(self, bits):\n flags = 'tilmsux'\n return ''.join(flags[i] if (1 << i) & bits else '' for i in xrange(6))","def bitmask(n: int) -> int:\n if n >= 0:\n return (1 << n) - 1\n else:\n return -1 << -n","def boolmask(indices, shape=None):\n indices = np.asanyarray(indices)\n if indices.dtype.kind not in {'i', 'u'}:\n indices = indices.astype(int)\n if shape is None:\n shape = indices.max() + 1\n mask = np.zeros(shape, dtype=bool)\n if mask.ndim > 1:\n mask[tuple(indices.T)] = True\n else:\n mask[indices] = True\n return mask","def any_values(*values):\n values = [_normalize(v) for v in values]\n for v in zip(*values):\n yield any(v)","def __init__(self, eset, flags=None):\n\n # Store the EnumSet\n self.eset = eset\n\n # Initialize the flags\n self.bitflags = 0\n self.flags = set()\n\n # Routine to call if we're modified\n self._notify = None\n\n # Process the flags that were set\n if isinstance(flags, six.integer_types):\n for opt in eset:\n if flags & int(opt):\n self.bitflags |= int(opt)\n self.flags.add(str(opt))\n\n # Make sure we got them all\n if self.bitflags != flags:\n raise TypeError(\n 'Unable to find enumeration values for 0x%x' %\n (flags & ~self.bitflags)\n )\n elif isinstance(flags, six.string_types):\n try:\n opt = eset[flags]\n except KeyError:\n raise TypeError(\n 'Unable to find enumeration value for flag \\\"%s\\\"' % flags\n )\n\n self.bitflags |= int(opt)\n self.flags.add(str(opt))\n elif flags is not None:\n for flag in flags:\n try:\n opt = eset[flag]\n except KeyError:\n raise TypeError(\n 'Unable to find enumeration value for flag \\\"%s\\\"' %\n flag\n )\n\n self.bitflags |= int(opt)\n self.flags.add(str(opt))","def __iter__(self):\n\n for opt in self.eset:\n if self.bitflags & int(opt):\n yield opt","def testBits(self):\n\n fullPlaneNameList = list(MaskPlaneNameIDDict.keys())\n totNumBits = countBits(MaxBitMask)\n for i in range(len(fullPlaneNameList)):\n numPlanes = i + 1\n setPlaneNameList = fullPlaneNameList[0:numPlanes]\n\n bitMask = coaddUtils.makeBitMask(setPlaneNameList)\n self.assertEqual(countBits(bitMask), numPlanes)\n for planeName, planeId in MaskPlaneNameIDDict.items():\n self.assertEqual((bitMask & (1 << planeId)) > 0, planeName in setPlaneNameList)\n\n invBitMask = coaddUtils.makeBitMask(setPlaneNameList, doInvert=True)\n self.assertEqual(countBits(invBitMask), totNumBits - numPlanes)\n for planeName, planeId in MaskPlaneNameIDDict.items():\n self.assertEqual((invBitMask & (1 << planeId)) > 0, planeName not in setPlaneNameList)","def convertToEnumItemSetArray(boolean: bool) -> typing.List[cern.japc.value.EnumItemSet]:\n ...","def apply_mask(binary, mask_dict):\n result = \"\"\n for i, val in enumerate(binary):\n if mask_dict[i] in ('X', '1'):\n result += mask_dict[i]\n else:\n result += binary[i]\n return result","def fn(mask):\n for i in range(len(piles)): \n val = (mask >> 3*i) & 7\n for k in range(1, val+1): \n mask0 = mask - (k << 3*i)\n if not fn(mask0): return True \n return False","def isect_flags(arr, other):\n flags = iter_reduce_ufunc(np.logical_or, (arr == item for item in other))\n if flags is None:\n flags = np.zeros(arr.shape, dtype=bool)\n return flags","def select_mask(cls, dataset, selection):\n mask = np.ones(len(dataset), dtype=np.bool_)\n for dim, sel in selection.items():\n if isinstance(sel, tuple):\n sel = slice(*sel)\n arr = cls.values(dataset, dim)\n if util.isdatetime(arr):\n try:\n sel = util.parse_datetime_selection(sel)\n except Exception:\n pass\n if isinstance(sel, slice):\n with warnings.catch_warnings():\n warnings.filterwarnings('ignore', r'invalid value encountered')\n if sel.start is not None:\n mask &= sel.start <= arr\n if sel.stop is not None:\n mask &= arr < sel.stop\n elif isinstance(sel, (set, list)):\n iter_slcs = []\n for ik in sel:\n with warnings.catch_warnings():\n warnings.filterwarnings('ignore', r'invalid value encountered')\n iter_slcs.append(arr == ik)\n mask &= np.logical_or.reduce(iter_slcs)\n elif callable(sel):\n mask &= sel(arr)\n else:\n index_mask = arr == sel\n if dataset.ndims == 1 and np.sum(index_mask) == 0:\n data_index = np.argmin(np.abs(arr - sel))\n mask = np.zeros(len(dataset), dtype=np.bool_)\n mask[data_index] = True\n else:\n mask &= index_mask\n return mask","def decode_flags(flags):\n if isinstance(flags, six.string_types):\n flags = int(flags.lstrip('@'), 16)\n return [name for i, name in enumerate(flag_names) if (1 << i) & flags]","def build_attention_mask(input_ids): \n attention_masks = [] \n\n # 1 for input and 0 for pad\n for seq in input_ids: \n attention_masks.append([float(i>0) for i in seq])\n\n return attention_masks","def _describe_bitmask(bits: int, table: Mapping[int, str], default: str = \"0\") -> str:\n result = []\n for bit, name in table.items():\n if bit & bits:\n result.append(name)\n if not result:\n return default\n return \"|\".join(result)","def _and(it):\n return 1 if it[0]==1 and it[1]==1 else 0","def get_all_const(*ops):\n return all(map(get_const, ops))","def get_bit(num, i):\n return num & (1 << i) != 0","def get_repetition_flags(self):\n day_flags = 0\n for i, box in enumerate((self._timer_mo_check_button,\n self._timer_tu_check_button,\n self._timer_we_check_button,\n self._timer_th_check_button,\n self._timer_fr_check_button,\n self._timer_sa_check_button,\n self._timer_su_check_button)):\n\n if box.get_active():\n day_flags = day_flags | (1 << i)\n\n return day_flags","def get_boolean_array_from(number: int) -> List[bool]:\n return_value = [False] * MAX_BIT_LENGTH\n last_bit_position = len(bin(number)) - 1\n for i in range(0, last_bit_position):\n return_value[i] = (number & (1 << i)) != 0\n return return_value","def bit_toggler(gen_on, gen_off):\n for n_on, n_off in zip(gen_on, gen_off):\n yield int(abs(n_on)), int(abs(n_off))","def build_list_from_masks(cls, masks: Iterable[\"datacube_ows.styles.base.StyleMask\"],\n layer: \"datacube_ows.ows_configuration.OWSNamedLayer\") -> List[\"FlagProductBands\"]:\n flag_products = []\n for mask in masks:\n handled = False\n for fp in flag_products:\n if fp.products_match(mask.band.pq_names):\n fp.add_flag_band(mask.band)\n handled = True\n break\n if not handled:\n flag_products.append(cls(mask.band, layer))\n return flag_products","def TransformFlags(self) -> _n_2_t_0[bool]:","def _mask_list(self, items):\n\n result_type = type(items)\n results = []\n for item in items:\n results.append(self._mask(item))\n\n return result_type(results)","def In(sigOrVal, iterable):\n res = None\n for i in iterable:\n i = toHVal(i)\n if res is None:\n res = sigOrVal._eq(i)\n else:\n res = res | sigOrVal._eq(i)\n\n return res","def select_body_parts(mask, list_of_body_parts):\n\n new_mask = np.zeros(mask.shape).astype(np.bool)\n\n for body_part in list_of_body_parts:\n idxs = body_parts[body_part]\n\n for idx in idxs:\n m_ = (mask == idx)\n new_mask = np.bitwise_or(new_mask, m_)\n\n return new_mask.astype(np.uint8)","def set(self, *options: str) -> int:\n self.flags |= self.mask(*options)\n return self.flags","def mask(n, start, end):\n columns = []\n value = 1\n for i in range(n):\n if start <= end:\n columns.append(value if (start <= i < end) else 0)\n else:\n columns.append(value if (start <= i or i < end) else 0)\n value <<= 1\n return BitColumnMatrix(columns)"],"string":"[\n \"def get_enumerations_from_bit_mask(enumeration, mask):\\n return [x for x in enumeration if (x.value & mask) == x.value]\",\n \"def parse_mask(value, mask_enum):\\n masks = []\\n for mask in mask_enum:\\n if value & mask:\\n masks.append(mask.name)\\n value ^= mask\\n if value:\\n masks.append(hex(value))\\n\\n return masks\",\n \"def bitmask(*args: Union[int, Sequence[int], Tuple[int, int]]) -> int:\\n mask = 0\\n\\n for a in args:\\n if isinstance(a, tuple):\\n hi, lo = a\\n mask |= ((1 << (hi - lo + 1)) - 1) << lo\\n elif isinstance(a, (list, set)):\\n mask |= reduce(operator.or_, ((1 << b) for b in a))\\n elif isinstance(a, int):\\n mask |= 1 << a\\n\\n return mask\",\n \"def create_basic_flag_mask(*flags):\\n\\n out = np.ones(len(flags[0]), bool)\\n for flag in flags:\\n out &= (~flag)\\n\\n return out\",\n \"def encode_flags(names):\\n return reduce(operator.ior, (flag_masks[name] for name in names), 0)\",\n \"def _generateResults_combosToBitmasks(self, all, want_combos):\\n names = {}\\n iter = enumerate(all)\\n try:\\n i, name = next(iter)\\n while True:\\n names[name] = (1 << i)\\n i, name = next(iter)\\n except StopIteration:\\n pass\\n print \\\"combosToBitmasks names:\\\", names\\n results = []\\n for combo in want_combos:\\n mask = 0\\n for name in combo:\\n if name in names:\\n mask |= names[name]\\n results.append(mask)\\n return results\",\n \"def is_bit_mask(enumeration, potential_mask):\\n if not isinstance(potential_mask, six.integer_types):\\n return False\\n\\n mask_enumerations = (\\n CryptographicUsageMask,\\n ProtectionStorageMask,\\n StorageStatusMask\\n )\\n if enumeration not in mask_enumerations:\\n return False\\n\\n mask = 0\\n for value in [e.value for e in enumeration]:\\n if (value & potential_mask) == value:\\n mask |= value\\n\\n if mask != potential_mask:\\n return False\\n\\n return True\",\n \"def flags(self):\\n flags = self.Flags\\n return [x for x in self.FLAGS_VALUES if flags & x]\",\n \"def bits(byte: int) -> Sequence[bool]:\\n assert byte < 0x100\\n return [bool(byte & mask) for mask in bit_masks]\",\n \"def from_value(cls, value):\\n value = value if value else 0\\n try:\\n flags = [flag.name for flag in cls.enum_class if flag.value & value]\\n except TypeError:\\n flags = [flag.name for flag in cls.enum_class if flag.name == value]\\n\\n return cls(*flags)\",\n \"def bits():\\n for d in data:\\n for i in [5, 4, 3, 2, 1, 0]:\\n yield (d >> i) & 1\",\n \"def get_flags(self):\\n\\n if self.raw.flags not in [0, 1, 2, 3]:\\n raise ValueError(\\\"Invalid raw flags: {}\\\".format(self.raw.flags))\\n\\n flags = set()\\n\\n if (self.raw.flags & 0b010) > 0:\\n flags.add(\\\"DF\\\")\\n\\n if (self.raw.flags & 0b001) > 0:\\n flags.add(\\\"MF\\\")\\n\\n return frozenset(flags)\",\n \"def _all_labels_to_bitmasks(all_labels):\\n l_dict = {}\\n for i, label in enumerate(all_labels):\\n l_dict[label.name] = 1<<i\\n return l_dict\",\n \"def mask(self):\\n return list(self._mask_generator())\",\n \"def get_taxa_bitmask(self, **kwargs):\\n if \\\"taxa\\\" in kwargs:\\n taxa = kwargs[\\\"taxa\\\"]\\n else:\\n taxa = self.get_taxa(**kwargs)\\n bitmask = 0\\n for taxon in taxa:\\n bitmask |= self.taxon_bitmask(taxon)\\n return bitmask\",\n \"def expand_mask(kind, value):\\n result = []\\n if value != 0:\\n mask_values = zip(spirv.spv[kind].values(), spirv.spv[kind].keys())\\n mask_values = sorted(mask_values, key=itemgetter(0))\\n for mask_number, mask_token in mask_values:\\n if (mask_number & value) != 0:\\n result.append(mask_token)\\n value = value ^ mask_number\\n if value != 0:\\n raise ParseError('Invalid mask value')\\n return result\",\n \"def test_build_mask(dq, bitvalues, expected):\\n result = build_mask(dq, bitvalues)\\n assert np.array_equal(result, expected)\",\n \"def interpretMasks(masks,shape=None):\\n if isinstance(masks,np.ndarray): return masks.astype(bool)\\n # make iterable\\n if not isinstance( masks, (list,tuple,np.ndarray) ): masks = (masks,)\\n masks = [interpretMask(mask,shape) for mask in masks]\\n # put them all together\\n mask = masks[0]\\n for m in masks[1:]:\\n mask = np.logical_or(mask,m)\\n return mask\",\n \"def process_result_value(self, value, dialect):\\n masks = list()\\n if value:\\n for e in enums.CryptographicUsageMask:\\n if e.value & value:\\n masks.append(e)\\n return masks\",\n \"def vertex_group_ids_to_bitmask(vertex):\\n list = [x.group for x in vertex.groups]\\n masked = 0\\n for group in list:\\n masked |= 1 << group\\n return masked\",\n \"def _flag_list_OR(self, wearable: Wearable, list_of_flags: list):\\n\\n result = wearable.data[self.invalid_col].apply(lambda x: list_of_flags[0] in InvCode.check_flag(x))\\n for flag in list_of_flags[1:]:\\n result |= wearable.data[self.invalid_col].apply(lambda x: flag in InvCode.check_flag(x))\\n return result\",\n \"def mask(self) -> list[int]:\\n return self._mask\",\n \"def getmask(\\n self, mask: Union[List[dd.Series], UserList], inverse: bool = False\\n ) -> List[dd.Series]:\\n output = []\\n for data, cond in zip(self.data, mask):\\n if inverse:\\n output.append(data[~cond])\\n else:\\n output.append(data[cond])\\n\\n return output\",\n \"def pixinlist(img, valList):\\n mask = numpy.zeros(img.shape, dtype=bool)\\n for val in valList:\\n mask[img==val] = True\\n return mask\",\n \"def smask(value, fields, width):\\n try:\\n value = reduce(__or__, [1 << i for i in value], 0)\\n except TypeError:\\n pass \\n try:\\n fields = reduce(__or__, [1 << i for i in fields], 0)\\n except TypeError:\\n pass\\n assert width > 0 \\n value &= (1 << width) - 1\\n result = sum(value << (width * i)\\n for i in range(INT_BITS//width) if (fields >> i) & 1)\\n return result & ((1 << INT_BITS) - 1)\",\n \"def all_bits_list(vals, width=16):\\n return flatten_list([to_bit_list(val, width) for val in vals])\",\n \"def set_flags(data):\\n flag_status_bit = {\\n \\\"flagfield_rf1\\\": np.array([1, 1, 2, 1, 2, 0, 0, 0]),\\n \\\"flagfield_rf2\\\": np.array([2, 2, 0, 0, 0, 0, 0, 0]),\\n \\\"flagfield_pl\\\": np.array([2, 2, 2, 2, 0, 0, 0, 0]),\\n \\\"flagfield_gen1\\\": np.array([0, 2, 0, 0, 0, 0, 0, 0]),\\n \\\"flagfield_gen2\\\": np.array([1, 0, 2, 0, 0, 0, 0, 0])\\n }\\n\\n f_usable = np.zeros(data[\\\"flagfield_rf1\\\"].size, dtype=np.uint8)\\n\\n for flagfield, bitmask in flag_status_bit.items():\\n subset = np.nonzero(data[flagfield])[0]\\n\\n if subset.size > 0:\\n unpacked_bits = np.fliplr(\\n np.unpackbits(data[flagfield][subset]).reshape(-1,\\n 8).astype(bool))\\n\\n flag = np.ma.array(np.tile(bitmask,\\n unpacked_bits.shape[0]).reshape(-1, 8),\\n mask=~unpacked_bits,\\n fill_value=0)\\n\\n f_usable[subset] = np.max(np.vstack(\\n (f_usable[subset], flag.filled().max(axis=1))),\\n axis=0)\\n\\n return f_usable\",\n \"def _split_bits(i: int) -> typing.Tuple[bool, bool, bool, bool, bool, bool, bool, bool]:\\n\\t\\n\\tassert i in range(256)\\n\\treturn (\\n\\t\\tbool(i & (1 << 7)),\\n\\t\\tbool(i & (1 << 6)),\\n\\t\\tbool(i & (1 << 5)),\\n\\t\\tbool(i & (1 << 4)),\\n\\t\\tbool(i & (1 << 3)),\\n\\t\\tbool(i & (1 << 2)),\\n\\t\\tbool(i & (1 << 1)),\\n\\t\\tbool(i & (1 << 0)),\\n\\t)\",\n \"def build_mask(dqarr, bitvalue):\\n bitvalue = interpret_bit_flags(bitvalue, mnemonic_map=pixel)\\n\\n if bitvalue is None:\\n return (np.ones(dqarr.shape, dtype=np.uint8))\\n return np.logical_not(np.bitwise_and(dqarr, ~bitvalue)).astype(np.uint8)\",\n \"def to_bit_list(val, width=16):\\n return [(1 if val & (1<<n) else 0) for n in range(width)]\",\n \"def bitfield(x, m):\\n b = [1 if digit=='1' else 0 for digit in bin(x)[2:]]\\n for i in range(len(b), m):\\n b.insert(0, 0)\\n return b\",\n \"def encode_aurafilter(flags: List[str]) -> int:\\n aurafilter = 0\\n for name in flags:\\n try:\\n aurafilter |= AURAFILTER_FLAGS[name]\\n except KeyError:\\n raise ValueError(f\\\"Unknown AuraFilter flag name: {name!r}\\\") from None\\n return aurafilter\",\n \"def return_value_mask(actions):\\n if hasattr(actions,'shape'):\\n M = actions.shape[0]\\n else:\\n M = 1\\n value_mask = torch.zeros(M,5)\\n value_mask[torch.arange(M),actions] = 1\\n value_mask = value_mask.bool()\\n return value_mask.squeeze(0)\",\n \"def bitlist(n):\\n return [n >> i & 1 for i in range(7,-1,-1)]\",\n \"def set_bitmask(self, value):\\r\\n self.__bitmask__ = value | 0xFF00\",\n \"def set24_to_list(v):\\n return [x for x in range(24) if v & (1 << x)]\",\n \"def _encode_check_unknown(values, uniques, return_mask=False):\\n uniques_set = set(uniques)\\n diff = list(set(values) - uniques_set)\\n if return_mask:\\n if diff:\\n valid_mask = [val in uniques_set for val in values]\\n else:\\n valid_mask = [True] * len(values)\\n return diff, valid_mask\\n else:\\n return diff\",\n \"def test_quality_mask():\\n quality = np.array([0, 0, 1])\\n assert np.all(KeplerQualityFlags.create_quality_mask(quality, bitmask=0))\\n assert np.all(KeplerQualityFlags.create_quality_mask(quality, bitmask=None))\\n assert np.all(KeplerQualityFlags.create_quality_mask(quality, bitmask='none'))\\n assert (KeplerQualityFlags.create_quality_mask(quality, bitmask=1)).sum() == 2\\n assert (KeplerQualityFlags.create_quality_mask(quality, bitmask='hardest')).sum() == 2\\n # Do we see a ValueError if an invalid bitmask is passed?\\n with pytest.raises(ValueError) as err:\\n KeplerQualityFlags.create_quality_mask(quality, bitmask='invalidoption')\\n assert \\\"not supported\\\" in err.value.args[0]\",\n \"def get_bitmask(self):\\r\\n return self.__bitmask__\",\n \"def convertToEnumItemSet(boolean: bool) -> cern.japc.value.EnumItemSet:\\n ...\",\n \"def gen_all_holds(hand):\\n\\n mask = sorted(gen_all_sequences((1,0), len(hand)))\\n answer_set = []\\n for current_mask in mask:\\n temp = []\\n for indx in range(len(current_mask)):\\n if current_mask[indx] == 1:\\n temp.append(hand[indx]);\\n answer_set.append(tuple(temp))\\n return set(answer_set)\",\n \"def flagSet():\\r\\n for flag in flags:\\r\\n if flags[flag]:\\r\\n return True\\r\\n return False\",\n \"def _generate_bitmask(n: int = 2, n_bits: int = 8) -> int:\\n all_ones = 2 ** n_bits - 1\\n cancel_bits = 2 ** n - 1\\n return all_ones - cancel_bits\",\n \"def list_to_set24(l):\\n res = 0\\n for x in l: res ^= 1 << x\\n return res & 0xffffff\",\n \"def bits(a,m):\\r\\n if isinstance(a, int):\\r\\n res = [None]*m\\r\\n for i in range(m):\\r\\n res[i] = a & 1\\r\\n a >>= 1\\r\\n else:\\r\\n res = []\\r\\n from Compiler.types import regint, cint\\r\\n while m > 0:\\r\\n aa = regint()\\r\\n convmodp(aa, a, bitlength=0)\\r\\n res += [cint(x) for x in aa.bit_decompose(min(64, m))]\\r\\n m -= 64\\r\\n if m > 0:\\r\\n aa = cint()\\r\\n shrci(aa, a, 64)\\r\\n a = aa\\r\\n return res\",\n \"def _make_masks(ilens, olens):\\n # (B, T_in)\\n in_masks = make_non_pad_mask(ilens)\\n # (B, T_out)\\n out_masks = make_non_pad_mask(olens)\\n # (B, T_out, T_in)\\n\\n return paddle.logical_and(\\n out_masks.unsqueeze(-1), in_masks.unsqueeze(-2))\",\n \"def get_mask(total, begin, end):\\n mask = np.zeros([total]).astype(np.float32)\\n mask[begin:end] = 1\\n return np.array(mask, dtype=np.bool)\",\n \"def ifc_subsets(me, ifc):\\n return me._ifc_subs.get(ifc, frozenset())\",\n \"def get_all_flags(options):\\n flags = []\\n if options.inputFlag:\\n flags.append(try_to_int(options.inputFlag))\\n if options.outputFlags:\\n for flag in options.outputFlags:\\n flags.append(try_to_int(flag))\\n return flags\",\n \"def __gen_bit_values(number):\\n number = int(number)\\n while number:\\n yield number & 0x1\\n number >>= 1\",\n \"def check_mask(f):\\n def wrapper(*args, **kwargs):\\n data = args[0]\\n try:\\n mask = data.mask\\n except AttributeError:\\n data = np.ma.array(data, mask=np.zeros(data.shape, dtype=np.bool))\\n mask = data.mask\\n args = list(args)\\n args[0] = data\\n args = tuple(args)\\n return f(*args, **kwargs)\\n return wrapper\",\n \"def mask(self):\\n return type(self)(self.data.mask, self.bset)\",\n \"def _fixed_masks_arg(mask):\\n return [\\\"NULL\\\", mask]\",\n \"def list_set_flags(self, include=frozenset(), exclude=frozenset()):\\n for (name, desc) in self.list_flags():\\n if name in exclude:\\n continue\\n if (name in include) or (desc.value is not desc.default):\\n yield (name, desc)\",\n \"def int_to_set(i):\\n\\ts = set()\\n\\tj = 1\\n\\twhile i != 0:\\n\\t\\tif i & 1:\\n\\t\\t\\ts.add(j)\\n\\t\\ti >>= 1\\n\\t\\tj += 1\\n\\treturn s\",\n \"def mask_codes_op(base_array, codes_array):\\r\\n result = numpy.empty(base_array.shape, dtype=numpy.int8)\\r\\n result[:] = mask_nodata\\r\\n valid_mask = base_array != base_nodata\\r\\n result[valid_mask] = numpy.isin(\\r\\n base_array[valid_mask], codes_array)\\r\\n return result\",\n \"def input_mask(self):\\n inputs = self.input\\n if isinstance(inputs, list):\\n return [getattr(x, '_keras_mask', None) for x in inputs]\\n else:\\n return getattr(inputs, '_keras_mask', None)\",\n \"def box_flags(self, box):\\n return [flag for flag in self.flags if flag.box == box]\",\n \"def apply_masks(masks):\\n masks = ee.List(masks) if isinstance(masks, list) else masks\\n first = ee.Image.constant(0)\\n\\n def compute(mask, first):\\n first = ee.Image(first)\\n return first.Or(mask)\\n\\n bad_pixels = ee.Image(masks.iterate(compute, first))\\n good_pixels = bad_pixels.Not()\\n\\n return good_pixels\",\n \"def mask(self, *options: str):\\n return reduce(lambda a, b: a | getattr(self, b), options, 0)\",\n \"def convertMaskToWeights(mask):\\n vals = np.unique(mask)\\n for i in range(len(vals)):\\n mask[mask==vals[i]]=i\\n mask = mask.astype(int)\\n w = mask.ravel() \\n return w\",\n \"def apply_mask(data, mask):\\n if len(mask) != 4:\\n raise ValueError(\\\"mask must contain 4 bytes\\\")\\n\\n return bytes(b ^ m for b, m in zip(data, itertools.cycle(mask)))\",\n \"def allowed_mods():\\n mods = [Mod.EZ, Mod.HD, Mod.HR, Mod.DT, Mod.HT, Mod.FL]\\n mod_powerset = chain.from_iterable(combinations(mods, r) for r in range(len(mods) + 1))\\n combos = []\\n for p in mod_powerset:\\n combined_mod = Mod(0)\\n for m in p:\\n combined_mod |= m\\n combos.append(combined_mod)\\n allowed = tuple(c for c in combos if valid_mod(c))\\n return allowed\",\n \"def GetActuatorsWithStatus(status_flags, status_helper, status_to_check):\\n\\n flag = 0\\n for status in status_to_check:\\n flag |= status_helper.Value(status)\\n return [key for key, value in status_flags.iteritems() if value & flag]\",\n \"def listFlag(flaglist):\\n flag = 0\\n for index, item in enumerate(flaglist):\\n flag = setFlag(flag, index, item)\\n return flag\",\n \"def EvaluateFlags(flags: int) -> Dict[str, bool]:\\n results = {}\\n sumFlags = 0\\n for flagName, flagMaskVal in RSEGeometryFlags.FLAG_MASKS.items():\\n sumFlags += flagMaskVal\\n if flagMaskVal & flags > 0:\\n results[flagName] = True\\n else:\\n results[flagName] = False\\n\\n if flags > sumFlags:\\n results[\\\"UnevaluatedFlags\\\"] = True\\n else:\\n results[\\\"UnevaluatedFlags\\\"] = False\\n\\n return results\",\n \"def one_mask(self):\\n accum = 0\\n for i in range(self.data.itemsize):\\n accum += (0xAA << (i << 3))\\n return accum\",\n \"def shiftr_bitmask(self):\\r\\n self.__bitmask__ = self.__bitmask__ >> 1\",\n \"def _describe_bitmask(\\n bits: int, table: Mapping[int, str], default: str = \\\"0\\\"\\n) -> str:\\n result = []\\n for bit, name in table.items():\\n if bit & bits:\\n result.append(name)\\n if not result:\\n return default\\n return \\\"|\\\".join(result)\",\n \"def core_mask(self):\\n mask = []\\n for atom in self.atoms:\\n if \\\"shell\\\" not in atom.atom_type.label:\\n mask.append(True)\\n else:\\n mask.append(False)\\n return mask\",\n \"def rfi_flag(data, freqs=None):\\n \\n masks = Masks()\\n\\n # Record any nans\\n masks.add(\\\"nan_mask\\\", np.isnan(data))\\n\\n if params.do_sum_threshold:\\n try:\\n to_flag\\n except NameError:\\n bpass = estimate_bandpass(data)\\n to_flag = data / bpass\\n \\n to_flag.mask = sum_threshold(to_flag)\\n to_flag.mask = flag_fraction(to_flag)\\n to_flag.mask = flag_window(to_flag)\\n\\n masks.add(\\\"sum_threshold_mask\\\", to_flag.mask)\\n \\n if params.do_sigma_clip:\\n try:\\n to_flag\\n except NameError:\\n bpass = estimate_bandpass(data)\\n to_flag = data / bpass\\n \\n to_flag.mask = clip2(to_flag)\\n to_flag.mask = flag_fraction(to_flag)\\n to_flag.mask = flag_window(to_flag)\\n\\n masks.add(\\\"clip_mask\\\", to_flag.mask)\\n \\n if params.do_dtv_flagging and freqs is not None:\\n try:\\n to_flag\\n except NameError:\\n bpass = estimate_bandpass(data)\\n to_flag = data / bpass\\n \\n to_flag.mask, dtv_times = do_dtv_flagging2(to_flag, freqs) \\n\\n masks.add(\\\"dtv_mask\\\", to_flag.mask)\\n\\n dtv_times_mask = np.zeros_like(data, dtype=np.bool)\\n dtv_times_mask[dtv_times] = True\\t\\n\\tmasks.add(\\\"dtv_times_mask\\\", dtv_times_mask)\\n masks.dtv_tms = dtv_times\\n \\n\\n return masks\",\n \"def _mask_to_cores(mask):\\n cores = set()\\n i = 0\\n while mask:\\n if mask % 2:\\n cores.add(i)\\n mask >>= 1\\n i += 1\\n return cores\",\n \"def _regex_flags_from_bits(self, bits):\\n flags = 'tilmsux'\\n return ''.join(flags[i] if (1 << i) & bits else '' for i in xrange(6))\",\n \"def bitmask(n: int) -> int:\\n if n >= 0:\\n return (1 << n) - 1\\n else:\\n return -1 << -n\",\n \"def boolmask(indices, shape=None):\\n indices = np.asanyarray(indices)\\n if indices.dtype.kind not in {'i', 'u'}:\\n indices = indices.astype(int)\\n if shape is None:\\n shape = indices.max() + 1\\n mask = np.zeros(shape, dtype=bool)\\n if mask.ndim > 1:\\n mask[tuple(indices.T)] = True\\n else:\\n mask[indices] = True\\n return mask\",\n \"def any_values(*values):\\n values = [_normalize(v) for v in values]\\n for v in zip(*values):\\n yield any(v)\",\n \"def __init__(self, eset, flags=None):\\n\\n # Store the EnumSet\\n self.eset = eset\\n\\n # Initialize the flags\\n self.bitflags = 0\\n self.flags = set()\\n\\n # Routine to call if we're modified\\n self._notify = None\\n\\n # Process the flags that were set\\n if isinstance(flags, six.integer_types):\\n for opt in eset:\\n if flags & int(opt):\\n self.bitflags |= int(opt)\\n self.flags.add(str(opt))\\n\\n # Make sure we got them all\\n if self.bitflags != flags:\\n raise TypeError(\\n 'Unable to find enumeration values for 0x%x' %\\n (flags & ~self.bitflags)\\n )\\n elif isinstance(flags, six.string_types):\\n try:\\n opt = eset[flags]\\n except KeyError:\\n raise TypeError(\\n 'Unable to find enumeration value for flag \\\\\\\"%s\\\\\\\"' % flags\\n )\\n\\n self.bitflags |= int(opt)\\n self.flags.add(str(opt))\\n elif flags is not None:\\n for flag in flags:\\n try:\\n opt = eset[flag]\\n except KeyError:\\n raise TypeError(\\n 'Unable to find enumeration value for flag \\\\\\\"%s\\\\\\\"' %\\n flag\\n )\\n\\n self.bitflags |= int(opt)\\n self.flags.add(str(opt))\",\n \"def __iter__(self):\\n\\n for opt in self.eset:\\n if self.bitflags & int(opt):\\n yield opt\",\n \"def testBits(self):\\n\\n fullPlaneNameList = list(MaskPlaneNameIDDict.keys())\\n totNumBits = countBits(MaxBitMask)\\n for i in range(len(fullPlaneNameList)):\\n numPlanes = i + 1\\n setPlaneNameList = fullPlaneNameList[0:numPlanes]\\n\\n bitMask = coaddUtils.makeBitMask(setPlaneNameList)\\n self.assertEqual(countBits(bitMask), numPlanes)\\n for planeName, planeId in MaskPlaneNameIDDict.items():\\n self.assertEqual((bitMask & (1 << planeId)) > 0, planeName in setPlaneNameList)\\n\\n invBitMask = coaddUtils.makeBitMask(setPlaneNameList, doInvert=True)\\n self.assertEqual(countBits(invBitMask), totNumBits - numPlanes)\\n for planeName, planeId in MaskPlaneNameIDDict.items():\\n self.assertEqual((invBitMask & (1 << planeId)) > 0, planeName not in setPlaneNameList)\",\n \"def convertToEnumItemSetArray(boolean: bool) -> typing.List[cern.japc.value.EnumItemSet]:\\n ...\",\n \"def apply_mask(binary, mask_dict):\\n result = \\\"\\\"\\n for i, val in enumerate(binary):\\n if mask_dict[i] in ('X', '1'):\\n result += mask_dict[i]\\n else:\\n result += binary[i]\\n return result\",\n \"def fn(mask):\\n for i in range(len(piles)): \\n val = (mask >> 3*i) & 7\\n for k in range(1, val+1): \\n mask0 = mask - (k << 3*i)\\n if not fn(mask0): return True \\n return False\",\n \"def isect_flags(arr, other):\\n flags = iter_reduce_ufunc(np.logical_or, (arr == item for item in other))\\n if flags is None:\\n flags = np.zeros(arr.shape, dtype=bool)\\n return flags\",\n \"def select_mask(cls, dataset, selection):\\n mask = np.ones(len(dataset), dtype=np.bool_)\\n for dim, sel in selection.items():\\n if isinstance(sel, tuple):\\n sel = slice(*sel)\\n arr = cls.values(dataset, dim)\\n if util.isdatetime(arr):\\n try:\\n sel = util.parse_datetime_selection(sel)\\n except Exception:\\n pass\\n if isinstance(sel, slice):\\n with warnings.catch_warnings():\\n warnings.filterwarnings('ignore', r'invalid value encountered')\\n if sel.start is not None:\\n mask &= sel.start <= arr\\n if sel.stop is not None:\\n mask &= arr < sel.stop\\n elif isinstance(sel, (set, list)):\\n iter_slcs = []\\n for ik in sel:\\n with warnings.catch_warnings():\\n warnings.filterwarnings('ignore', r'invalid value encountered')\\n iter_slcs.append(arr == ik)\\n mask &= np.logical_or.reduce(iter_slcs)\\n elif callable(sel):\\n mask &= sel(arr)\\n else:\\n index_mask = arr == sel\\n if dataset.ndims == 1 and np.sum(index_mask) == 0:\\n data_index = np.argmin(np.abs(arr - sel))\\n mask = np.zeros(len(dataset), dtype=np.bool_)\\n mask[data_index] = True\\n else:\\n mask &= index_mask\\n return mask\",\n \"def decode_flags(flags):\\n if isinstance(flags, six.string_types):\\n flags = int(flags.lstrip('@'), 16)\\n return [name for i, name in enumerate(flag_names) if (1 << i) & flags]\",\n \"def build_attention_mask(input_ids): \\n attention_masks = [] \\n\\n # 1 for input and 0 for pad\\n for seq in input_ids: \\n attention_masks.append([float(i>0) for i in seq])\\n\\n return attention_masks\",\n \"def _describe_bitmask(bits: int, table: Mapping[int, str], default: str = \\\"0\\\") -> str:\\n result = []\\n for bit, name in table.items():\\n if bit & bits:\\n result.append(name)\\n if not result:\\n return default\\n return \\\"|\\\".join(result)\",\n \"def _and(it):\\n return 1 if it[0]==1 and it[1]==1 else 0\",\n \"def get_all_const(*ops):\\n return all(map(get_const, ops))\",\n \"def get_bit(num, i):\\n return num & (1 << i) != 0\",\n \"def get_repetition_flags(self):\\n day_flags = 0\\n for i, box in enumerate((self._timer_mo_check_button,\\n self._timer_tu_check_button,\\n self._timer_we_check_button,\\n self._timer_th_check_button,\\n self._timer_fr_check_button,\\n self._timer_sa_check_button,\\n self._timer_su_check_button)):\\n\\n if box.get_active():\\n day_flags = day_flags | (1 << i)\\n\\n return day_flags\",\n \"def get_boolean_array_from(number: int) -> List[bool]:\\n return_value = [False] * MAX_BIT_LENGTH\\n last_bit_position = len(bin(number)) - 1\\n for i in range(0, last_bit_position):\\n return_value[i] = (number & (1 << i)) != 0\\n return return_value\",\n \"def bit_toggler(gen_on, gen_off):\\n for n_on, n_off in zip(gen_on, gen_off):\\n yield int(abs(n_on)), int(abs(n_off))\",\n \"def build_list_from_masks(cls, masks: Iterable[\\\"datacube_ows.styles.base.StyleMask\\\"],\\n layer: \\\"datacube_ows.ows_configuration.OWSNamedLayer\\\") -> List[\\\"FlagProductBands\\\"]:\\n flag_products = []\\n for mask in masks:\\n handled = False\\n for fp in flag_products:\\n if fp.products_match(mask.band.pq_names):\\n fp.add_flag_band(mask.band)\\n handled = True\\n break\\n if not handled:\\n flag_products.append(cls(mask.band, layer))\\n return flag_products\",\n \"def TransformFlags(self) -> _n_2_t_0[bool]:\",\n \"def _mask_list(self, items):\\n\\n result_type = type(items)\\n results = []\\n for item in items:\\n results.append(self._mask(item))\\n\\n return result_type(results)\",\n \"def In(sigOrVal, iterable):\\n res = None\\n for i in iterable:\\n i = toHVal(i)\\n if res is None:\\n res = sigOrVal._eq(i)\\n else:\\n res = res | sigOrVal._eq(i)\\n\\n return res\",\n \"def select_body_parts(mask, list_of_body_parts):\\n\\n new_mask = np.zeros(mask.shape).astype(np.bool)\\n\\n for body_part in list_of_body_parts:\\n idxs = body_parts[body_part]\\n\\n for idx in idxs:\\n m_ = (mask == idx)\\n new_mask = np.bitwise_or(new_mask, m_)\\n\\n return new_mask.astype(np.uint8)\",\n \"def set(self, *options: str) -> int:\\n self.flags |= self.mask(*options)\\n return self.flags\",\n \"def mask(n, start, end):\\n columns = []\\n value = 1\\n for i in range(n):\\n if start <= end:\\n columns.append(value if (start <= i < end) else 0)\\n else:\\n columns.append(value if (start <= i or i < end) else 0)\\n value <<= 1\\n return BitColumnMatrix(columns)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7744489","0.66913533","0.6403534","0.61704373","0.61267203","0.5990406","0.58188605","0.5776456","0.5742034","0.57257146","0.5702052","0.5667115","0.5648651","0.54798436","0.54597044","0.54477435","0.5405333","0.53865755","0.53729063","0.53284824","0.53239876","0.5318844","0.5270372","0.52507114","0.5245095","0.52319646","0.5230634","0.5213665","0.5198025","0.5164179","0.5141206","0.5126625","0.5126027","0.5119711","0.5117807","0.5112834","0.5112725","0.5097013","0.5082239","0.5075783","0.50738055","0.50585765","0.5027871","0.5010892","0.50049573","0.5003238","0.4979777","0.49746674","0.49683607","0.4950007","0.49456802","0.49420297","0.49414906","0.49380752","0.4922623","0.4901685","0.48975095","0.489577","0.48884663","0.48863894","0.48863512","0.48710364","0.4868574","0.48683816","0.48636955","0.4858367","0.48543674","0.48486152","0.48338532","0.4833055","0.4822523","0.48217905","0.48145393","0.48102877","0.48065755","0.48028445","0.4795193","0.47898728","0.47861308","0.47739306","0.47667357","0.47650197","0.47610134","0.47604635","0.475786","0.47546035","0.47504756","0.474548","0.47377563","0.47375527","0.4729819","0.47278863","0.47269985","0.47161314","0.47112918","0.47098666","0.47043633","0.47036403","0.46910927","0.4676379"],"string":"[\n \"0.7744489\",\n \"0.66913533\",\n \"0.6403534\",\n \"0.61704373\",\n \"0.61267203\",\n \"0.5990406\",\n \"0.58188605\",\n \"0.5776456\",\n \"0.5742034\",\n \"0.57257146\",\n \"0.5702052\",\n \"0.5667115\",\n \"0.5648651\",\n \"0.54798436\",\n \"0.54597044\",\n \"0.54477435\",\n \"0.5405333\",\n \"0.53865755\",\n \"0.53729063\",\n \"0.53284824\",\n \"0.53239876\",\n \"0.5318844\",\n \"0.5270372\",\n \"0.52507114\",\n \"0.5245095\",\n \"0.52319646\",\n \"0.5230634\",\n \"0.5213665\",\n \"0.5198025\",\n \"0.5164179\",\n \"0.5141206\",\n \"0.5126625\",\n \"0.5126027\",\n \"0.5119711\",\n \"0.5117807\",\n \"0.5112834\",\n \"0.5112725\",\n \"0.5097013\",\n \"0.5082239\",\n \"0.5075783\",\n \"0.50738055\",\n \"0.50585765\",\n \"0.5027871\",\n \"0.5010892\",\n \"0.50049573\",\n \"0.5003238\",\n \"0.4979777\",\n \"0.49746674\",\n \"0.49683607\",\n \"0.4950007\",\n \"0.49456802\",\n \"0.49420297\",\n \"0.49414906\",\n \"0.49380752\",\n \"0.4922623\",\n \"0.4901685\",\n \"0.48975095\",\n \"0.489577\",\n \"0.48884663\",\n \"0.48863894\",\n \"0.48863512\",\n \"0.48710364\",\n \"0.4868574\",\n \"0.48683816\",\n \"0.48636955\",\n \"0.4858367\",\n \"0.48543674\",\n \"0.48486152\",\n \"0.48338532\",\n \"0.4833055\",\n \"0.4822523\",\n \"0.48217905\",\n \"0.48145393\",\n \"0.48102877\",\n \"0.48065755\",\n \"0.48028445\",\n \"0.4795193\",\n \"0.47898728\",\n \"0.47861308\",\n \"0.47739306\",\n \"0.47667357\",\n \"0.47650197\",\n \"0.47610134\",\n \"0.47604635\",\n \"0.475786\",\n \"0.47546035\",\n \"0.47504756\",\n \"0.474548\",\n \"0.47377563\",\n \"0.47375527\",\n \"0.4729819\",\n \"0.47278863\",\n \"0.47269985\",\n \"0.47161314\",\n \"0.47112918\",\n \"0.47098666\",\n \"0.47043633\",\n \"0.47036403\",\n \"0.46910927\",\n \"0.4676379\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8022848"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93186,"cells":{"query":{"kind":"string","value":"A utility function that creates a list of enumeration values from a bit mask for a specific mask enumeration class."},"document":{"kind":"string","value":"def get_enumerations_from_bit_mask(enumeration, mask):\n return [x for x in enumeration if (x.value & mask) == x.value]"},"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 parse_mask(value, mask_enum):\n masks = []\n for mask in mask_enum:\n if value & mask:\n masks.append(mask.name)\n value ^= mask\n if value:\n masks.append(hex(value))\n\n return masks","def get_bit_mask_from_enumerations(enumerations):\n return functools.reduce(\n lambda x, y: x | y, [z.value for z in enumerations]\n )","def convertToEnumItemSetArray(boolean: bool) -> typing.List[cern.japc.value.EnumItemSet]:\n ...","def convertToEnumItemArray(boolean: bool) -> typing.List[cern.japc.value.EnumItem]:\n ...","def from_value(cls, value):\n value = value if value else 0\n try:\n flags = [flag.name for flag in cls.enum_class if flag.value & value]\n except TypeError:\n flags = [flag.name for flag in cls.enum_class if flag.name == value]\n\n return cls(*flags)","def convertToEnumItemSet(boolean: bool) -> cern.japc.value.EnumItemSet:\n ...","def convertToEnumItemSetArray(byte: int, enumType: cern.japc.value.EnumType) -> typing.List[cern.japc.value.EnumItemSet]:\n ...","def variable_type_from_booleans_to_enums(\n as_states: bool, as_controls: bool, as_states_dot: bool, as_stochastic: bool\n) -> list[VariableType]:\n\n variable_type = []\n if as_states:\n variable_type.append(VariableType.STATES)\n if as_states_dot:\n variable_type.append(VariableType.STATES_DOT)\n if as_controls:\n variable_type.append(VariableType.CONTROLS)\n if as_stochastic:\n variable_type.append(VariableType.STOCHASTIC)\n return variable_type","def to_bit_list(val, width=16):\n return [(1 if val & (1<<n) else 0) for n in range(width)]","def from_bitmask ( cls, mode, rwx_bits ):\n return cls (\n mode & rwx_bits[0], mode & rwx_bits[1], mode & rwx_bits[2],\n )","def get_enum_constants(cf, verbose):\n # Gets enum constants declared in the given class.\n # Consider the following code:\n # which compiles to:\n \"\"\"\n public final class TestEnum extends java.lang.Enum<TestEnum>\n minor version: 0\n major version: 52\n flags: ACC_PUBLIC, ACC_FINAL, ACC_SUPER, ACC_ENUM\n {\n public static final TestEnum FOO;\n descriptor: LTestEnum;\n flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM\n\n public static final TestEnum BAR;\n descriptor: LTestEnum;\n flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM\n\n public static final TestEnum BAZ;\n descriptor: LTestEnum;\n flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM\n\n public static final TestEnum RECOMMENDED_VALUE;\n descriptor: LTestEnum;\n flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL\n\n private static final TestEnum[] $VALUES;\n descriptor: [LTestEnum;\n flags: ACC_PRIVATE, ACC_STATIC, ACC_FINAL, ACC_SYNTHETIC\n\n public static TestEnum[] values();\n // ...\n\n public static TestEnum valueOf(java.lang.String);\n // ...\n\n private TestEnum(int);\n // ...\n\n static {};\n descriptor: ()V\n flags: ACC_STATIC\n Code:\n stack=5, locals=0, args_size=0\n // Initializing enum constants:\n 0: new #5 // class TestEnum\n 3: dup\n 4: ldc #8 // String FOO\n 6: iconst_0\n 7: sipush 900\n 10: invokespecial #1 // Method \"<init>\":(Ljava/lang/String;II)V\n 13: putstatic #9 // Field FOO:LTestEnum;\n 16: new #10 // class TestEnum$1\n 19: dup\n 20: ldc #11 // String BAR\n 22: iconst_1\n 23: bipush 42\n 25: invokespecial #12 // Method TestEnum$1.\"<init>\":(Ljava/lang/String;II)V\n 28: putstatic #13 // Field BAR:LTestEnum;\n 31: new #5 // class TestEnum\n 34: dup\n 35: ldc #14 // String BAZ\n 37: iconst_2\n 38: ldc #15 // String SomeSystemProperty\n 40: invokestatic #16 // Method java/lang/Integer.getInteger:(Ljava/lang/String;)Ljava/lang/Integer;\n 43: invokevirtual #17 // Method java/lang/Integer.intValue:()I\n 46: invokespecial #1 // Method \"<init>\":(Ljava/lang/String;II)V\n 49: putstatic #18 // Field BAZ:LTestEnum;\n // Setting up $VALUES\n 52: iconst_3\n 53: anewarray #5 // class TestEnum\n 56: dup\n 57: iconst_0\n 58: getstatic #9 // Field FOO:LTestEnum;\n 61: aastore\n 62: dup\n 63: iconst_1\n 64: getstatic #13 // Field BAR:LTestEnum;\n 67: aastore\n 68: dup\n 69: iconst_2\n 70: getstatic #18 // Field BAZ:LTestEnum;\n 73: aastore\n 74: putstatic #2 // Field $VALUES:[LTestEnum;\n // Other user-specified stuff\n 77: getstatic #13 // Field BAR:LTestEnum;\n 80: putstatic #19 // Field RECOMMENDED_VALUE:LTestEnum;\n 83: return\n }\n \"\"\"\n # We only care about the enum constants, not other random user stuff\n # (such as RECOMMENDED_VALUE) or the $VALUES thing. Fortunately,\n # ACC_ENUM helps us with this. It's worth noting that although MC's\n # obfuscater gets rid of the field names, it does not get rid of the\n # string constant for enum names (which is used by valueOf()), nor\n # does it touch ACC_ENUM.\n # For this method, we don't care about parameters other than the name.\n if not cf.access_flags.acc_enum:\n raise Exception(cf.this.name.value + \" is not an enum!\")\n\n enum_fields = list(cf.fields.find(f=lambda field: field.access_flags.acc_enum))\n enum_class = None\n enum_name = None\n\n result = {}\n\n for ins in cf.methods.find_one(name=\"<clinit>\").code.disassemble():\n if ins == \"new\" and enum_class is None:\n const = ins.operands[0]\n enum_class = const.name.value\n elif ins in (\"ldc\", \"ldc_w\") and enum_name is None:\n const = ins.operands[0]\n if isinstance(const, String):\n enum_name = const.string.value\n elif ins == \"putstatic\":\n if enum_class is None or enum_name is None:\n if verbose:\n print(\"Ignoring putstatic for %s as enum_class or enum_name is unset\" % str(ins))\n continue\n const = ins.operands[0]\n assigned_field = const.name_and_type\n if not any(field.name == assigned_field.name and field.descriptor == assigned_field.descriptor for field in enum_fields):\n # This could happen with an enum constant that sets a field in\n # its constructor, which is unlikely but happens with e.g. this:\n \"\"\"\n enum Foo {\n FOO(i = 2);\n static int i;\n private Foo(int n) {}\n }\n \"\"\"\n if verbose:\n print(\"Ignoring putstatic for %s as it is to a field not in enum_fields (%s)\" % (str(ins), enum_fields))\n continue\n result[enum_name] = {\n 'name': enum_name,\n 'field': assigned_field.name.value,\n 'class': enum_class\n }\n enum_class = None\n enum_name = None\n\n if len(result) == len(enum_fields):\n break\n\n if verbose and len(result) != len(enum_fields):\n print(\"Did not find assignments to all enum fields - fields are %s and result is %s\" % (result, enum_fields))\n\n return result","def _build_all_enums(self):\n uniq_enums = []\n used_values = set()\n enum_value_to_name_list = defaultdict(set) # key: int, value: list of strings (enum name\n for enum in self.enum_list:\n if enum in self.bitmask_enums:\n continue\n\n if enum not in self.enum_name_to_value:\n print(f'Notice: enum {enum} has no value')\n continue\n\n if not self._enum_should_collect(enum):\n continue\n\n value = self.enum_name_to_value[enum]\n\n enum_value_to_name_list[value].add(enum)\n\n if value in used_values:\n continue\n\n uniq_enums.append((value, enum))\n used_values.add(value)\n\n uniq_enums.sort()\n\n for value, enum in uniq_enums:\n name_list = self._choose_enum_names(enum_value_to_name_list[value])\n if name_list:\n list_str = ' / '.join(name_list)\n enum_value_str = self._case_value(enum)\n case = f' case {enum_value_str}: return \"{list_str}\";'\n self.all_enum_string_cases.append(case)\n\n self.map_make_entries.append(f' {{ \"{enum}\", {enum_value_str} }}')","def convertToEnumItemArray(byte: int, enumType: cern.japc.value.EnumType) -> typing.List[cern.japc.value.EnumItem]:\n ...","def _generateResults_combosToBitmasks(self, all, want_combos):\n names = {}\n iter = enumerate(all)\n try:\n i, name = next(iter)\n while True:\n names[name] = (1 << i)\n i, name = next(iter)\n except StopIteration:\n pass\n print \"combosToBitmasks names:\", names\n results = []\n for combo in want_combos:\n mask = 0\n for name in combo:\n if name in names:\n mask |= names[name]\n results.append(mask)\n return results","def to_list(bits: int) -> list[Position]:\n positions = []\n for r in range(8):\n for c in range(8):\n mask = pos_mask(r, c)\n if bits & mask > 0:\n positions.append(Position(r, c))\n return positions","def expand_mask(kind, value):\n result = []\n if value != 0:\n mask_values = zip(spirv.spv[kind].values(), spirv.spv[kind].keys())\n mask_values = sorted(mask_values, key=itemgetter(0))\n for mask_number, mask_token in mask_values:\n if (mask_number & value) != 0:\n result.append(mask_token)\n value = value ^ mask_number\n if value != 0:\n raise ParseError('Invalid mask value')\n return result","def set24_to_list(v):\n return [x for x in range(24) if v & (1 << x)]","def build_list_from_masks(cls, masks: Iterable[\"datacube_ows.styles.base.StyleMask\"],\n layer: \"datacube_ows.ows_configuration.OWSNamedLayer\") -> List[\"FlagProductBands\"]:\n flag_products = []\n for mask in masks:\n handled = False\n for fp in flag_products:\n if fp.products_match(mask.band.pq_names):\n fp.add_flag_band(mask.band)\n handled = True\n break\n if not handled:\n flag_products.append(cls(mask.band, layer))\n return flag_products","def mask(self):\n return list(self._mask_generator())","def all_bits_list(vals, width=16):\n return flatten_list([to_bit_list(val, width) for val in vals])","def _build_enum_groups(self):\n for group in self.used_enum_groups:\n if group not in self.group_to_enum_list:\n print(f'Warning: Enum group {group} has no values defined.')\n continue\n\n group_type = 'basic'\n if group in self.bitmask_groups:\n group_type = 'bitmask'\n\n values_used = set()\n enum_name_list = self.group_to_enum_list[group]\n enum_tuple_list = []\n for enum_name in enum_name_list:\n if enum_name not in self.enum_list:\n continue\n\n if enum_name not in self.enum_name_to_value:\n print(f'Warning: enum {enum_name} has no value')\n continue\n\n if not self._enum_should_collect(enum_name):\n continue\n\n enum_value = self.enum_name_to_value[enum_name]\n if enum_value not in values_used:\n enum_value_str = self._case_value(enum_name)\n enum_tuple_list.append((enum_value, enum_value_str, enum_name))\n values_used.add(enum_value)\n\n if enum_name in self.bitmask_enums:\n group_type = 'bitmask'\n\n enum_tuple_list.sort()\n\n group_max_len = 0\n for enum_info in enum_tuple_list:\n wrapper_enum_value_name = enum_info[2][3:].lower()\n if wrapper_enum_value_name in RESERVED_NAMES:\n wrapper_enum_value_name = wrapper_enum_value_name + '_'\n if len(wrapper_enum_value_name) > group_max_len:\n group_max_len = len(wrapper_enum_value_name)\n\n group_enum_string_entries = []\n group_enum_to_base_zero_entries = []\n base_zero_to_group_enum_entries = []\n group_wrapper_enum_value_definitions = []\n base_zero_value = 0\n\n for enum_info in enum_tuple_list:\n wrapper_enum_value_name = enum_info[2][3:].lower()\n\n if wrapper_enum_value_name in RESERVED_NAMES:\n wrapper_enum_value_name = wrapper_enum_value_name + '_'\n\n formatting = {\n 'ENUM_VALUE': enum_info[1],\n 'ENUM_STRING': enum_info[2],\n 'ENUM_BASE_ZERO_VALUE': base_zero_value,\n 'ENUM_VERSION': self._enum_version(enum_info[2]),\n 'WRAPPER_ENUM_TYPE_NAME': self.to_type_name(group),\n 'WRAPPER_ENUM_VALUE_NAME': wrapper_enum_value_name,\n }\n\n string_entry = templates.ENUM_STRING_MAKE_ENTRY[group_type].format(**formatting)\n group_enum_string_entries.append(string_entry)\n group_wrapper_enum_value_definitions.append(\n ' {:{}} = {:>6}u /* {} */'.format(\n wrapper_enum_value_name,\n group_max_len,\n enum_info[1],\n self._enum_version(enum_info[2])))\n\n if group_type == 'basic':\n group_enum_to_base_zero_make_entry = templates.ENUM_TO_BASE_ZERO_MAKE_ENTRY.format(**formatting)\n base_zero_to_group_enum_make_entry = templates.BASE_ZERO_TO_ENUM_MAKE_ENTRY.format(**formatting)\n group_enum_to_base_zero_entries.append(group_enum_to_base_zero_make_entry)\n base_zero_to_group_enum_entries.append(base_zero_to_group_enum_make_entry)\n base_zero_value = base_zero_value + 1\n\n if enum_tuple_list:\n wrapper_enum_name = self.to_type_name(group)\n definitions = ',\\n'.join(sorted(group_wrapper_enum_value_definitions))\n string_entries = '\\n'.join(sorted(group_enum_string_entries))\n formatting = {\n 'WRAPPER_ENUM_TYPE_NAME': wrapper_enum_name,\n 'WRAPPER_ENUM_STRING_FN_NAME': self.split_to_body_and_ext(group)[0],\n 'GROUP_NAME': group,\n 'WRAPPER_ENUM_VALUE_DEFINITIONS': definitions,\n 'GROUP_ENUM_STRING_ENTRIES': string_entries,\n 'GROUP_ENUM_TO_BASE_ZERO_ENTRIES': '\\n'.join(group_enum_to_base_zero_entries),\n 'BASE_ZERO_TO_GROUP_ENUM_ENTRIES': '\\n'.join(base_zero_to_group_enum_entries),\n }\n\n if group_type == 'basic':\n self.enum_to_base_zero_function_declarations.append(\n templates.ENUM_TO_BASE_ZERO_FUNCTION_DECLARATION.format(**formatting)\n )\n self.base_zero_to_enum_function_declarations.append(\n templates.BASE_ZERO_TO_ENUM_FUNCTION_DECLARATION.format(**formatting)\n )\n self.enum_base_zero_function_definitions.append(\n templates.ENUM_BASE_ZERO_FUNCTION_DEFINITION.format(**formatting)\n )\n self.untyped_enum_string_function_declarations.append(\n templates.UNTYPED_ENUM_STRING_FUNCTION_DECLARATION.format(**formatting)\n )\n self.untyped_enum_string_function_definitions.append(\n templates.UNTYPED_ENUM_STRING_FUNCTION_DEFINITION.format(**formatting)\n )\n\n self.enum_string_function_declarations.append(\n templates.ENUM_STRING_FUNCTION_DECLARATION[group_type].format(**formatting)\n )\n self.enum_string_function_definitions.append(\n templates.ENUM_STRING_FUNCTION_DEFINITION[group_type].format(**formatting)\n )\n self.wrapper_enum_declarations.append(\n templates.WRAPPER_ENUM_DECLARATION.format(**formatting)\n )\n self.enum_helper_definitions.append(\n templates.ENUM_HELPER_DEFINITION[group_type].format(**formatting)\n )","def bitModeToEnum(bitMode):\n bits = {\n 0: CORR_2BIT,\n 1: CORR_3BIT,\n 2: CORR_4BIT\n }\n return bits[bitMode]","def box_flags(self, box):\n return [flag for flag in self.flags if flag.box == box]","def GetActuatorsWithStatus(status_flags, status_helper, status_to_check):\n\n flag = 0\n for status in status_to_check:\n flag |= status_helper.Value(status)\n return [key for key, value in status_flags.iteritems() if value & flag]","def getFlags(flagbyte, *positions):\n return [getFlag(flagbyte, pos) for pos in positions]","def parse_mask(mask):\n mask_dict = dict()\n for i, val in enumerate(mask):\n mask_dict[i] = val\n\n return mask_dict","def decode_flags(flags):\n if isinstance(flags, six.string_types):\n flags = int(flags.lstrip('@'), 16)\n return [name for i, name in enumerate(flag_names) if (1 << i) & flags]","def flags(self):\n flags = self.Flags\n return [x for x in self.FLAGS_VALUES if flags & x]","def convertToEnumItem(boolean: bool) -> cern.japc.value.EnumItem:\n ...","def handle_enum(enum_annotations: Any) -> list:\n result = []\n for attribute in list(enum_annotations):\n result.append(attribute.value)\n return result","def _all_labels_to_bitmasks(all_labels):\n l_dict = {}\n for i, label in enumerate(all_labels):\n l_dict[label.name] = 1<<i\n return l_dict","def availableValues(self):\n return [x.name for x in self._field.enum_type.values]","def bitlist(n):\n return [n >> i & 1 for i in range(7,-1,-1)]","def getmask(\n self, mask: Union[List[dd.Series], UserList], inverse: bool = False\n ) -> List[dd.Series]:\n output = []\n for data, cond in zip(self.data, mask):\n if inverse:\n output.append(data[~cond])\n else:\n output.append(data[cond])\n\n return output","def get_all_flags(options):\n flags = []\n if options.inputFlag:\n flags.append(try_to_int(options.inputFlag))\n if options.outputFlags:\n for flag in options.outputFlags:\n flags.append(try_to_int(flag))\n return flags","def list_available_enum(enum_type: Type[Enum]) -> List[str]:\n return [f\"{i}: {v}\" for (i, v) in enumerate(enum_type)] # type: ignore[var-annotated]","def flags(cls):\n\n assert cls.__bases__ == (object,)\n\n d = dict(cls.__dict__)\n new_type = type(cls.__name__, (int,), d)\n new_type.__module__ = cls.__module__\n\n map_ = {}\n for key, value in iteritems(d):\n if key.upper() == key and isinstance(value, integer_types):\n value_instance = new_type(value)\n setattr(new_type, key, value_instance)\n map_[value] = key\n\n def str_(self):\n value = int(self)\n matches = []\n for k, v in map_.items():\n if value & k:\n matches.append(\"%s.%s\" % (type(self).__name__, v))\n value &= ~k\n if value != 0 or not matches:\n matches.append(text_type(value))\n\n return \" | \".join(matches)\n\n def repr_(self):\n return \"<%s: %d>\" % (str(self), int(self))\n\n setattr(new_type, \"__repr__\", repr_)\n setattr(new_type, \"__str__\", str_)\n\n return new_type","def create_basic_flag_mask(*flags):\n\n out = np.ones(len(flags[0]), bool)\n for flag in flags:\n out &= (~flag)\n\n return out","def flags(self):\n return list(self._flags_generator())","def choices(cls):\n # return list(map(tuple, cls.__members__.items()))\n return [(int(code), name) for name, code in cls.__members__.items()]","def mapping_for_enum(mapping):\n return dict(mapping.keys())","def as_name_list(cls, lower=True, **kwargs):\n return cls.enum_class.as_name_list(lower=lower, **kwargs)","def decode(self, emissions: torch.Tensor,\n mask: Optional[torch.ByteTensor] = None) -> List[List[int]]:\n if mask is None:\n mask = emissions.new_ones(emissions.shape[:2], dtype=torch.uint8)\n\n return self._viterbi_decode(emissions, mask)","def __iter__(self):\n return iter(self._enums)","def enum(cls, options, values):\r\n names, real = zip(*options)\r\n del names # unused\r\n\r\n def factory(i, name):\r\n return cls(i, name, (len(real),), lambda a: real[a[0]], values)\r\n return factory","def get_flags(self):\n\n if self.raw.flags not in [0, 1, 2, 3]:\n raise ValueError(\"Invalid raw flags: {}\".format(self.raw.flags))\n\n flags = set()\n\n if (self.raw.flags & 0b010) > 0:\n flags.add(\"DF\")\n\n if (self.raw.flags & 0b001) > 0:\n flags.add(\"MF\")\n\n return frozenset(flags)","def tenum(name, vals):\n\n if isinstance(vals, basestring):\n vals = vals.split()\n sort, consts = z3.EnumSort(name, vals)\n fields = dict(zip(vals, consts))\n fields[\"_z3_sort\"] = sort\n return type(name, (SEnumBase, SymbolicVal), fields)","def make_class_masks(subject_names):\n masks = Munch()\n\n masks.has_dash = subject_names.apply(test_dash_in)\n masks.first_alpha = subject_names.apply(test_starts_letter)\n masks.last_alpha = subject_names.apply(test_ends_letter)\n\n return masks","def process_result_value(self, value, dialect):\n masks = list()\n if value:\n for e in enums.CryptographicUsageMask:\n if e.value & value:\n masks.append(e)\n return masks","def _GetContactNoticeEnum(domains_messages):\n return domains_messages.ConfigureContactSettingsRequest.ContactNoticesValueListEntryValuesEnum","def enum_names(self):\n return [enum.name for enum in self]","def _string_to_bitlist(self, data):\n l = len(data) * 8\n result = [0] * l\n pos = 0\n for ch in data:\n i = 7\n while i >= 0:\n # bit-wise operation\n if ch & (1 << i) != 0:\n result[pos] = 1\n else:\n result[pos] = 0\n pos += 1\n i -= 1\n return result","def enums(self) -> Mapping[str, wrappers.EnumType]:\n return collections.ChainMap({},\n *[p.all_enums for p in self.protos.values()],\n )","def _decode_mask(mask: dict):\n bitmask = mask.get('mask')\n mem_dict = {key: val for key, val in mask.items() if not key == 'mask'}\n new_mem_dict = dict()\n\n for mem in mem_dict.items():\n bit_str = BIT_FORMAT.format(mem[1])\n result_str = ''\n\n for i in range(len(bit_str)):\n new_bit = bit_str[i] if bitmask[i] == 'X' else bitmask[i]\n result_str += new_bit\n\n new_mem_dict[mem[0]] = int(result_str, 2)\n\n return new_mem_dict","def enum(**enums):\n return type('Enum',(),enums)","def unmask(self, mask, verbose=0):\n if isinstance(mask, str): # Woodstock-style string mask format\n mask = tuple(re.sub('\\s+', ' ', mask).lower().split(' '))\n assert len(mask) == self.nthemes # must be bad mask if wrong theme count\n else:\n try:\n assert isinstance(mask, tuple) and len(mask) == self.nthemes\n except:\n print(len(mask), type(mask), mask)\n assert False\n dtype_keys = copy.copy(list(self.dtypes.keys())) # filter this\n for ti, tac in enumerate(mask):\n if tac == '?': continue # wildcard matches all\n tacs = self._expand_theme(self._themes[ti], tac, verbose=verbose) if tac in self._themes[ti] else []\n dtype_keys = [dtk for dtk in dtype_keys if dtk[ti] in tacs] # exclude bad matches\n return dtype_keys","def with_mask(self, mask):\n return self[mask]","def bits_list(number):\n\n # https://wiki.python.org/moin/BitManipulation\n if number == 0:\n return [0]\n else:\n # binary_literal string e.g. '0b101'\n binary_literal = bin(number)\n bits_string = binary_literal.lstrip('0b')\n # list comprehension\n bits = [int(bit_character) for bit_character in bits_string]\n return bits","def from_python_enum_direct_values(cls, enum, name=None):\n if name is None:\n name = enum.__name__\n return cls(name, [EnumValue(v.name, python_value=v.value) for v in enum])","def encode_flags(names):\n return reduce(operator.ior, (flag_masks[name] for name in names), 0)","def bits(byte: int) -> Sequence[bool]:\n assert byte < 0x100\n return [bool(byte & mask) for mask in bit_masks]","def _regex_flags_from_bits(self, bits):\n flags = 'tilmsux'\n return ''.join(flags[i] if (1 << i) & bits else '' for i in xrange(6))","def enums(self):\n return self._enums","def enum(*sequential, **named):\n enums = dict(zip(sequential, range(len(sequential))), **named)\n return type('Enum', (), enums)","def enum(*sequential, **named):\n enums = dict(zip(sequential, range(len(sequential))), **named)\n return type('Enum', (), enums)","def enum(*sequential, **named):\n enums = dict(zip(sequential, range(len(sequential))), **named)\n return type('Enum', (), enums)","def enum(*sequential, **named):\n enums = dict(zip(sequential, range(len(sequential))), **named)\n return type('Enum', (), enums)","def _GetContactPrivacyEnum(domains_messages):\n return domains_messages.ContactSettings.PrivacyValueValuesEnum","def _fromflagname(cls, name:str, default=...) -> enum.Enum:\n if default is not Ellipsis:\n return cls._LOOKUP.get(name, default)\n return cls._LOOKUP[name]","def makeListOfEnabledEvents(gcauCfgDict):\r\n OBJ_NAME = \"SYSVAR\"\r\n OBJ_ATTR = \"EventEnable\"\r\n list = []\r\n try:\r\n obj = gcauCfgDict[OBJ_NAME]\r\n try:\r\n mask = int(obj[OBJ_ATTR], 16)\r\n except KeyError:\r\n raise AgcAttrException(\"{0} misses: {1}\"\\\r\n .format(jeep.defGetMyName(), OBJ_ATTR))\r\n else:\r\n n = 1\r\n while mask != 0:\r\n if mask % 2:\r\n list.append(n)\r\n mask = mask >> 1\r\n n = n + 1 \r\n except KeyError:\r\n raise AgcObjException(\"{0} mises: {1}\"\\\r\n .format(jeep.defGetMyName(), OBJ_NAME))\r\n return list","def construct_by_element_mask(cls, mask):\n mask = np.asarray(mask)\n ue = np.unique(mask)\n if not (len(mask.shape) == 2 and len(ue) == 2 and 0 in ue and 1 in ue):\n raise ValueError(\"The mask matrix should be a 2d array, and there must be only \"\n \"1 and 0 in the matrix, in which, 1 means the corresponding \"\n \"element is known, and will be added to the MultiLabelIndexCollection container.\")\n\n nz_row, nz_col = np.nonzero(mask)\n return cls(data=[(nz_row[i], nz_col[i]) for i in range(len(nz_row))], label_size=mask.shape[1])","def __get_bit_values(self, number, size=32):\n res = list(self.__gen_bit_values(number))\n res.reverse()\n # 0-pad the most significant bit\n res = [0] * (size - len(res)) + res\n return res","def get_all_enums(schema_obj):\n\n enums = []\n for vendor in schema_obj.vendor_list:\n for typespace in vendor.typespace_list:\n for enum in typespace.enum_list:\n enums.append(enum)\n for trait in vendor.trait_list:\n for enum in trait.enum_list:\n enums.append(enum)\n for enum in vendor.enum_list:\n enums.append(enum)\n return enums","def _GetTransferLockEnum(domains_messages):\n return domains_messages.ManagementSettings.TransferLockStateValueValuesEnum","def bitfield(x, m):\n b = [1 if digit=='1' else 0 for digit in bin(x)[2:]]\n for i in range(len(b), m):\n b.insert(0, 0)\n return b","def to_list(self):\n return [bits.value for bits in self.data]","def test_should_return_a_list(self):\n\n tcp_flags = TCPControlBits(['SYN', 'ACK'])\n assert_is_instance(tcp_flags.to_list(), list)","def sequential_enum(*sequential, **named):\n enums = dict(zip(sequential, range(len(sequential))), **named)\n return type('Enum', (), enums)","def bits(self):\n return list(range(self.lsb, self.msb + 1))","def makeCountriesEnumerationType (self):\n\t\t# stub = getEnumerationTypeXmlStub (\"countriesType\")\n\t\t# countriesVocab = AnnotatedEnumerationType (stub)\n\t\tcountriesVocab = self.createEnumerationType (\"countriesType\");\n\t\tcountry_codes = self.countryCodeMap.keys()\n\t\tcountry_codes.sort()\n\t\tdataList = map (lambda key: (key, self.countryCodeMap[key].name), country_codes)\n\t\tcountriesVocab.setValues (dataList)\n\t\treturn countriesVocab","def convertMaskToWeights(mask):\n vals = np.unique(mask)\n for i in range(len(vals)):\n mask[mask==vals[i]]=i\n mask = mask.astype(int)\n w = mask.ravel() \n return w","def list_flags(self):\n return self._defs.items()","def mask(self) -> list[int]:\n return self._mask","def build_mask(mask, unused_features_positions):\n\tfinal_mask = mask.tolist()\n\n\tfor i in range(len(unused_features_positions)):\n\t\tif not unused_features_positions[i]:\n\t\t\tfinal_mask.insert(i, False)\n\n\treturn final_mask","def decode_aurafilter(aurafilter: int) -> Tuple[List[str], _Hex]:\n af_names = []\n for name, flag in AURAFILTER_FLAGS.items():\n if aurafilter & flag:\n aurafilter &= ~flag\n af_names.append(name)\n return af_names, _Hex(aurafilter)","def build_semantic_masks(self):\n with tf.variable_scope(\"build_semantic_masks\"):\n dynamic_tgt_mask = self.__priors\n static_tgt_mask = 1.0 - dynamic_tgt_mask\n return dynamic_tgt_mask, static_tgt_mask","def makeMaskFromArray(array):\n if array is None: return None\n cls = globals()[\"Mask%s\" % suffixes[str(array.dtype.type)]]\n return cls(array)","def mask2categorical(Mask: tf.Tensor, labels: dict) -> tf.Tensor:\n assert type(labels) == dict, \"labels variable should be a dictionary\"\n\n X = Mask\n\n if X.dtype == \"float32\":\n X = tf.cast(X*255, dtype=\"uint8\")\n\n Y = tf.zeros(X.shape[0:2] , dtype=\"float32\")\n for i, key in enumerate(labels):\n Y = tf.where(np.all(X == labels[key], axis=-1), i, Y)\n Y = tf.cast(Y, dtype=\"uint8\")\n return Y","def listFlag(flaglist):\n flag = 0\n for index, item in enumerate(flaglist):\n flag = setFlag(flag, index, item)\n return flag","def process_flags(self):\n\t\tsflags = []\n\t\tfor attr in dir(self):\n\t\t\tif attr[:3] != \"PF_\":\n\t\t\t\tcontinue\n\t\t\tvalue = getattr(self, attr)\n\t\t\tif value & self.fields[\"flags\"]:\n\t\t\t\tsflags.append(attr)\n\n\t\treturn sflags","def enumerate_flags(flag, f_map):\r\n # Reset string based flags to null\r\n f_type = ''\r\n f_flag = ''\r\n # Iterate through flags\r\n for i in f_map:\r\n if i & flag:\r\n if f_map[i] == 'FolderEvent;' or \\\r\n f_map[i] == 'FileEvent;' or \\\r\n f_map[i] == 'SymbolicLink;' or \\\r\n f_map[i] == 'HardLink;':\r\n f_type = ''.join([f_type, f_map[i]])\r\n else:\r\n f_flag = ''.join([f_flag, f_map[i]])\r\n return f_type, f_flag","def __gen_bit_values(number):\n number = int(number)\n while number:\n yield number & 0x1\n number >>= 1","def __init__(self, eset, flags=None):\n\n # Store the EnumSet\n self.eset = eset\n\n # Initialize the flags\n self.bitflags = 0\n self.flags = set()\n\n # Routine to call if we're modified\n self._notify = None\n\n # Process the flags that were set\n if isinstance(flags, six.integer_types):\n for opt in eset:\n if flags & int(opt):\n self.bitflags |= int(opt)\n self.flags.add(str(opt))\n\n # Make sure we got them all\n if self.bitflags != flags:\n raise TypeError(\n 'Unable to find enumeration values for 0x%x' %\n (flags & ~self.bitflags)\n )\n elif isinstance(flags, six.string_types):\n try:\n opt = eset[flags]\n except KeyError:\n raise TypeError(\n 'Unable to find enumeration value for flag \\\"%s\\\"' % flags\n )\n\n self.bitflags |= int(opt)\n self.flags.add(str(opt))\n elif flags is not None:\n for flag in flags:\n try:\n opt = eset[flag]\n except KeyError:\n raise TypeError(\n 'Unable to find enumeration value for flag \\\"%s\\\"' %\n flag\n )\n\n self.bitflags |= int(opt)\n self.flags.add(str(opt))","def _fixed_masks_arg(mask):\n return [\"NULL\", mask]","def generate_list(self):\n\n array = [False] * 25\n bits = self.generate_bits()\n\n for column in range(2, -1, -1):\n for row in range(0, 5):\n bit = next(bits)\n\n array[column + (row * 5)] = bit\n array[(4 - column) + (row * 5)] = bit\n\n return array","def _enumerate_message(self, name, message_class):\n key_value_pair = []\n assert(message_class is not None) \n assert(dir(message_class) is not None) \n \n # TODO: to review, hack\n for key in dir(message_class):\n if key.isupper():\n \n # set the class attributes to the Enum values\n key_value_pair.append((key, getattr(message_class, key)))\n \n return Enum(name, key_value_pair)","def IntEnum(name, keys, start=1):\n return IntEnumBase(name,\n [(key, index) for index, key in enumerate(keys, start=start)])","def get_bitmask(self):\r\n return self.__bitmask__","def values (root, ignore_access_errors=False, _want_types=False):\n root = registry (root, accept_value=False)\n try:\n hKey = root.pyobject ()\n except exc.x_access_denied:\n if ignore_access_errors:\n raise StopIteration\n else:\n raise\n\n values = []\n i = 0\n while True:\n try:\n name, value, type = wrapped (win32api.RegEnumValue, hKey, i)\n if _want_types:\n yield name, value, type\n else:\n yield name, value\n except exc.x_access_denied:\n if ignore_access_errors:\n raise StopIteration\n else:\n raise\n i += 1","def readEnumTypes(self):\n types = {}\n for m in re.finditer(\"TYPE (\\w*) = ENUMERATION OF\\s*\\(([\\,\\w\\_\\s]*)\\);\\s*END_TYPE;\", self.data, re.DOTALL):\n typename, types_enum_string = m.groups() \n typestring = re.sub('\\s', '', types_enum_string)\n types[typename] = typestring.split(',')\n \n return types"],"string":"[\n \"def parse_mask(value, mask_enum):\\n masks = []\\n for mask in mask_enum:\\n if value & mask:\\n masks.append(mask.name)\\n value ^= mask\\n if value:\\n masks.append(hex(value))\\n\\n return masks\",\n \"def get_bit_mask_from_enumerations(enumerations):\\n return functools.reduce(\\n lambda x, y: x | y, [z.value for z in enumerations]\\n )\",\n \"def convertToEnumItemSetArray(boolean: bool) -> typing.List[cern.japc.value.EnumItemSet]:\\n ...\",\n \"def convertToEnumItemArray(boolean: bool) -> typing.List[cern.japc.value.EnumItem]:\\n ...\",\n \"def from_value(cls, value):\\n value = value if value else 0\\n try:\\n flags = [flag.name for flag in cls.enum_class if flag.value & value]\\n except TypeError:\\n flags = [flag.name for flag in cls.enum_class if flag.name == value]\\n\\n return cls(*flags)\",\n \"def convertToEnumItemSet(boolean: bool) -> cern.japc.value.EnumItemSet:\\n ...\",\n \"def convertToEnumItemSetArray(byte: int, enumType: cern.japc.value.EnumType) -> typing.List[cern.japc.value.EnumItemSet]:\\n ...\",\n \"def variable_type_from_booleans_to_enums(\\n as_states: bool, as_controls: bool, as_states_dot: bool, as_stochastic: bool\\n) -> list[VariableType]:\\n\\n variable_type = []\\n if as_states:\\n variable_type.append(VariableType.STATES)\\n if as_states_dot:\\n variable_type.append(VariableType.STATES_DOT)\\n if as_controls:\\n variable_type.append(VariableType.CONTROLS)\\n if as_stochastic:\\n variable_type.append(VariableType.STOCHASTIC)\\n return variable_type\",\n \"def to_bit_list(val, width=16):\\n return [(1 if val & (1<<n) else 0) for n in range(width)]\",\n \"def from_bitmask ( cls, mode, rwx_bits ):\\n return cls (\\n mode & rwx_bits[0], mode & rwx_bits[1], mode & rwx_bits[2],\\n )\",\n \"def get_enum_constants(cf, verbose):\\n # Gets enum constants declared in the given class.\\n # Consider the following code:\\n # which compiles to:\\n \\\"\\\"\\\"\\n public final class TestEnum extends java.lang.Enum<TestEnum>\\n minor version: 0\\n major version: 52\\n flags: ACC_PUBLIC, ACC_FINAL, ACC_SUPER, ACC_ENUM\\n {\\n public static final TestEnum FOO;\\n descriptor: LTestEnum;\\n flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM\\n\\n public static final TestEnum BAR;\\n descriptor: LTestEnum;\\n flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM\\n\\n public static final TestEnum BAZ;\\n descriptor: LTestEnum;\\n flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM\\n\\n public static final TestEnum RECOMMENDED_VALUE;\\n descriptor: LTestEnum;\\n flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL\\n\\n private static final TestEnum[] $VALUES;\\n descriptor: [LTestEnum;\\n flags: ACC_PRIVATE, ACC_STATIC, ACC_FINAL, ACC_SYNTHETIC\\n\\n public static TestEnum[] values();\\n // ...\\n\\n public static TestEnum valueOf(java.lang.String);\\n // ...\\n\\n private TestEnum(int);\\n // ...\\n\\n static {};\\n descriptor: ()V\\n flags: ACC_STATIC\\n Code:\\n stack=5, locals=0, args_size=0\\n // Initializing enum constants:\\n 0: new #5 // class TestEnum\\n 3: dup\\n 4: ldc #8 // String FOO\\n 6: iconst_0\\n 7: sipush 900\\n 10: invokespecial #1 // Method \\\"<init>\\\":(Ljava/lang/String;II)V\\n 13: putstatic #9 // Field FOO:LTestEnum;\\n 16: new #10 // class TestEnum$1\\n 19: dup\\n 20: ldc #11 // String BAR\\n 22: iconst_1\\n 23: bipush 42\\n 25: invokespecial #12 // Method TestEnum$1.\\\"<init>\\\":(Ljava/lang/String;II)V\\n 28: putstatic #13 // Field BAR:LTestEnum;\\n 31: new #5 // class TestEnum\\n 34: dup\\n 35: ldc #14 // String BAZ\\n 37: iconst_2\\n 38: ldc #15 // String SomeSystemProperty\\n 40: invokestatic #16 // Method java/lang/Integer.getInteger:(Ljava/lang/String;)Ljava/lang/Integer;\\n 43: invokevirtual #17 // Method java/lang/Integer.intValue:()I\\n 46: invokespecial #1 // Method \\\"<init>\\\":(Ljava/lang/String;II)V\\n 49: putstatic #18 // Field BAZ:LTestEnum;\\n // Setting up $VALUES\\n 52: iconst_3\\n 53: anewarray #5 // class TestEnum\\n 56: dup\\n 57: iconst_0\\n 58: getstatic #9 // Field FOO:LTestEnum;\\n 61: aastore\\n 62: dup\\n 63: iconst_1\\n 64: getstatic #13 // Field BAR:LTestEnum;\\n 67: aastore\\n 68: dup\\n 69: iconst_2\\n 70: getstatic #18 // Field BAZ:LTestEnum;\\n 73: aastore\\n 74: putstatic #2 // Field $VALUES:[LTestEnum;\\n // Other user-specified stuff\\n 77: getstatic #13 // Field BAR:LTestEnum;\\n 80: putstatic #19 // Field RECOMMENDED_VALUE:LTestEnum;\\n 83: return\\n }\\n \\\"\\\"\\\"\\n # We only care about the enum constants, not other random user stuff\\n # (such as RECOMMENDED_VALUE) or the $VALUES thing. Fortunately,\\n # ACC_ENUM helps us with this. It's worth noting that although MC's\\n # obfuscater gets rid of the field names, it does not get rid of the\\n # string constant for enum names (which is used by valueOf()), nor\\n # does it touch ACC_ENUM.\\n # For this method, we don't care about parameters other than the name.\\n if not cf.access_flags.acc_enum:\\n raise Exception(cf.this.name.value + \\\" is not an enum!\\\")\\n\\n enum_fields = list(cf.fields.find(f=lambda field: field.access_flags.acc_enum))\\n enum_class = None\\n enum_name = None\\n\\n result = {}\\n\\n for ins in cf.methods.find_one(name=\\\"<clinit>\\\").code.disassemble():\\n if ins == \\\"new\\\" and enum_class is None:\\n const = ins.operands[0]\\n enum_class = const.name.value\\n elif ins in (\\\"ldc\\\", \\\"ldc_w\\\") and enum_name is None:\\n const = ins.operands[0]\\n if isinstance(const, String):\\n enum_name = const.string.value\\n elif ins == \\\"putstatic\\\":\\n if enum_class is None or enum_name is None:\\n if verbose:\\n print(\\\"Ignoring putstatic for %s as enum_class or enum_name is unset\\\" % str(ins))\\n continue\\n const = ins.operands[0]\\n assigned_field = const.name_and_type\\n if not any(field.name == assigned_field.name and field.descriptor == assigned_field.descriptor for field in enum_fields):\\n # This could happen with an enum constant that sets a field in\\n # its constructor, which is unlikely but happens with e.g. this:\\n \\\"\\\"\\\"\\n enum Foo {\\n FOO(i = 2);\\n static int i;\\n private Foo(int n) {}\\n }\\n \\\"\\\"\\\"\\n if verbose:\\n print(\\\"Ignoring putstatic for %s as it is to a field not in enum_fields (%s)\\\" % (str(ins), enum_fields))\\n continue\\n result[enum_name] = {\\n 'name': enum_name,\\n 'field': assigned_field.name.value,\\n 'class': enum_class\\n }\\n enum_class = None\\n enum_name = None\\n\\n if len(result) == len(enum_fields):\\n break\\n\\n if verbose and len(result) != len(enum_fields):\\n print(\\\"Did not find assignments to all enum fields - fields are %s and result is %s\\\" % (result, enum_fields))\\n\\n return result\",\n \"def _build_all_enums(self):\\n uniq_enums = []\\n used_values = set()\\n enum_value_to_name_list = defaultdict(set) # key: int, value: list of strings (enum name\\n for enum in self.enum_list:\\n if enum in self.bitmask_enums:\\n continue\\n\\n if enum not in self.enum_name_to_value:\\n print(f'Notice: enum {enum} has no value')\\n continue\\n\\n if not self._enum_should_collect(enum):\\n continue\\n\\n value = self.enum_name_to_value[enum]\\n\\n enum_value_to_name_list[value].add(enum)\\n\\n if value in used_values:\\n continue\\n\\n uniq_enums.append((value, enum))\\n used_values.add(value)\\n\\n uniq_enums.sort()\\n\\n for value, enum in uniq_enums:\\n name_list = self._choose_enum_names(enum_value_to_name_list[value])\\n if name_list:\\n list_str = ' / '.join(name_list)\\n enum_value_str = self._case_value(enum)\\n case = f' case {enum_value_str}: return \\\"{list_str}\\\";'\\n self.all_enum_string_cases.append(case)\\n\\n self.map_make_entries.append(f' {{ \\\"{enum}\\\", {enum_value_str} }}')\",\n \"def convertToEnumItemArray(byte: int, enumType: cern.japc.value.EnumType) -> typing.List[cern.japc.value.EnumItem]:\\n ...\",\n \"def _generateResults_combosToBitmasks(self, all, want_combos):\\n names = {}\\n iter = enumerate(all)\\n try:\\n i, name = next(iter)\\n while True:\\n names[name] = (1 << i)\\n i, name = next(iter)\\n except StopIteration:\\n pass\\n print \\\"combosToBitmasks names:\\\", names\\n results = []\\n for combo in want_combos:\\n mask = 0\\n for name in combo:\\n if name in names:\\n mask |= names[name]\\n results.append(mask)\\n return results\",\n \"def to_list(bits: int) -> list[Position]:\\n positions = []\\n for r in range(8):\\n for c in range(8):\\n mask = pos_mask(r, c)\\n if bits & mask > 0:\\n positions.append(Position(r, c))\\n return positions\",\n \"def expand_mask(kind, value):\\n result = []\\n if value != 0:\\n mask_values = zip(spirv.spv[kind].values(), spirv.spv[kind].keys())\\n mask_values = sorted(mask_values, key=itemgetter(0))\\n for mask_number, mask_token in mask_values:\\n if (mask_number & value) != 0:\\n result.append(mask_token)\\n value = value ^ mask_number\\n if value != 0:\\n raise ParseError('Invalid mask value')\\n return result\",\n \"def set24_to_list(v):\\n return [x for x in range(24) if v & (1 << x)]\",\n \"def build_list_from_masks(cls, masks: Iterable[\\\"datacube_ows.styles.base.StyleMask\\\"],\\n layer: \\\"datacube_ows.ows_configuration.OWSNamedLayer\\\") -> List[\\\"FlagProductBands\\\"]:\\n flag_products = []\\n for mask in masks:\\n handled = False\\n for fp in flag_products:\\n if fp.products_match(mask.band.pq_names):\\n fp.add_flag_band(mask.band)\\n handled = True\\n break\\n if not handled:\\n flag_products.append(cls(mask.band, layer))\\n return flag_products\",\n \"def mask(self):\\n return list(self._mask_generator())\",\n \"def all_bits_list(vals, width=16):\\n return flatten_list([to_bit_list(val, width) for val in vals])\",\n \"def _build_enum_groups(self):\\n for group in self.used_enum_groups:\\n if group not in self.group_to_enum_list:\\n print(f'Warning: Enum group {group} has no values defined.')\\n continue\\n\\n group_type = 'basic'\\n if group in self.bitmask_groups:\\n group_type = 'bitmask'\\n\\n values_used = set()\\n enum_name_list = self.group_to_enum_list[group]\\n enum_tuple_list = []\\n for enum_name in enum_name_list:\\n if enum_name not in self.enum_list:\\n continue\\n\\n if enum_name not in self.enum_name_to_value:\\n print(f'Warning: enum {enum_name} has no value')\\n continue\\n\\n if not self._enum_should_collect(enum_name):\\n continue\\n\\n enum_value = self.enum_name_to_value[enum_name]\\n if enum_value not in values_used:\\n enum_value_str = self._case_value(enum_name)\\n enum_tuple_list.append((enum_value, enum_value_str, enum_name))\\n values_used.add(enum_value)\\n\\n if enum_name in self.bitmask_enums:\\n group_type = 'bitmask'\\n\\n enum_tuple_list.sort()\\n\\n group_max_len = 0\\n for enum_info in enum_tuple_list:\\n wrapper_enum_value_name = enum_info[2][3:].lower()\\n if wrapper_enum_value_name in RESERVED_NAMES:\\n wrapper_enum_value_name = wrapper_enum_value_name + '_'\\n if len(wrapper_enum_value_name) > group_max_len:\\n group_max_len = len(wrapper_enum_value_name)\\n\\n group_enum_string_entries = []\\n group_enum_to_base_zero_entries = []\\n base_zero_to_group_enum_entries = []\\n group_wrapper_enum_value_definitions = []\\n base_zero_value = 0\\n\\n for enum_info in enum_tuple_list:\\n wrapper_enum_value_name = enum_info[2][3:].lower()\\n\\n if wrapper_enum_value_name in RESERVED_NAMES:\\n wrapper_enum_value_name = wrapper_enum_value_name + '_'\\n\\n formatting = {\\n 'ENUM_VALUE': enum_info[1],\\n 'ENUM_STRING': enum_info[2],\\n 'ENUM_BASE_ZERO_VALUE': base_zero_value,\\n 'ENUM_VERSION': self._enum_version(enum_info[2]),\\n 'WRAPPER_ENUM_TYPE_NAME': self.to_type_name(group),\\n 'WRAPPER_ENUM_VALUE_NAME': wrapper_enum_value_name,\\n }\\n\\n string_entry = templates.ENUM_STRING_MAKE_ENTRY[group_type].format(**formatting)\\n group_enum_string_entries.append(string_entry)\\n group_wrapper_enum_value_definitions.append(\\n ' {:{}} = {:>6}u /* {} */'.format(\\n wrapper_enum_value_name,\\n group_max_len,\\n enum_info[1],\\n self._enum_version(enum_info[2])))\\n\\n if group_type == 'basic':\\n group_enum_to_base_zero_make_entry = templates.ENUM_TO_BASE_ZERO_MAKE_ENTRY.format(**formatting)\\n base_zero_to_group_enum_make_entry = templates.BASE_ZERO_TO_ENUM_MAKE_ENTRY.format(**formatting)\\n group_enum_to_base_zero_entries.append(group_enum_to_base_zero_make_entry)\\n base_zero_to_group_enum_entries.append(base_zero_to_group_enum_make_entry)\\n base_zero_value = base_zero_value + 1\\n\\n if enum_tuple_list:\\n wrapper_enum_name = self.to_type_name(group)\\n definitions = ',\\\\n'.join(sorted(group_wrapper_enum_value_definitions))\\n string_entries = '\\\\n'.join(sorted(group_enum_string_entries))\\n formatting = {\\n 'WRAPPER_ENUM_TYPE_NAME': wrapper_enum_name,\\n 'WRAPPER_ENUM_STRING_FN_NAME': self.split_to_body_and_ext(group)[0],\\n 'GROUP_NAME': group,\\n 'WRAPPER_ENUM_VALUE_DEFINITIONS': definitions,\\n 'GROUP_ENUM_STRING_ENTRIES': string_entries,\\n 'GROUP_ENUM_TO_BASE_ZERO_ENTRIES': '\\\\n'.join(group_enum_to_base_zero_entries),\\n 'BASE_ZERO_TO_GROUP_ENUM_ENTRIES': '\\\\n'.join(base_zero_to_group_enum_entries),\\n }\\n\\n if group_type == 'basic':\\n self.enum_to_base_zero_function_declarations.append(\\n templates.ENUM_TO_BASE_ZERO_FUNCTION_DECLARATION.format(**formatting)\\n )\\n self.base_zero_to_enum_function_declarations.append(\\n templates.BASE_ZERO_TO_ENUM_FUNCTION_DECLARATION.format(**formatting)\\n )\\n self.enum_base_zero_function_definitions.append(\\n templates.ENUM_BASE_ZERO_FUNCTION_DEFINITION.format(**formatting)\\n )\\n self.untyped_enum_string_function_declarations.append(\\n templates.UNTYPED_ENUM_STRING_FUNCTION_DECLARATION.format(**formatting)\\n )\\n self.untyped_enum_string_function_definitions.append(\\n templates.UNTYPED_ENUM_STRING_FUNCTION_DEFINITION.format(**formatting)\\n )\\n\\n self.enum_string_function_declarations.append(\\n templates.ENUM_STRING_FUNCTION_DECLARATION[group_type].format(**formatting)\\n )\\n self.enum_string_function_definitions.append(\\n templates.ENUM_STRING_FUNCTION_DEFINITION[group_type].format(**formatting)\\n )\\n self.wrapper_enum_declarations.append(\\n templates.WRAPPER_ENUM_DECLARATION.format(**formatting)\\n )\\n self.enum_helper_definitions.append(\\n templates.ENUM_HELPER_DEFINITION[group_type].format(**formatting)\\n )\",\n \"def bitModeToEnum(bitMode):\\n bits = {\\n 0: CORR_2BIT,\\n 1: CORR_3BIT,\\n 2: CORR_4BIT\\n }\\n return bits[bitMode]\",\n \"def box_flags(self, box):\\n return [flag for flag in self.flags if flag.box == box]\",\n \"def GetActuatorsWithStatus(status_flags, status_helper, status_to_check):\\n\\n flag = 0\\n for status in status_to_check:\\n flag |= status_helper.Value(status)\\n return [key for key, value in status_flags.iteritems() if value & flag]\",\n \"def getFlags(flagbyte, *positions):\\n return [getFlag(flagbyte, pos) for pos in positions]\",\n \"def parse_mask(mask):\\n mask_dict = dict()\\n for i, val in enumerate(mask):\\n mask_dict[i] = val\\n\\n return mask_dict\",\n \"def decode_flags(flags):\\n if isinstance(flags, six.string_types):\\n flags = int(flags.lstrip('@'), 16)\\n return [name for i, name in enumerate(flag_names) if (1 << i) & flags]\",\n \"def flags(self):\\n flags = self.Flags\\n return [x for x in self.FLAGS_VALUES if flags & x]\",\n \"def convertToEnumItem(boolean: bool) -> cern.japc.value.EnumItem:\\n ...\",\n \"def handle_enum(enum_annotations: Any) -> list:\\n result = []\\n for attribute in list(enum_annotations):\\n result.append(attribute.value)\\n return result\",\n \"def _all_labels_to_bitmasks(all_labels):\\n l_dict = {}\\n for i, label in enumerate(all_labels):\\n l_dict[label.name] = 1<<i\\n return l_dict\",\n \"def availableValues(self):\\n return [x.name for x in self._field.enum_type.values]\",\n \"def bitlist(n):\\n return [n >> i & 1 for i in range(7,-1,-1)]\",\n \"def getmask(\\n self, mask: Union[List[dd.Series], UserList], inverse: bool = False\\n ) -> List[dd.Series]:\\n output = []\\n for data, cond in zip(self.data, mask):\\n if inverse:\\n output.append(data[~cond])\\n else:\\n output.append(data[cond])\\n\\n return output\",\n \"def get_all_flags(options):\\n flags = []\\n if options.inputFlag:\\n flags.append(try_to_int(options.inputFlag))\\n if options.outputFlags:\\n for flag in options.outputFlags:\\n flags.append(try_to_int(flag))\\n return flags\",\n \"def list_available_enum(enum_type: Type[Enum]) -> List[str]:\\n return [f\\\"{i}: {v}\\\" for (i, v) in enumerate(enum_type)] # type: ignore[var-annotated]\",\n \"def flags(cls):\\n\\n assert cls.__bases__ == (object,)\\n\\n d = dict(cls.__dict__)\\n new_type = type(cls.__name__, (int,), d)\\n new_type.__module__ = cls.__module__\\n\\n map_ = {}\\n for key, value in iteritems(d):\\n if key.upper() == key and isinstance(value, integer_types):\\n value_instance = new_type(value)\\n setattr(new_type, key, value_instance)\\n map_[value] = key\\n\\n def str_(self):\\n value = int(self)\\n matches = []\\n for k, v in map_.items():\\n if value & k:\\n matches.append(\\\"%s.%s\\\" % (type(self).__name__, v))\\n value &= ~k\\n if value != 0 or not matches:\\n matches.append(text_type(value))\\n\\n return \\\" | \\\".join(matches)\\n\\n def repr_(self):\\n return \\\"<%s: %d>\\\" % (str(self), int(self))\\n\\n setattr(new_type, \\\"__repr__\\\", repr_)\\n setattr(new_type, \\\"__str__\\\", str_)\\n\\n return new_type\",\n \"def create_basic_flag_mask(*flags):\\n\\n out = np.ones(len(flags[0]), bool)\\n for flag in flags:\\n out &= (~flag)\\n\\n return out\",\n \"def flags(self):\\n return list(self._flags_generator())\",\n \"def choices(cls):\\n # return list(map(tuple, cls.__members__.items()))\\n return [(int(code), name) for name, code in cls.__members__.items()]\",\n \"def mapping_for_enum(mapping):\\n return dict(mapping.keys())\",\n \"def as_name_list(cls, lower=True, **kwargs):\\n return cls.enum_class.as_name_list(lower=lower, **kwargs)\",\n \"def decode(self, emissions: torch.Tensor,\\n mask: Optional[torch.ByteTensor] = None) -> List[List[int]]:\\n if mask is None:\\n mask = emissions.new_ones(emissions.shape[:2], dtype=torch.uint8)\\n\\n return self._viterbi_decode(emissions, mask)\",\n \"def __iter__(self):\\n return iter(self._enums)\",\n \"def enum(cls, options, values):\\r\\n names, real = zip(*options)\\r\\n del names # unused\\r\\n\\r\\n def factory(i, name):\\r\\n return cls(i, name, (len(real),), lambda a: real[a[0]], values)\\r\\n return factory\",\n \"def get_flags(self):\\n\\n if self.raw.flags not in [0, 1, 2, 3]:\\n raise ValueError(\\\"Invalid raw flags: {}\\\".format(self.raw.flags))\\n\\n flags = set()\\n\\n if (self.raw.flags & 0b010) > 0:\\n flags.add(\\\"DF\\\")\\n\\n if (self.raw.flags & 0b001) > 0:\\n flags.add(\\\"MF\\\")\\n\\n return frozenset(flags)\",\n \"def tenum(name, vals):\\n\\n if isinstance(vals, basestring):\\n vals = vals.split()\\n sort, consts = z3.EnumSort(name, vals)\\n fields = dict(zip(vals, consts))\\n fields[\\\"_z3_sort\\\"] = sort\\n return type(name, (SEnumBase, SymbolicVal), fields)\",\n \"def make_class_masks(subject_names):\\n masks = Munch()\\n\\n masks.has_dash = subject_names.apply(test_dash_in)\\n masks.first_alpha = subject_names.apply(test_starts_letter)\\n masks.last_alpha = subject_names.apply(test_ends_letter)\\n\\n return masks\",\n \"def process_result_value(self, value, dialect):\\n masks = list()\\n if value:\\n for e in enums.CryptographicUsageMask:\\n if e.value & value:\\n masks.append(e)\\n return masks\",\n \"def _GetContactNoticeEnum(domains_messages):\\n return domains_messages.ConfigureContactSettingsRequest.ContactNoticesValueListEntryValuesEnum\",\n \"def enum_names(self):\\n return [enum.name for enum in self]\",\n \"def _string_to_bitlist(self, data):\\n l = len(data) * 8\\n result = [0] * l\\n pos = 0\\n for ch in data:\\n i = 7\\n while i >= 0:\\n # bit-wise operation\\n if ch & (1 << i) != 0:\\n result[pos] = 1\\n else:\\n result[pos] = 0\\n pos += 1\\n i -= 1\\n return result\",\n \"def enums(self) -> Mapping[str, wrappers.EnumType]:\\n return collections.ChainMap({},\\n *[p.all_enums for p in self.protos.values()],\\n )\",\n \"def _decode_mask(mask: dict):\\n bitmask = mask.get('mask')\\n mem_dict = {key: val for key, val in mask.items() if not key == 'mask'}\\n new_mem_dict = dict()\\n\\n for mem in mem_dict.items():\\n bit_str = BIT_FORMAT.format(mem[1])\\n result_str = ''\\n\\n for i in range(len(bit_str)):\\n new_bit = bit_str[i] if bitmask[i] == 'X' else bitmask[i]\\n result_str += new_bit\\n\\n new_mem_dict[mem[0]] = int(result_str, 2)\\n\\n return new_mem_dict\",\n \"def enum(**enums):\\n return type('Enum',(),enums)\",\n \"def unmask(self, mask, verbose=0):\\n if isinstance(mask, str): # Woodstock-style string mask format\\n mask = tuple(re.sub('\\\\s+', ' ', mask).lower().split(' '))\\n assert len(mask) == self.nthemes # must be bad mask if wrong theme count\\n else:\\n try:\\n assert isinstance(mask, tuple) and len(mask) == self.nthemes\\n except:\\n print(len(mask), type(mask), mask)\\n assert False\\n dtype_keys = copy.copy(list(self.dtypes.keys())) # filter this\\n for ti, tac in enumerate(mask):\\n if tac == '?': continue # wildcard matches all\\n tacs = self._expand_theme(self._themes[ti], tac, verbose=verbose) if tac in self._themes[ti] else []\\n dtype_keys = [dtk for dtk in dtype_keys if dtk[ti] in tacs] # exclude bad matches\\n return dtype_keys\",\n \"def with_mask(self, mask):\\n return self[mask]\",\n \"def bits_list(number):\\n\\n # https://wiki.python.org/moin/BitManipulation\\n if number == 0:\\n return [0]\\n else:\\n # binary_literal string e.g. '0b101'\\n binary_literal = bin(number)\\n bits_string = binary_literal.lstrip('0b')\\n # list comprehension\\n bits = [int(bit_character) for bit_character in bits_string]\\n return bits\",\n \"def from_python_enum_direct_values(cls, enum, name=None):\\n if name is None:\\n name = enum.__name__\\n return cls(name, [EnumValue(v.name, python_value=v.value) for v in enum])\",\n \"def encode_flags(names):\\n return reduce(operator.ior, (flag_masks[name] for name in names), 0)\",\n \"def bits(byte: int) -> Sequence[bool]:\\n assert byte < 0x100\\n return [bool(byte & mask) for mask in bit_masks]\",\n \"def _regex_flags_from_bits(self, bits):\\n flags = 'tilmsux'\\n return ''.join(flags[i] if (1 << i) & bits else '' for i in xrange(6))\",\n \"def enums(self):\\n return self._enums\",\n \"def enum(*sequential, **named):\\n enums = dict(zip(sequential, range(len(sequential))), **named)\\n return type('Enum', (), enums)\",\n \"def enum(*sequential, **named):\\n enums = dict(zip(sequential, range(len(sequential))), **named)\\n return type('Enum', (), enums)\",\n \"def enum(*sequential, **named):\\n enums = dict(zip(sequential, range(len(sequential))), **named)\\n return type('Enum', (), enums)\",\n \"def enum(*sequential, **named):\\n enums = dict(zip(sequential, range(len(sequential))), **named)\\n return type('Enum', (), enums)\",\n \"def _GetContactPrivacyEnum(domains_messages):\\n return domains_messages.ContactSettings.PrivacyValueValuesEnum\",\n \"def _fromflagname(cls, name:str, default=...) -> enum.Enum:\\n if default is not Ellipsis:\\n return cls._LOOKUP.get(name, default)\\n return cls._LOOKUP[name]\",\n \"def makeListOfEnabledEvents(gcauCfgDict):\\r\\n OBJ_NAME = \\\"SYSVAR\\\"\\r\\n OBJ_ATTR = \\\"EventEnable\\\"\\r\\n list = []\\r\\n try:\\r\\n obj = gcauCfgDict[OBJ_NAME]\\r\\n try:\\r\\n mask = int(obj[OBJ_ATTR], 16)\\r\\n except KeyError:\\r\\n raise AgcAttrException(\\\"{0} misses: {1}\\\"\\\\\\r\\n .format(jeep.defGetMyName(), OBJ_ATTR))\\r\\n else:\\r\\n n = 1\\r\\n while mask != 0:\\r\\n if mask % 2:\\r\\n list.append(n)\\r\\n mask = mask >> 1\\r\\n n = n + 1 \\r\\n except KeyError:\\r\\n raise AgcObjException(\\\"{0} mises: {1}\\\"\\\\\\r\\n .format(jeep.defGetMyName(), OBJ_NAME))\\r\\n return list\",\n \"def construct_by_element_mask(cls, mask):\\n mask = np.asarray(mask)\\n ue = np.unique(mask)\\n if not (len(mask.shape) == 2 and len(ue) == 2 and 0 in ue and 1 in ue):\\n raise ValueError(\\\"The mask matrix should be a 2d array, and there must be only \\\"\\n \\\"1 and 0 in the matrix, in which, 1 means the corresponding \\\"\\n \\\"element is known, and will be added to the MultiLabelIndexCollection container.\\\")\\n\\n nz_row, nz_col = np.nonzero(mask)\\n return cls(data=[(nz_row[i], nz_col[i]) for i in range(len(nz_row))], label_size=mask.shape[1])\",\n \"def __get_bit_values(self, number, size=32):\\n res = list(self.__gen_bit_values(number))\\n res.reverse()\\n # 0-pad the most significant bit\\n res = [0] * (size - len(res)) + res\\n return res\",\n \"def get_all_enums(schema_obj):\\n\\n enums = []\\n for vendor in schema_obj.vendor_list:\\n for typespace in vendor.typespace_list:\\n for enum in typespace.enum_list:\\n enums.append(enum)\\n for trait in vendor.trait_list:\\n for enum in trait.enum_list:\\n enums.append(enum)\\n for enum in vendor.enum_list:\\n enums.append(enum)\\n return enums\",\n \"def _GetTransferLockEnum(domains_messages):\\n return domains_messages.ManagementSettings.TransferLockStateValueValuesEnum\",\n \"def bitfield(x, m):\\n b = [1 if digit=='1' else 0 for digit in bin(x)[2:]]\\n for i in range(len(b), m):\\n b.insert(0, 0)\\n return b\",\n \"def to_list(self):\\n return [bits.value for bits in self.data]\",\n \"def test_should_return_a_list(self):\\n\\n tcp_flags = TCPControlBits(['SYN', 'ACK'])\\n assert_is_instance(tcp_flags.to_list(), list)\",\n \"def sequential_enum(*sequential, **named):\\n enums = dict(zip(sequential, range(len(sequential))), **named)\\n return type('Enum', (), enums)\",\n \"def bits(self):\\n return list(range(self.lsb, self.msb + 1))\",\n \"def makeCountriesEnumerationType (self):\\n\\t\\t# stub = getEnumerationTypeXmlStub (\\\"countriesType\\\")\\n\\t\\t# countriesVocab = AnnotatedEnumerationType (stub)\\n\\t\\tcountriesVocab = self.createEnumerationType (\\\"countriesType\\\");\\n\\t\\tcountry_codes = self.countryCodeMap.keys()\\n\\t\\tcountry_codes.sort()\\n\\t\\tdataList = map (lambda key: (key, self.countryCodeMap[key].name), country_codes)\\n\\t\\tcountriesVocab.setValues (dataList)\\n\\t\\treturn countriesVocab\",\n \"def convertMaskToWeights(mask):\\n vals = np.unique(mask)\\n for i in range(len(vals)):\\n mask[mask==vals[i]]=i\\n mask = mask.astype(int)\\n w = mask.ravel() \\n return w\",\n \"def list_flags(self):\\n return self._defs.items()\",\n \"def mask(self) -> list[int]:\\n return self._mask\",\n \"def build_mask(mask, unused_features_positions):\\n\\tfinal_mask = mask.tolist()\\n\\n\\tfor i in range(len(unused_features_positions)):\\n\\t\\tif not unused_features_positions[i]:\\n\\t\\t\\tfinal_mask.insert(i, False)\\n\\n\\treturn final_mask\",\n \"def decode_aurafilter(aurafilter: int) -> Tuple[List[str], _Hex]:\\n af_names = []\\n for name, flag in AURAFILTER_FLAGS.items():\\n if aurafilter & flag:\\n aurafilter &= ~flag\\n af_names.append(name)\\n return af_names, _Hex(aurafilter)\",\n \"def build_semantic_masks(self):\\n with tf.variable_scope(\\\"build_semantic_masks\\\"):\\n dynamic_tgt_mask = self.__priors\\n static_tgt_mask = 1.0 - dynamic_tgt_mask\\n return dynamic_tgt_mask, static_tgt_mask\",\n \"def makeMaskFromArray(array):\\n if array is None: return None\\n cls = globals()[\\\"Mask%s\\\" % suffixes[str(array.dtype.type)]]\\n return cls(array)\",\n \"def mask2categorical(Mask: tf.Tensor, labels: dict) -> tf.Tensor:\\n assert type(labels) == dict, \\\"labels variable should be a dictionary\\\"\\n\\n X = Mask\\n\\n if X.dtype == \\\"float32\\\":\\n X = tf.cast(X*255, dtype=\\\"uint8\\\")\\n\\n Y = tf.zeros(X.shape[0:2] , dtype=\\\"float32\\\")\\n for i, key in enumerate(labels):\\n Y = tf.where(np.all(X == labels[key], axis=-1), i, Y)\\n Y = tf.cast(Y, dtype=\\\"uint8\\\")\\n return Y\",\n \"def listFlag(flaglist):\\n flag = 0\\n for index, item in enumerate(flaglist):\\n flag = setFlag(flag, index, item)\\n return flag\",\n \"def process_flags(self):\\n\\t\\tsflags = []\\n\\t\\tfor attr in dir(self):\\n\\t\\t\\tif attr[:3] != \\\"PF_\\\":\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tvalue = getattr(self, attr)\\n\\t\\t\\tif value & self.fields[\\\"flags\\\"]:\\n\\t\\t\\t\\tsflags.append(attr)\\n\\n\\t\\treturn sflags\",\n \"def enumerate_flags(flag, f_map):\\r\\n # Reset string based flags to null\\r\\n f_type = ''\\r\\n f_flag = ''\\r\\n # Iterate through flags\\r\\n for i in f_map:\\r\\n if i & flag:\\r\\n if f_map[i] == 'FolderEvent;' or \\\\\\r\\n f_map[i] == 'FileEvent;' or \\\\\\r\\n f_map[i] == 'SymbolicLink;' or \\\\\\r\\n f_map[i] == 'HardLink;':\\r\\n f_type = ''.join([f_type, f_map[i]])\\r\\n else:\\r\\n f_flag = ''.join([f_flag, f_map[i]])\\r\\n return f_type, f_flag\",\n \"def __gen_bit_values(number):\\n number = int(number)\\n while number:\\n yield number & 0x1\\n number >>= 1\",\n \"def __init__(self, eset, flags=None):\\n\\n # Store the EnumSet\\n self.eset = eset\\n\\n # Initialize the flags\\n self.bitflags = 0\\n self.flags = set()\\n\\n # Routine to call if we're modified\\n self._notify = None\\n\\n # Process the flags that were set\\n if isinstance(flags, six.integer_types):\\n for opt in eset:\\n if flags & int(opt):\\n self.bitflags |= int(opt)\\n self.flags.add(str(opt))\\n\\n # Make sure we got them all\\n if self.bitflags != flags:\\n raise TypeError(\\n 'Unable to find enumeration values for 0x%x' %\\n (flags & ~self.bitflags)\\n )\\n elif isinstance(flags, six.string_types):\\n try:\\n opt = eset[flags]\\n except KeyError:\\n raise TypeError(\\n 'Unable to find enumeration value for flag \\\\\\\"%s\\\\\\\"' % flags\\n )\\n\\n self.bitflags |= int(opt)\\n self.flags.add(str(opt))\\n elif flags is not None:\\n for flag in flags:\\n try:\\n opt = eset[flag]\\n except KeyError:\\n raise TypeError(\\n 'Unable to find enumeration value for flag \\\\\\\"%s\\\\\\\"' %\\n flag\\n )\\n\\n self.bitflags |= int(opt)\\n self.flags.add(str(opt))\",\n \"def _fixed_masks_arg(mask):\\n return [\\\"NULL\\\", mask]\",\n \"def generate_list(self):\\n\\n array = [False] * 25\\n bits = self.generate_bits()\\n\\n for column in range(2, -1, -1):\\n for row in range(0, 5):\\n bit = next(bits)\\n\\n array[column + (row * 5)] = bit\\n array[(4 - column) + (row * 5)] = bit\\n\\n return array\",\n \"def _enumerate_message(self, name, message_class):\\n key_value_pair = []\\n assert(message_class is not None) \\n assert(dir(message_class) is not None) \\n \\n # TODO: to review, hack\\n for key in dir(message_class):\\n if key.isupper():\\n \\n # set the class attributes to the Enum values\\n key_value_pair.append((key, getattr(message_class, key)))\\n \\n return Enum(name, key_value_pair)\",\n \"def IntEnum(name, keys, start=1):\\n return IntEnumBase(name,\\n [(key, index) for index, key in enumerate(keys, start=start)])\",\n \"def get_bitmask(self):\\r\\n return self.__bitmask__\",\n \"def values (root, ignore_access_errors=False, _want_types=False):\\n root = registry (root, accept_value=False)\\n try:\\n hKey = root.pyobject ()\\n except exc.x_access_denied:\\n if ignore_access_errors:\\n raise StopIteration\\n else:\\n raise\\n\\n values = []\\n i = 0\\n while True:\\n try:\\n name, value, type = wrapped (win32api.RegEnumValue, hKey, i)\\n if _want_types:\\n yield name, value, type\\n else:\\n yield name, value\\n except exc.x_access_denied:\\n if ignore_access_errors:\\n raise StopIteration\\n else:\\n raise\\n i += 1\",\n \"def readEnumTypes(self):\\n types = {}\\n for m in re.finditer(\\\"TYPE (\\\\w*) = ENUMERATION OF\\\\s*\\\\(([\\\\,\\\\w\\\\_\\\\s]*)\\\\);\\\\s*END_TYPE;\\\", self.data, re.DOTALL):\\n typename, types_enum_string = m.groups() \\n typestring = re.sub('\\\\s', '', types_enum_string)\\n types[typename] = typestring.split(',')\\n \\n return types\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69542855","0.6844899","0.6179964","0.6085858","0.60515696","0.58843184","0.5866593","0.5610187","0.5600955","0.5540577","0.54730654","0.5454916","0.5427376","0.538644","0.5377461","0.5375424","0.5373737","0.5363888","0.5209238","0.5204924","0.51944685","0.5176985","0.51642734","0.5157373","0.5152311","0.5151899","0.51471543","0.5144892","0.51401937","0.50915664","0.5084801","0.5081372","0.5053606","0.50512475","0.50445384","0.50239503","0.4973072","0.49720553","0.49714917","0.49665847","0.49616313","0.49354714","0.4920768","0.49066103","0.49010962","0.48889664","0.48861083","0.48810482","0.48745957","0.48368964","0.48350286","0.48226896","0.48171288","0.48116955","0.4782012","0.477966","0.4765856","0.47655064","0.47624308","0.4754077","0.47488335","0.4743212","0.4742986","0.4734184","0.4734184","0.4734184","0.4734184","0.4721407","0.47177035","0.47142997","0.46911344","0.46825823","0.4680512","0.46774882","0.46705735","0.46580753","0.4655768","0.46553296","0.46428064","0.46418428","0.4638156","0.46306524","0.4620859","0.4620681","0.46195775","0.46058738","0.46047682","0.4599884","0.45958322","0.45946607","0.4577981","0.4577289","0.4575321","0.45718092","0.4571356","0.45674765","0.45620918","0.4561854","0.45555824","0.4551748"],"string":"[\n \"0.69542855\",\n \"0.6844899\",\n \"0.6179964\",\n \"0.6085858\",\n \"0.60515696\",\n \"0.58843184\",\n \"0.5866593\",\n \"0.5610187\",\n \"0.5600955\",\n \"0.5540577\",\n \"0.54730654\",\n \"0.5454916\",\n \"0.5427376\",\n \"0.538644\",\n \"0.5377461\",\n \"0.5375424\",\n \"0.5373737\",\n \"0.5363888\",\n \"0.5209238\",\n \"0.5204924\",\n \"0.51944685\",\n \"0.5176985\",\n \"0.51642734\",\n \"0.5157373\",\n \"0.5152311\",\n \"0.5151899\",\n \"0.51471543\",\n \"0.5144892\",\n \"0.51401937\",\n \"0.50915664\",\n \"0.5084801\",\n \"0.5081372\",\n \"0.5053606\",\n \"0.50512475\",\n \"0.50445384\",\n \"0.50239503\",\n \"0.4973072\",\n \"0.49720553\",\n \"0.49714917\",\n \"0.49665847\",\n \"0.49616313\",\n \"0.49354714\",\n \"0.4920768\",\n \"0.49066103\",\n \"0.49010962\",\n \"0.48889664\",\n \"0.48861083\",\n \"0.48810482\",\n \"0.48745957\",\n \"0.48368964\",\n \"0.48350286\",\n \"0.48226896\",\n \"0.48171288\",\n \"0.48116955\",\n \"0.4782012\",\n \"0.477966\",\n \"0.4765856\",\n \"0.47655064\",\n \"0.47624308\",\n \"0.4754077\",\n \"0.47488335\",\n \"0.4743212\",\n \"0.4742986\",\n \"0.4734184\",\n \"0.4734184\",\n \"0.4734184\",\n \"0.4734184\",\n \"0.4721407\",\n \"0.47177035\",\n \"0.47142997\",\n \"0.46911344\",\n \"0.46825823\",\n \"0.4680512\",\n \"0.46774882\",\n \"0.46705735\",\n \"0.46580753\",\n \"0.4655768\",\n \"0.46553296\",\n \"0.46428064\",\n \"0.46418428\",\n \"0.4638156\",\n \"0.46306524\",\n \"0.4620859\",\n \"0.4620681\",\n \"0.46195775\",\n \"0.46058738\",\n \"0.46047682\",\n \"0.4599884\",\n \"0.45958322\",\n \"0.45946607\",\n \"0.4577981\",\n \"0.4577289\",\n \"0.4575321\",\n \"0.45718092\",\n \"0.4571356\",\n \"0.45674765\",\n \"0.45620918\",\n \"0.4561854\",\n \"0.45555824\",\n \"0.4551748\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.81864226"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93187,"cells":{"query":{"kind":"string","value":"A utility function that checks if the provided value is a composite bit mask of enumeration values in the specified enumeration class."},"document":{"kind":"string","value":"def is_bit_mask(enumeration, potential_mask):\n if not isinstance(potential_mask, six.integer_types):\n return False\n\n mask_enumerations = (\n CryptographicUsageMask,\n ProtectionStorageMask,\n StorageStatusMask\n )\n if enumeration not in mask_enumerations:\n return False\n\n mask = 0\n for value in [e.value for e in enumeration]:\n if (value & potential_mask) == value:\n mask |= value\n\n if mask != potential_mask:\n return False\n\n return 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 is_enum_value(enumeration, potential_value):\n try:\n enumeration(potential_value)\n except ValueError:\n return False\n\n return True","def get_enumerations_from_bit_mask(enumeration, mask):\n return [x for x in enumeration if (x.value & mask) == x.value]","def _is_equal_to_enumatom(self, enumatom):\n\n return (self.enum == enumatom.enum and self.shape == enumatom.shape\n and np.all(self.dflt == enumatom.dflt)\n and self.base == enumatom.base)","def is_enum(self):\n return self.is_complex and not self.is_class","def _check_enum(\n enum_class: 'settings_enums.SettingsEnumType'\n ) -> 'ScalarTypes':\n if not issubclass(enum_class, enum.Enum):\n raise TypeError('{} is not an Enum'.format(enum_class))\n\n instances: 'List[settings_enums.SettingsEnum]' = list(enum_class)\n enum_type = type(instances[0].value)\n\n for instance in instances:\n if not isinstance(instance.value, enum_type):\n raise TypeError('enum {} uses mixed types {} and {}'.format(\n enum_class, enum_type, type(instance)))\n\n if enum_type not in _TYPE_MAP:\n raise TypeError(\n '{} (underlying type of {}) is not a valid setting type'.format(\n enum_type, enum_class))\n\n return enum_type","def from_value(cls, value):\n value = value if value else 0\n try:\n flags = [flag.name for flag in cls.enum_class if flag.value & value]\n except TypeError:\n flags = [flag.name for flag in cls.enum_class if flag.name == value]\n\n return cls(*flags)","def is_boost_enum(obj: Any) -> bool:\n for cls in type(obj).__bases__:\n if \"Boost.Python.enum\" in str(cls):\n return True\n return False","def has_valid_channel_values(rgb_coll):\n return all([is_0to255(c) and is_int(c) for c in rgb_coll])","def is_enum(schema_obj):\n\n return (isinstance(schema_obj, schema.Enum) or\n (isinstance(schema_obj, schema.Field) and schema_obj.enum_type))","def check_enum(enumerator, value):\n is_valid = False\n for data in enumerator:\n if data == value:\n is_valid = True\n break\n\n if is_valid:\n return value\n else:\n my_banner(\"Value must be from enum \" + enumerator +\" Value has been set to N/A\")\n return \"na\"","def get_bit_mask_from_enumerations(enumerations):\n return functools.reduce(\n lambda x, y: x | y, [z.value for z in enumerations]\n )","def check_enumeration_style(ctx, stmt):\n elemtype = stmt.search_one(\"type\")\n if elemtype is None or elemtype.arg != \"enumeration\":\n return\n\n for enum in elemtype.search(\"enum\"):\n if re.match(r\"[a-z]\", enum.arg):\n err_add(ctx.errors, stmt.pos, \"OC_ENUM_CASE\",\n (enum.arg, enum.arg.upper().replace(\"-\", \"_\")))\n elif not re.match(r\"^[A-Z0-9][A-Z0-9\\_\\.]{0,}$\", enum.arg):\n err_add(ctx.errors, stmt.pos, \"OC_ENUM_UNDERSCORES\",\n (enum.arg, enum.arg.upper().replace(\"-\", \"_\")))","def enum_check(*args, func=None):\n func = func or inspect.stack()[2][3]\n for var in args:\n if not isinstance(var, (enum.EnumMeta, aenum.EnumMeta)):\n name = type(var).__name__\n raise EnumError(\n 'Function {} expected enumeration, {} got instead.'.format(func, name))","def is_mutually_bit_compatible_with(self, other: 'CompositeType') -> bool:\n return self.bit_length_set == other.bit_length_set","def test_bitmask(self, bit):\r\n if (int((format(self.__bitmask__, '016b')[2:])[bit]) == 0):\r\n return True\r\n return False","def __contains__(self, flag):\n\n if isinstance(flag, six.integer_types):\n # Pretty easy\n return (self.bitflags & flag) == flag\n elif isinstance(flag, six.string_types):\n # Simple string\n return flag in self.flags\n else:\n try:\n # Make sure all the specified flags are present\n return all(str(self.eset[fl]) in self.flags\n for fl in flag)\n except KeyError:\n return False","def test_get_enum_by_value():\n assert BusinessType.get_enum_by_value('CP') == BusinessType.COOPERATIVE\n assert BusinessType.get_enum_by_value('FM') == BusinessType.PARTNERSHIP_AND_SOLE_PROP\n assert BusinessType.get_enum_by_value('NOT_FOUND') is None","def mask_check(mask):\n if isinstance(mask, u.Quantity):\n if not (mask.unit == u.dimensionless_unscaled):\n raise TypeError(\n \"Mask should not be a non-dimensionless and unscaled Quantity!\"\n )\n mask = mask.value\n\n # Check for values of mask\n if np.any(mask > 1) or np.any(mask < 0):\n raise ValueError(\"Mask should be within range from 0 to 1 only.\")","def is_valid_color(value):\n if is_str(value):\n return is_hex_string(value)\n elif is_tuple_or_list(value):\n return (is_tuple_or_list(value)\n and is_three_channeled(value)\n and has_valid_channel_values(value))\n else:\n return is_str_or_coll(value)","def is_reaction_class(rxn_class):\n return rxn_class in _values(ReactionClass.Typ)","def parse_mask(value, mask_enum):\n masks = []\n for mask in mask_enum:\n if value & mask:\n masks.append(mask.name)\n value ^= mask\n if value:\n masks.append(hex(value))\n\n return masks","def bases_mask_is_valid(bases_mask):\n try:\n for read in bases_mask.upper().split(','):\n if not re.match(r'^([IY][0-9]+|[IY]*)(N[0-9]+|N*)$',read):\n return False\n return True\n except AttributeError:\n return False","def test_enum_detection():\n\n grammar = \"\"\"\n IsEnum: \"keyword1\" | \"keyword2\" | \"keyword3\";\n IsNotEnum: val=\"keyword1\" | val=\"keyword2\" | val=\"keyword3\";\n StillNotEnum: val=\"keyword1\" | \"keyword2\" | \"keyword3\";\n\n // identified as EDatatype with object type\n NotEnumAgain: SubEnum | SubEnum2;\n\n // this is an enumeration\n SubEnum: \"keyword1\" | \"keyword2\";\n SubEnum2: \"keyword3\" | \"keyword4\";\n \"\"\"\n\n mm = metamodel_from_str(grammar)\n\n IsEnum = mm['IsEnum']\n assert isinstance(IsEnum, ecore.EEnum)\n assert IsEnum.name == 'IsEnum'\n assert all((x in IsEnum for x in (\"keyword1\", \"keyword2\", \"keyword3\")))\n\n IsNotEnum = mm['IsNotEnum']\n assert IsNotEnum.name == 'IsNotEnum'\n assert isinstance(IsNotEnum, ecore.EClass)\n\n StillNotEnum = mm['StillNotEnum']\n assert StillNotEnum.name == 'StillNotEnum'\n assert isinstance(StillNotEnum, ecore.EClass)\n\n NotEnumAgain = mm['NotEnumAgain']\n assert isinstance(NotEnumAgain, ecore.EDataType)\n assert NotEnumAgain.name == 'NotEnumAgain'\n\n SubEnum = mm['SubEnum']\n assert isinstance(SubEnum, ecore.EEnum)\n assert SubEnum.name == 'SubEnum'\n assert all((x in IsEnum for x in (\"keyword1\", \"keyword2\")))","def is_enum(self):\n return False","def is_bits(self, argno: Union[int, Tuple[int, ...]]) -> '_Checker':\n if isinstance(argno, tuple):\n for a in argno:\n self.is_bits(a)\n return self\n\n t = self.arg_types[argno]\n if not isinstance(t, BitsType):\n raise XlsTypeError(self.span, t, None,\n 'Want argument {} to be bits; got {}'.format(argno, t))\n return self","def check_enum(self, name, values):\n v = self.__dict__.get(name)\n if v not in values:\n raise ValueError(\n \"Invalid value: {0}='{1}', not in '{2}'\".format(name, v, values))","def is_composite_or_composite_value(tensor):\n # TODO(b/125094323): This should be isinstance(CompositeTensor) or\n # isinstance(CompositeTensorValue) once we support that.\n return isinstance(\n tensor,\n (composite_tensor.CompositeTensor, sparse_tensor.SparseTensorValue,\n ragged_tensor_value.RaggedTensorValue))","def getClassMask(self, rgb, im):\n # Colour mask\n if len(rgb) == 3:\n r, g, b = rgb\n r_mask = im[:,:, 0] == r\n g_mask = im[:,:, 1] == g\n b_mask = im[:,:, 2] == b\n mask = r_mask & g_mask & b_mask\n return mask\n # 8-bit mask\n return im[:,:] == rgb","def subclassof(c, b):\n try:\n return issubclass(c, b)\n except TypeError:\n return False","def __contains__(self, item):\n\t\tif isinstance(item, basestring):\n\t\t\treturn item in self._channels\n\t\telif hasattr(item, '__iter__'):\n\t\t\treturn all(ch in self._channels for ch in item)\n\t\telse:\n\t\t\treturn False","def __bool__(self):\n raise ValueError(\"never bool enums\")","def is_istc(val):\n val = val.replace(\"-\", \"\").replace(\" \", \"\").upper()\n if len(val) != 16:\n return False\n sequence = [11, 9, 3, 1]\n try:\n r = sum([int(x, 16) * sequence[i % 4] for i, x in enumerate(val[:-1])])\n ck = hex(r % 16)[2:].upper()\n return ck == val[-1]\n except ValueError:\n return False","def is_FriCASElement(x):\n return isinstance(x, FriCASElement)","def test_condition(c, flag_dict, unspecified_val):\n\n for ci in c:\n if ci.name not in flag_dict:\n if not unspecified_val:\n return False\n elif ci.enabled != flag_dict[ci.name]:\n return False\n return True","def __inStructure(self, umls_cui):\n return (umls_cui in self.structure)","def valid(black, white, x, y):\n return (not black & gobit[(x, y)]) and (not white & gobit[(x, y)])","def contains(cls, value):\n return any(value == item.value for item in cls)","def is_rgb_color(v):\n if hasattr(v, \"r\") and hasattr(v, \"g\") and hasattr(v, \"b\"):\n v = [v.r, v.g, v.b]\n if not isiterable(v) or len(v) < 3:\n return False\n try:\n return all([0 <= int(x) <= 255 for x in v[:3]])\n except (TypeError, ValueError):\n return False","def test_should_have_all_bits_zeroed_because_there_is_no_valid_flag(self):\n tcp_flags = TCPControlBits(['AAA', 'BBB', 'CCC'])\n assert_false(any(tcp_flags.control_bits.values()))","def check_if_mask(address):\n bin_address = address_to_bin(address)\n bin_str = ''.join(bin_address.split('.'))\n i = 0\n while i < len(bin_str) and bin_str[i] == '1':\n i += 1\n\n if i == 0:\n return False\n\n for j in range(i, len(bin_str)):\n if bin_str[j] == '1':\n return False\n\n return True","def is_0to255(value):\n return 0 <= value <= 255","def is_choices(typ) -> bool:\n return type(typ) is type(Choices)","def has_value(cls, value):\n return any(value == item.value for item in cls)","def has_value(cls, value):\n return any(value == item.value for item in cls)","def valid_color(self, color):\n valid = False\n if (isinstance(color, list) and len(color) == 3):\n valid = True\n for chan in color:\n valid = valid and (0 <= chan <= 15)\n if not valid:\n _LOGGER.warn(\"{0} was not a valid color\".format(color))\n return valid","def _enum_should_collect(self, enum):\n last_require_version = 0\n for feature in self.enum_required_by_feature[enum]:\n last_require_version = max(last_require_version, feature['number'])\n\n last_remove_version = 0\n for feature in self.enum_removed_by_feature[enum]:\n last_remove_version = max(last_remove_version, feature['number'])\n\n for extension in self.enum_required_by_extension[enum]:\n extension_name = extension['name']\n if extension_name in self.extensions_to_collect:\n #print(f'Collecting enum {enum} because it is required by {extension_name}')\n return True\n\n # filter by command not required by core profile\n if last_require_version == 0:\n return False\n\n # filter by removed\n if last_remove_version > last_require_version:\n return False\n\n return True","def is_of_type(cls, value) -> bool:\n # UTF8 = 'utf-8'\n # UTF16 = 'utf-16'\n # UTF32 = 'utf-32'\n # ASCII = 'ascii'\n # BINARY = 'binary'\n # OCTAL = 'octal'\n # HEXADECIMAL = 'hexadecimal'\n # CP1252 = 'cp1252'\n # WINDOWS1252 = 'windows-1252'\n # UNICODEESCAPE = 'unicode-escape'\n\n v = None\n if cls == cls.UTF8 or cls == cls.UTF16 or cls == cls.UTF32 or cls == cls.UNICODEESCAPE:\n try:\n v = bytes(value)\n except:\n return False\n\n if cls == cls.ASCII:\n try:\n v = ascii(value)\n except:\n return False\n\n if cls == cls.BINARY:\n try:\n v = bin(value)\n except:\n return False\n\n if cls == cls.OCTAL:\n try:\n v = oct(value)\n except:\n return False\n\n if cls == cls.HEXADECIMAL:\n try:\n v = hex(value)\n except:\n return False\n\n if cls == cls.WINDOWS1252 or cls == cls.CP1252:\n try:\n v = str(value)\n except:\n return False\n return True","def test_has_exactly_type():\r\n\r\n return has_exactly_type(1, int) and not has_exactly_type(True, int) and has_exactly_type(True, bool)","def _assert_enum_valid(cls, enum):\n if isinstance(enum, EnumMeta):\n enum_values = [str(option.value) for option in enum]\n elif isinstance(enum, Iterable):\n enum_values = list(enum)\n else:\n msg = \"enum must be a subclass of Enum or an iterable.\"\n raise ValidationException(\n message=msg,\n no_personal_data_message=msg,\n error_category=ErrorCategory.USER_ERROR,\n target=ErrorTarget.PIPELINE,\n )\n\n if len(enum_values) <= 0:\n msg = \"enum must have enum values.\"\n raise ValidationException(\n message=msg,\n no_personal_data_message=msg,\n error_category=ErrorCategory.USER_ERROR,\n target=ErrorTarget.PIPELINE,\n )\n\n if any(not isinstance(v, str) for v in enum_values):\n msg = \"enum values must be str type.\"\n raise ValidationException(\n message=msg,\n no_personal_data_message=msg,\n error_category=ErrorCategory.USER_ERROR,\n target=ErrorTarget.PIPELINE,\n )\n\n return enum_values","def window_class_match(expected_class):\n # AHK has byte strings and I can't manage to convert them to str, so go the\n # other way.\n expected_class = expected_class.encode('ascii')\n def f(win):\n n = conv(win.class_name)\n return expected_class in n\n return f","def _assert_enum_valid(cls, enum: Type):\n if isinstance(enum, EnumMeta):\n enum_values = [str(option.value) for option in enum]\n elif isinstance(enum, Iterable):\n enum_values = list(enum)\n else:\n msg = \"enum must be a subclass of Enum or an iterable.\"\n raise ValidationException(\n message=msg,\n no_personal_data_message=msg,\n error_category=ErrorCategory.USER_ERROR,\n target=ErrorTarget.PIPELINE,\n error_type=ValidationErrorType.INVALID_VALUE,\n )\n\n if len(enum_values) <= 0:\n msg = \"enum must have enum values.\"\n raise ValidationException(\n message=msg,\n no_personal_data_message=msg,\n error_category=ErrorCategory.USER_ERROR,\n target=ErrorTarget.PIPELINE,\n error_type=ValidationErrorType.INVALID_VALUE,\n )\n\n if any(not isinstance(v, str) for v in enum_values):\n msg = \"enum values must be str type.\"\n raise ValidationException(\n message=msg,\n no_personal_data_message=msg,\n error_category=ErrorCategory.USER_ERROR,\n target=ErrorTarget.PIPELINE,\n error_type=ValidationErrorType.INVALID_VALUE,\n )\n\n return enum_values","def contains(cls, value):\n return value in cls.values()","def is_known(combo):\n return not _NONE_NONE & combo","def issubclass_safe(value, type_):\n try:\n return issubclass(value, type_)\n except (TypeError, AttributeError):\n # Cannot perform issubclass on some types\n return False","def test_contains():\n bounds = MolecularStructureBounds()\n assert bounds.contains(MolecularStructureBounds())\n assert not bounds.contains(RealBounds(0.0, 2.0, ''))\n assert not bounds.contains(None)\n with pytest.raises(TypeError):\n bounds.contains('c1(C=O)cc(OC)c(O)cc1')\n with pytest.raises(TypeError):\n bounds.contains('InChI=1/C8H8O3/c1-11-8-4-6(5-9)2-3-7(8)10/h2-5,10H,1H3')","def _matches(o, pattern):\n if not len(o) == len(pattern):\n return False\n comps = zip(o,pattern)\n return all(isinstance(obj,kind) for obj,kind in comps)","def cast_value_to_enum(attribute: Any, widget_value: str):\n enum_class: MyEnum = attribute.__class__\n return (t for i, t in enumerate(enum_class)\n if t.value == widget_value).__next__()","def validateComponentMask(comp_mask):\n return 0","def check_other(seq_iter):\n\treturn any(filter(has_abba, seq_iter))","def _is_color_valid(self, color):\n # make sure it is a tuple\n if type(color).__name__ != 'tuple':\n return False\n # check the length of the tuple\n if len(color) != 3:\n return False\n # verify that component colors are between _MIN and _MAX\n for c in color:\n if c < MIN or c > MAX:\n return False\n return True","def check_eclass(eclass):\n eclass = str(eclass)\n # Should be a valid eclass\n return eclass not in LIST_ECLASS","def is_subset(self, other):\n if isinstance(other, Permissions):\n return (self.value & other.value) == self.value\n else:\n raise TypeError(\"cannot compare {} with {}\".format(self.__class__.__name__, other.__class__.__name__))","def is_extended(self, value):\r\n if ((int(value) & 0xFF00) > 0):\r\n return True\r\n return False","def checkValue(c, m, y, k):\n MINVAL=0\n MAXVAL=255\n valueOk=True\n for val in c, m, y, k:\n if val >=MINVAL and val <=255:\n pass\n else:\n valueOk=False\n \n return valueOk","def __type_okay(value, argtype, allow_none=False):\n if value is None:\n return allow_none\n if isinstance(argtype, str):\n if argtype in __macros:\n return __type_okay(value, __macros[argtype], allow_none=allow_none)\n elif argtype is 'int':\n return __is_int(value)\n elif argtype is 'float':\n return __is_float(value)\n return argtype in [cls.__name__ for cls in value.__class__.__mro__]\n elif isinstance(argtype, type):\n if argtype == six.text_type:\n return isinstance(value, six.text_type) or isinstance(value, six.string_types)\n elif argtype == str:\n return isinstance(value, six.string_types)\n elif argtype is int:\n return __is_int(value)\n elif argtype is float:\n return __is_float(value)\n return isinstance(value, argtype)\n elif isinstance(argtype, tuple) or isinstance(argtype, list):\n return any(__type_okay(value, i) for i in argtype)\n else: # argtype is None\n return True","def validateScore(scoreEnum, dice):\n \n diceFreq = dice.freq()\n flatten = dice.flatten()\n\n if scoreEnum.name == 'THREE_OF_K':\n return (3 in diceFreq) or (4 in diceFreq) or (5 in diceFreq)\n elif scoreEnum.name == 'FOUR_OF_K':\n return (4 in diceFreq) or (5 in diceFreq)\n elif scoreEnum.name == 'FULL_H':\n return (3 in diceFreq) and (2 in diceFreq)\n elif scoreEnum.name == 'SM_STRT':\n return (flatten == (1, 1, 1, 1, 1, 0) or\n flatten == (0, 1, 1, 1, 1, 1) or\n flatten == (1, 1, 1, 1, 0, 0) or\n flatten == (1, 1, 1, 1, 0, 1) or\n flatten == (0, 1, 1, 1, 1, 0) or\n flatten == (0, 0, 1, 1, 1, 1) or\n flatten == (1, 0, 1, 1, 1, 1))\n elif scoreEnum.name == 'LG_STRT':\n return (flatten == (1, 1, 1, 1, 1, 0) or flatten == (0, 1, 1, 1, 1, 1))\n elif scoreEnum.name == 'YAHTZEE':\n return (5 in diceFreq)\n else:\n return True","def _assert_enum_types_equal(self, type1, type2):\n self.assertEqual(type1.name, type2.name)\n self.assertEqual(type1.description, type2.description)\n self.assertEqual(type1.func_descriptor, type2.func_descriptor)","def GroupKind_isValid(*args):\n return _libsbml.GroupKind_isValid(*args)","def bitmask(*args: Union[int, Sequence[int], Tuple[int, int]]) -> int:\n mask = 0\n\n for a in args:\n if isinstance(a, tuple):\n hi, lo = a\n mask |= ((1 << (hi - lo + 1)) - 1) << lo\n elif isinstance(a, (list, set)):\n mask |= reduce(operator.or_, ((1 << b) for b in a))\n elif isinstance(a, int):\n mask |= 1 << a\n\n return mask","def is_non_reducing(self):\n return bool(set(self.kind) & set(\"ABC\"))","def has_value(cls, value):\n return value in [item.value for item in cls]","def instance_of(cls):\n def check(value):\n return (\n isinstance(value, cls),\n u\"{value!r} is instance of {actual!s}, required {required!s}\".format(\n value=value,\n actual=fullyQualifiedName(type(value)),\n required=fullyQualifiedName(cls),\n ),\n )\n return check","def _is_compositional_type(content_type: str) -> bool:\n for valid_compositional_type in (\n SPECIFICATION_COMPOSITIONAL_TYPES + PYTHON_COMPOSITIONAL_TYPES\n ):\n if content_type.startswith(valid_compositional_type):\n return True\n return False","def scapy_packet_Packet_hasflag(self, field_name, value):\n\tfield, val = self.getfield_and_val(field_name)\n\tif isinstance(field, EnumField):\n\t\tif val not in field.i2s:\n\t\t\treturn False\n\t\treturn field.i2s[val] == value\n\telse:\n\t\treturn (1 << field.names.index([value])) & self.__getattr__(field_name) != 0","def test_type_builder_handles_enumerations_with_uppercase_values():\n schema = [\n SchemaEnum(\n name=\"UppercaseEnum\",\n value_type=\"string\",\n values=[\"HELLO_WORLD\", \"UPPERCASE_VALUE\", \"SOME_VALUE\"],\n ),\n ]\n\n build_result = build_types(schema)\n\n assert len(build_result) == 1\n assert build_result[0] == EnumDefinition(\n name=\"UppercaseEnum\",\n values=[\n (\"HELLO_WORLD\", \"HELLO_WORLD\"),\n (\"UPPERCASE_VALUE\", \"UPPERCASE_VALUE\"),\n (\"SOME_VALUE\", \"SOME_VALUE\"),\n ],\n depends_on=set(),\n )","def is_composite_type(self):\n return False","def is_cc(test_cases):\r\n \r\n n_inputs=len(test_cases[0])\r\n cc=[]\r\n was_true=False\r\n was_false=False\r\n \r\n for input in range(n_inputs):\r\n was_true=False\r\n was_false=False\r\n for test_case in test_cases:\r\n if test_case[input] == True:\r\n was_true=True\r\n else:\r\n was_false=True\r\n if was_true and was_false:\r\n cc.append(True)\r\n else:\r\n cc.append(False) \r\n return all(cc)","def _test_bit(expr: Expression, bit: int) -> bool:\n masked = _simplify_masked(expr, 1 << bit)\n return isinstance(masked, IntLiteral) and masked.value != 0","def sdi_bus_valid(sdi_bus):\n bus_upper = sdi_bus.upper()\n if (\"PORT1\" in bus_upper) or (\"PORT2\" in bus_upper) or (\"RS485\" in bus_upper):\n return True\n else:\n return False","def __isValidRgbaColor(self, color):\n rgba = []\n \n parts = color.split(\",\")\n if len(parts) not in [3, 4]:\n return False, []\n \n for part in parts:\n try:\n c = int(part)\n except ValueError:\n return False, []\n \n if c < 0 or c > 255:\n return False, []\n \n rgba.append(c)\n \n return True, rgba","def isValidFilter(klass):\n if not isclass(klass):\n logger.error(f\"{klass!r} is not a class\")\n return False\n if not callable(klass):\n logger.error(f\"{klass!r} is not callable\")\n return False\n if getfullargspec(klass.__call__).args != getfullargspec(BaseFilter.__call__).args:\n logger.error(f\"{klass!r} '__call__' method has incorrect signature\")\n return False\n return True","def isa_binary_element(self, element):\n\n return len(self.above(element)) <= 2 and len(self.under(element)) <= 2","def contains(self, other: 'BaseBox'):\n return np.all(other.lower >= self.lower) and np.all(other.upper <= self.upper)","def test_invalid_inputs(self):\n f = gtrutils.check_petition_combos\n \n self.assertFalse( f(-1, 1, [], False, False))\n self.assertFalse( f( 0, 1, [], False, False))\n self.assertFalse( f( 1, 0, [], False, False))\n self.assertFalse( f( 1, 1, [-1], False, False))\n self.assertFalse( f( 1,-1, [], False, False))\n self.assertFalse( f( 1, 1, [1], False, False)) # n_off_role can never be 1\n self.assertFalse( f( 1, 1, [1], True, False)) # n_off_role can never be 1\n self.assertFalse( f( 1, 1, [1], False, True)) # n_off_role can never be 1\n self.assertFalse( f( 1, 1, [1], True, True)) # n_off_role can never be 1\n self.assertFalse( f( 1, 1, [1,3], True, True)) # n_off_role can never be 1\n\n self.assertFalse( f( 3, 0, [2,3,3], False, True)) # n_off_role can never be 1\n self.assertFalse( f( 3, 0, [2,3,3], True, False)) # n_off_role can never be 1\n self.assertFalse( f( 2, 0, [2,3,3], False, True)) # n_off_role can never be 1\n self.assertFalse( f( 2, 0, [2,3,3], True, False)) # n_off_role can never be 1\n self.assertFalse( f( 5, 1, [6,6], True, False)) # n_off_role can never be 1","def _isA(self, elementClass, category = ''):\n if not isinstance(self, elementClass):\n return False\n if category and self.getCategory() != category:\n return False\n return True","def _validate_value_type(value: Any, expected: Sequence[Type]) -> bool:\n\n for entry in expected:\n if get_origin(entry) is None:\n if type(value) == entry: # pylint: disable=unidiomatic-typecheck\n return True\n continue\n if _validate_value_type(value, get_args(entry)):\n return True\n return False","def test_quality_mask():\n quality = np.array([0, 0, 1])\n assert np.all(KeplerQualityFlags.create_quality_mask(quality, bitmask=0))\n assert np.all(KeplerQualityFlags.create_quality_mask(quality, bitmask=None))\n assert np.all(KeplerQualityFlags.create_quality_mask(quality, bitmask='none'))\n assert (KeplerQualityFlags.create_quality_mask(quality, bitmask=1)).sum() == 2\n assert (KeplerQualityFlags.create_quality_mask(quality, bitmask='hardest')).sum() == 2\n # Do we see a ValueError if an invalid bitmask is passed?\n with pytest.raises(ValueError) as err:\n KeplerQualityFlags.create_quality_mask(quality, bitmask='invalidoption')\n assert \"not supported\" in err.value.args[0]","def validate_type(type):\n\n types_upper = [i.upper() for i in officeTypes]\n if type.upper() in types_upper:\n return True\n return False","def ISLOGICAL(value):\n return isinstance(value, bool)","def asCompositeType(klass):\n\n class _CompositeName(CompositeName):\n\n def mdl_fromString(_CNClass,aString):\n # Parse plain composite name, using this as compound parser\n name = CompositeName.parse(aString, klass)\n if isinstance(name, klass):\n return CompositeName([name])\n return name\n\n mdl_fromString = classmethod(mdl_fromString)\n\n\n def mdl_normalize(_CNClass, value):\n if isinstance(value, klass):\n # normalize compound as part of Composite\n return CompositeName([value])\n return CompositeName(value)\n\n mdl_normalize = classmethod(mdl_normalize)\n\n\n return _CompositeName","def test_type_builder_handles_top_level_enumerations():\n schema = [\n SchemaEnum(name=\"TestEnum\", value_type=\"string\", values=[\"a\", \"b\", \"c\"]),\n ]\n\n build_result = build_types(schema)\n\n assert len(build_result) == 1\n assert build_result[0] == EnumDefinition(\n name=\"TestEnum\", values=[(\"A\", \"a\"), (\"B\", \"b\"), (\"C\", \"c\")], depends_on=set(),\n )","def is_acceptable(self, value: Any) -> bool:\n if self == self.ARTIFACT_LIST:\n return typing_utils.is_homogeneous_artifact_list(value)\n elif self == self.ARTIFACT_MULTIMAP:\n return typing_utils.is_artifact_multimap(value)\n elif self == self.ARTIFACT_MULTIMAP_LIST:\n return typing_utils.is_list_of_artifact_multimap(value)\n raise NotImplementedError(f'Cannot check type for {self}.')","def _check_bit(self, bit, mask=1, errmsg=None):\n if self.mot_type == \"ims\":\n if self._msta_bit(bit, mask):\n if errmsg is not None:\n print errmsg\n return True\n return False","def issubclass_(arg1, arg2):\n try:\n return issubclass(arg1, arg2)\n except TypeError:\n return False","def isbit(integer, nth_bit):\n if nth_bit < 0:\n raise ValueError('Negative bit number.')\n mask = 1 << nth_bit\n return integer & mask > 0","def edge_case(values):\r\n for val in values:\r\n if val is True:\r\n return False\r\n return True","def construction_for_another_type(cname, graphtype):\n for t in constructions:\n if t == graphtype:\n continue\n if cname in constructions[t]:\n return True\n return False","def is_subtype_of(self, other):\n if type(self) is not type(other):\n return False\n\n if (not self._transform_is_composite and\n self.transform_or_spec != other.transform_or_spec):\n return False\n\n # pylint: disable=protected-access\n try:\n tf.nest.assert_same_structure((self._specs, self._unique_id_params),\n (other._specs, other._unique_id_params))\n except (TypeError, ValueError):\n return False\n\n self_elements = tf.nest.flatten((self._specs, self._unique_id_params))\n other_elements = tf.nest.flatten((other._specs, other._unique_id_params))\n\n def is_subtype_or_equal(a, b):\n try:\n return a.is_subtype_of(b)\n except AttributeError:\n return a == b\n\n return all(\n is_subtype_or_equal(self_element, other_element)\n for (self_element, other_element) in zip(self_elements, other_elements))","def ColorIdentityHas(colours):\n return And(*(search(field='colorIdentity', method=IN, value=c)\n for c in colours.upper()))","def validate_outcome_class(outcomes):\n # Make sure the class is the same for all outcomes.\n equal_classes = all(outcomes[0].__class__ == outcome.__class__\n for outcome in outcomes)\n\n if not equal_classes:\n raise ditException('Not all outcomes have the same class.')\n else:\n return True"],"string":"[\n \"def is_enum_value(enumeration, potential_value):\\n try:\\n enumeration(potential_value)\\n except ValueError:\\n return False\\n\\n return True\",\n \"def get_enumerations_from_bit_mask(enumeration, mask):\\n return [x for x in enumeration if (x.value & mask) == x.value]\",\n \"def _is_equal_to_enumatom(self, enumatom):\\n\\n return (self.enum == enumatom.enum and self.shape == enumatom.shape\\n and np.all(self.dflt == enumatom.dflt)\\n and self.base == enumatom.base)\",\n \"def is_enum(self):\\n return self.is_complex and not self.is_class\",\n \"def _check_enum(\\n enum_class: 'settings_enums.SettingsEnumType'\\n ) -> 'ScalarTypes':\\n if not issubclass(enum_class, enum.Enum):\\n raise TypeError('{} is not an Enum'.format(enum_class))\\n\\n instances: 'List[settings_enums.SettingsEnum]' = list(enum_class)\\n enum_type = type(instances[0].value)\\n\\n for instance in instances:\\n if not isinstance(instance.value, enum_type):\\n raise TypeError('enum {} uses mixed types {} and {}'.format(\\n enum_class, enum_type, type(instance)))\\n\\n if enum_type not in _TYPE_MAP:\\n raise TypeError(\\n '{} (underlying type of {}) is not a valid setting type'.format(\\n enum_type, enum_class))\\n\\n return enum_type\",\n \"def from_value(cls, value):\\n value = value if value else 0\\n try:\\n flags = [flag.name for flag in cls.enum_class if flag.value & value]\\n except TypeError:\\n flags = [flag.name for flag in cls.enum_class if flag.name == value]\\n\\n return cls(*flags)\",\n \"def is_boost_enum(obj: Any) -> bool:\\n for cls in type(obj).__bases__:\\n if \\\"Boost.Python.enum\\\" in str(cls):\\n return True\\n return False\",\n \"def has_valid_channel_values(rgb_coll):\\n return all([is_0to255(c) and is_int(c) for c in rgb_coll])\",\n \"def is_enum(schema_obj):\\n\\n return (isinstance(schema_obj, schema.Enum) or\\n (isinstance(schema_obj, schema.Field) and schema_obj.enum_type))\",\n \"def check_enum(enumerator, value):\\n is_valid = False\\n for data in enumerator:\\n if data == value:\\n is_valid = True\\n break\\n\\n if is_valid:\\n return value\\n else:\\n my_banner(\\\"Value must be from enum \\\" + enumerator +\\\" Value has been set to N/A\\\")\\n return \\\"na\\\"\",\n \"def get_bit_mask_from_enumerations(enumerations):\\n return functools.reduce(\\n lambda x, y: x | y, [z.value for z in enumerations]\\n )\",\n \"def check_enumeration_style(ctx, stmt):\\n elemtype = stmt.search_one(\\\"type\\\")\\n if elemtype is None or elemtype.arg != \\\"enumeration\\\":\\n return\\n\\n for enum in elemtype.search(\\\"enum\\\"):\\n if re.match(r\\\"[a-z]\\\", enum.arg):\\n err_add(ctx.errors, stmt.pos, \\\"OC_ENUM_CASE\\\",\\n (enum.arg, enum.arg.upper().replace(\\\"-\\\", \\\"_\\\")))\\n elif not re.match(r\\\"^[A-Z0-9][A-Z0-9\\\\_\\\\.]{0,}$\\\", enum.arg):\\n err_add(ctx.errors, stmt.pos, \\\"OC_ENUM_UNDERSCORES\\\",\\n (enum.arg, enum.arg.upper().replace(\\\"-\\\", \\\"_\\\")))\",\n \"def enum_check(*args, func=None):\\n func = func or inspect.stack()[2][3]\\n for var in args:\\n if not isinstance(var, (enum.EnumMeta, aenum.EnumMeta)):\\n name = type(var).__name__\\n raise EnumError(\\n 'Function {} expected enumeration, {} got instead.'.format(func, name))\",\n \"def is_mutually_bit_compatible_with(self, other: 'CompositeType') -> bool:\\n return self.bit_length_set == other.bit_length_set\",\n \"def test_bitmask(self, bit):\\r\\n if (int((format(self.__bitmask__, '016b')[2:])[bit]) == 0):\\r\\n return True\\r\\n return False\",\n \"def __contains__(self, flag):\\n\\n if isinstance(flag, six.integer_types):\\n # Pretty easy\\n return (self.bitflags & flag) == flag\\n elif isinstance(flag, six.string_types):\\n # Simple string\\n return flag in self.flags\\n else:\\n try:\\n # Make sure all the specified flags are present\\n return all(str(self.eset[fl]) in self.flags\\n for fl in flag)\\n except KeyError:\\n return False\",\n \"def test_get_enum_by_value():\\n assert BusinessType.get_enum_by_value('CP') == BusinessType.COOPERATIVE\\n assert BusinessType.get_enum_by_value('FM') == BusinessType.PARTNERSHIP_AND_SOLE_PROP\\n assert BusinessType.get_enum_by_value('NOT_FOUND') is None\",\n \"def mask_check(mask):\\n if isinstance(mask, u.Quantity):\\n if not (mask.unit == u.dimensionless_unscaled):\\n raise TypeError(\\n \\\"Mask should not be a non-dimensionless and unscaled Quantity!\\\"\\n )\\n mask = mask.value\\n\\n # Check for values of mask\\n if np.any(mask > 1) or np.any(mask < 0):\\n raise ValueError(\\\"Mask should be within range from 0 to 1 only.\\\")\",\n \"def is_valid_color(value):\\n if is_str(value):\\n return is_hex_string(value)\\n elif is_tuple_or_list(value):\\n return (is_tuple_or_list(value)\\n and is_three_channeled(value)\\n and has_valid_channel_values(value))\\n else:\\n return is_str_or_coll(value)\",\n \"def is_reaction_class(rxn_class):\\n return rxn_class in _values(ReactionClass.Typ)\",\n \"def parse_mask(value, mask_enum):\\n masks = []\\n for mask in mask_enum:\\n if value & mask:\\n masks.append(mask.name)\\n value ^= mask\\n if value:\\n masks.append(hex(value))\\n\\n return masks\",\n \"def bases_mask_is_valid(bases_mask):\\n try:\\n for read in bases_mask.upper().split(','):\\n if not re.match(r'^([IY][0-9]+|[IY]*)(N[0-9]+|N*)$',read):\\n return False\\n return True\\n except AttributeError:\\n return False\",\n \"def test_enum_detection():\\n\\n grammar = \\\"\\\"\\\"\\n IsEnum: \\\"keyword1\\\" | \\\"keyword2\\\" | \\\"keyword3\\\";\\n IsNotEnum: val=\\\"keyword1\\\" | val=\\\"keyword2\\\" | val=\\\"keyword3\\\";\\n StillNotEnum: val=\\\"keyword1\\\" | \\\"keyword2\\\" | \\\"keyword3\\\";\\n\\n // identified as EDatatype with object type\\n NotEnumAgain: SubEnum | SubEnum2;\\n\\n // this is an enumeration\\n SubEnum: \\\"keyword1\\\" | \\\"keyword2\\\";\\n SubEnum2: \\\"keyword3\\\" | \\\"keyword4\\\";\\n \\\"\\\"\\\"\\n\\n mm = metamodel_from_str(grammar)\\n\\n IsEnum = mm['IsEnum']\\n assert isinstance(IsEnum, ecore.EEnum)\\n assert IsEnum.name == 'IsEnum'\\n assert all((x in IsEnum for x in (\\\"keyword1\\\", \\\"keyword2\\\", \\\"keyword3\\\")))\\n\\n IsNotEnum = mm['IsNotEnum']\\n assert IsNotEnum.name == 'IsNotEnum'\\n assert isinstance(IsNotEnum, ecore.EClass)\\n\\n StillNotEnum = mm['StillNotEnum']\\n assert StillNotEnum.name == 'StillNotEnum'\\n assert isinstance(StillNotEnum, ecore.EClass)\\n\\n NotEnumAgain = mm['NotEnumAgain']\\n assert isinstance(NotEnumAgain, ecore.EDataType)\\n assert NotEnumAgain.name == 'NotEnumAgain'\\n\\n SubEnum = mm['SubEnum']\\n assert isinstance(SubEnum, ecore.EEnum)\\n assert SubEnum.name == 'SubEnum'\\n assert all((x in IsEnum for x in (\\\"keyword1\\\", \\\"keyword2\\\")))\",\n \"def is_enum(self):\\n return False\",\n \"def is_bits(self, argno: Union[int, Tuple[int, ...]]) -> '_Checker':\\n if isinstance(argno, tuple):\\n for a in argno:\\n self.is_bits(a)\\n return self\\n\\n t = self.arg_types[argno]\\n if not isinstance(t, BitsType):\\n raise XlsTypeError(self.span, t, None,\\n 'Want argument {} to be bits; got {}'.format(argno, t))\\n return self\",\n \"def check_enum(self, name, values):\\n v = self.__dict__.get(name)\\n if v not in values:\\n raise ValueError(\\n \\\"Invalid value: {0}='{1}', not in '{2}'\\\".format(name, v, values))\",\n \"def is_composite_or_composite_value(tensor):\\n # TODO(b/125094323): This should be isinstance(CompositeTensor) or\\n # isinstance(CompositeTensorValue) once we support that.\\n return isinstance(\\n tensor,\\n (composite_tensor.CompositeTensor, sparse_tensor.SparseTensorValue,\\n ragged_tensor_value.RaggedTensorValue))\",\n \"def getClassMask(self, rgb, im):\\n # Colour mask\\n if len(rgb) == 3:\\n r, g, b = rgb\\n r_mask = im[:,:, 0] == r\\n g_mask = im[:,:, 1] == g\\n b_mask = im[:,:, 2] == b\\n mask = r_mask & g_mask & b_mask\\n return mask\\n # 8-bit mask\\n return im[:,:] == rgb\",\n \"def subclassof(c, b):\\n try:\\n return issubclass(c, b)\\n except TypeError:\\n return False\",\n \"def __contains__(self, item):\\n\\t\\tif isinstance(item, basestring):\\n\\t\\t\\treturn item in self._channels\\n\\t\\telif hasattr(item, '__iter__'):\\n\\t\\t\\treturn all(ch in self._channels for ch in item)\\n\\t\\telse:\\n\\t\\t\\treturn False\",\n \"def __bool__(self):\\n raise ValueError(\\\"never bool enums\\\")\",\n \"def is_istc(val):\\n val = val.replace(\\\"-\\\", \\\"\\\").replace(\\\" \\\", \\\"\\\").upper()\\n if len(val) != 16:\\n return False\\n sequence = [11, 9, 3, 1]\\n try:\\n r = sum([int(x, 16) * sequence[i % 4] for i, x in enumerate(val[:-1])])\\n ck = hex(r % 16)[2:].upper()\\n return ck == val[-1]\\n except ValueError:\\n return False\",\n \"def is_FriCASElement(x):\\n return isinstance(x, FriCASElement)\",\n \"def test_condition(c, flag_dict, unspecified_val):\\n\\n for ci in c:\\n if ci.name not in flag_dict:\\n if not unspecified_val:\\n return False\\n elif ci.enabled != flag_dict[ci.name]:\\n return False\\n return True\",\n \"def __inStructure(self, umls_cui):\\n return (umls_cui in self.structure)\",\n \"def valid(black, white, x, y):\\n return (not black & gobit[(x, y)]) and (not white & gobit[(x, y)])\",\n \"def contains(cls, value):\\n return any(value == item.value for item in cls)\",\n \"def is_rgb_color(v):\\n if hasattr(v, \\\"r\\\") and hasattr(v, \\\"g\\\") and hasattr(v, \\\"b\\\"):\\n v = [v.r, v.g, v.b]\\n if not isiterable(v) or len(v) < 3:\\n return False\\n try:\\n return all([0 <= int(x) <= 255 for x in v[:3]])\\n except (TypeError, ValueError):\\n return False\",\n \"def test_should_have_all_bits_zeroed_because_there_is_no_valid_flag(self):\\n tcp_flags = TCPControlBits(['AAA', 'BBB', 'CCC'])\\n assert_false(any(tcp_flags.control_bits.values()))\",\n \"def check_if_mask(address):\\n bin_address = address_to_bin(address)\\n bin_str = ''.join(bin_address.split('.'))\\n i = 0\\n while i < len(bin_str) and bin_str[i] == '1':\\n i += 1\\n\\n if i == 0:\\n return False\\n\\n for j in range(i, len(bin_str)):\\n if bin_str[j] == '1':\\n return False\\n\\n return True\",\n \"def is_0to255(value):\\n return 0 <= value <= 255\",\n \"def is_choices(typ) -> bool:\\n return type(typ) is type(Choices)\",\n \"def has_value(cls, value):\\n return any(value == item.value for item in cls)\",\n \"def has_value(cls, value):\\n return any(value == item.value for item in cls)\",\n \"def valid_color(self, color):\\n valid = False\\n if (isinstance(color, list) and len(color) == 3):\\n valid = True\\n for chan in color:\\n valid = valid and (0 <= chan <= 15)\\n if not valid:\\n _LOGGER.warn(\\\"{0} was not a valid color\\\".format(color))\\n return valid\",\n \"def _enum_should_collect(self, enum):\\n last_require_version = 0\\n for feature in self.enum_required_by_feature[enum]:\\n last_require_version = max(last_require_version, feature['number'])\\n\\n last_remove_version = 0\\n for feature in self.enum_removed_by_feature[enum]:\\n last_remove_version = max(last_remove_version, feature['number'])\\n\\n for extension in self.enum_required_by_extension[enum]:\\n extension_name = extension['name']\\n if extension_name in self.extensions_to_collect:\\n #print(f'Collecting enum {enum} because it is required by {extension_name}')\\n return True\\n\\n # filter by command not required by core profile\\n if last_require_version == 0:\\n return False\\n\\n # filter by removed\\n if last_remove_version > last_require_version:\\n return False\\n\\n return True\",\n \"def is_of_type(cls, value) -> bool:\\n # UTF8 = 'utf-8'\\n # UTF16 = 'utf-16'\\n # UTF32 = 'utf-32'\\n # ASCII = 'ascii'\\n # BINARY = 'binary'\\n # OCTAL = 'octal'\\n # HEXADECIMAL = 'hexadecimal'\\n # CP1252 = 'cp1252'\\n # WINDOWS1252 = 'windows-1252'\\n # UNICODEESCAPE = 'unicode-escape'\\n\\n v = None\\n if cls == cls.UTF8 or cls == cls.UTF16 or cls == cls.UTF32 or cls == cls.UNICODEESCAPE:\\n try:\\n v = bytes(value)\\n except:\\n return False\\n\\n if cls == cls.ASCII:\\n try:\\n v = ascii(value)\\n except:\\n return False\\n\\n if cls == cls.BINARY:\\n try:\\n v = bin(value)\\n except:\\n return False\\n\\n if cls == cls.OCTAL:\\n try:\\n v = oct(value)\\n except:\\n return False\\n\\n if cls == cls.HEXADECIMAL:\\n try:\\n v = hex(value)\\n except:\\n return False\\n\\n if cls == cls.WINDOWS1252 or cls == cls.CP1252:\\n try:\\n v = str(value)\\n except:\\n return False\\n return True\",\n \"def test_has_exactly_type():\\r\\n\\r\\n return has_exactly_type(1, int) and not has_exactly_type(True, int) and has_exactly_type(True, bool)\",\n \"def _assert_enum_valid(cls, enum):\\n if isinstance(enum, EnumMeta):\\n enum_values = [str(option.value) for option in enum]\\n elif isinstance(enum, Iterable):\\n enum_values = list(enum)\\n else:\\n msg = \\\"enum must be a subclass of Enum or an iterable.\\\"\\n raise ValidationException(\\n message=msg,\\n no_personal_data_message=msg,\\n error_category=ErrorCategory.USER_ERROR,\\n target=ErrorTarget.PIPELINE,\\n )\\n\\n if len(enum_values) <= 0:\\n msg = \\\"enum must have enum values.\\\"\\n raise ValidationException(\\n message=msg,\\n no_personal_data_message=msg,\\n error_category=ErrorCategory.USER_ERROR,\\n target=ErrorTarget.PIPELINE,\\n )\\n\\n if any(not isinstance(v, str) for v in enum_values):\\n msg = \\\"enum values must be str type.\\\"\\n raise ValidationException(\\n message=msg,\\n no_personal_data_message=msg,\\n error_category=ErrorCategory.USER_ERROR,\\n target=ErrorTarget.PIPELINE,\\n )\\n\\n return enum_values\",\n \"def window_class_match(expected_class):\\n # AHK has byte strings and I can't manage to convert them to str, so go the\\n # other way.\\n expected_class = expected_class.encode('ascii')\\n def f(win):\\n n = conv(win.class_name)\\n return expected_class in n\\n return f\",\n \"def _assert_enum_valid(cls, enum: Type):\\n if isinstance(enum, EnumMeta):\\n enum_values = [str(option.value) for option in enum]\\n elif isinstance(enum, Iterable):\\n enum_values = list(enum)\\n else:\\n msg = \\\"enum must be a subclass of Enum or an iterable.\\\"\\n raise ValidationException(\\n message=msg,\\n no_personal_data_message=msg,\\n error_category=ErrorCategory.USER_ERROR,\\n target=ErrorTarget.PIPELINE,\\n error_type=ValidationErrorType.INVALID_VALUE,\\n )\\n\\n if len(enum_values) <= 0:\\n msg = \\\"enum must have enum values.\\\"\\n raise ValidationException(\\n message=msg,\\n no_personal_data_message=msg,\\n error_category=ErrorCategory.USER_ERROR,\\n target=ErrorTarget.PIPELINE,\\n error_type=ValidationErrorType.INVALID_VALUE,\\n )\\n\\n if any(not isinstance(v, str) for v in enum_values):\\n msg = \\\"enum values must be str type.\\\"\\n raise ValidationException(\\n message=msg,\\n no_personal_data_message=msg,\\n error_category=ErrorCategory.USER_ERROR,\\n target=ErrorTarget.PIPELINE,\\n error_type=ValidationErrorType.INVALID_VALUE,\\n )\\n\\n return enum_values\",\n \"def contains(cls, value):\\n return value in cls.values()\",\n \"def is_known(combo):\\n return not _NONE_NONE & combo\",\n \"def issubclass_safe(value, type_):\\n try:\\n return issubclass(value, type_)\\n except (TypeError, AttributeError):\\n # Cannot perform issubclass on some types\\n return False\",\n \"def test_contains():\\n bounds = MolecularStructureBounds()\\n assert bounds.contains(MolecularStructureBounds())\\n assert not bounds.contains(RealBounds(0.0, 2.0, ''))\\n assert not bounds.contains(None)\\n with pytest.raises(TypeError):\\n bounds.contains('c1(C=O)cc(OC)c(O)cc1')\\n with pytest.raises(TypeError):\\n bounds.contains('InChI=1/C8H8O3/c1-11-8-4-6(5-9)2-3-7(8)10/h2-5,10H,1H3')\",\n \"def _matches(o, pattern):\\n if not len(o) == len(pattern):\\n return False\\n comps = zip(o,pattern)\\n return all(isinstance(obj,kind) for obj,kind in comps)\",\n \"def cast_value_to_enum(attribute: Any, widget_value: str):\\n enum_class: MyEnum = attribute.__class__\\n return (t for i, t in enumerate(enum_class)\\n if t.value == widget_value).__next__()\",\n \"def validateComponentMask(comp_mask):\\n return 0\",\n \"def check_other(seq_iter):\\n\\treturn any(filter(has_abba, seq_iter))\",\n \"def _is_color_valid(self, color):\\n # make sure it is a tuple\\n if type(color).__name__ != 'tuple':\\n return False\\n # check the length of the tuple\\n if len(color) != 3:\\n return False\\n # verify that component colors are between _MIN and _MAX\\n for c in color:\\n if c < MIN or c > MAX:\\n return False\\n return True\",\n \"def check_eclass(eclass):\\n eclass = str(eclass)\\n # Should be a valid eclass\\n return eclass not in LIST_ECLASS\",\n \"def is_subset(self, other):\\n if isinstance(other, Permissions):\\n return (self.value & other.value) == self.value\\n else:\\n raise TypeError(\\\"cannot compare {} with {}\\\".format(self.__class__.__name__, other.__class__.__name__))\",\n \"def is_extended(self, value):\\r\\n if ((int(value) & 0xFF00) > 0):\\r\\n return True\\r\\n return False\",\n \"def checkValue(c, m, y, k):\\n MINVAL=0\\n MAXVAL=255\\n valueOk=True\\n for val in c, m, y, k:\\n if val >=MINVAL and val <=255:\\n pass\\n else:\\n valueOk=False\\n \\n return valueOk\",\n \"def __type_okay(value, argtype, allow_none=False):\\n if value is None:\\n return allow_none\\n if isinstance(argtype, str):\\n if argtype in __macros:\\n return __type_okay(value, __macros[argtype], allow_none=allow_none)\\n elif argtype is 'int':\\n return __is_int(value)\\n elif argtype is 'float':\\n return __is_float(value)\\n return argtype in [cls.__name__ for cls in value.__class__.__mro__]\\n elif isinstance(argtype, type):\\n if argtype == six.text_type:\\n return isinstance(value, six.text_type) or isinstance(value, six.string_types)\\n elif argtype == str:\\n return isinstance(value, six.string_types)\\n elif argtype is int:\\n return __is_int(value)\\n elif argtype is float:\\n return __is_float(value)\\n return isinstance(value, argtype)\\n elif isinstance(argtype, tuple) or isinstance(argtype, list):\\n return any(__type_okay(value, i) for i in argtype)\\n else: # argtype is None\\n return True\",\n \"def validateScore(scoreEnum, dice):\\n \\n diceFreq = dice.freq()\\n flatten = dice.flatten()\\n\\n if scoreEnum.name == 'THREE_OF_K':\\n return (3 in diceFreq) or (4 in diceFreq) or (5 in diceFreq)\\n elif scoreEnum.name == 'FOUR_OF_K':\\n return (4 in diceFreq) or (5 in diceFreq)\\n elif scoreEnum.name == 'FULL_H':\\n return (3 in diceFreq) and (2 in diceFreq)\\n elif scoreEnum.name == 'SM_STRT':\\n return (flatten == (1, 1, 1, 1, 1, 0) or\\n flatten == (0, 1, 1, 1, 1, 1) or\\n flatten == (1, 1, 1, 1, 0, 0) or\\n flatten == (1, 1, 1, 1, 0, 1) or\\n flatten == (0, 1, 1, 1, 1, 0) or\\n flatten == (0, 0, 1, 1, 1, 1) or\\n flatten == (1, 0, 1, 1, 1, 1))\\n elif scoreEnum.name == 'LG_STRT':\\n return (flatten == (1, 1, 1, 1, 1, 0) or flatten == (0, 1, 1, 1, 1, 1))\\n elif scoreEnum.name == 'YAHTZEE':\\n return (5 in diceFreq)\\n else:\\n return True\",\n \"def _assert_enum_types_equal(self, type1, type2):\\n self.assertEqual(type1.name, type2.name)\\n self.assertEqual(type1.description, type2.description)\\n self.assertEqual(type1.func_descriptor, type2.func_descriptor)\",\n \"def GroupKind_isValid(*args):\\n return _libsbml.GroupKind_isValid(*args)\",\n \"def bitmask(*args: Union[int, Sequence[int], Tuple[int, int]]) -> int:\\n mask = 0\\n\\n for a in args:\\n if isinstance(a, tuple):\\n hi, lo = a\\n mask |= ((1 << (hi - lo + 1)) - 1) << lo\\n elif isinstance(a, (list, set)):\\n mask |= reduce(operator.or_, ((1 << b) for b in a))\\n elif isinstance(a, int):\\n mask |= 1 << a\\n\\n return mask\",\n \"def is_non_reducing(self):\\n return bool(set(self.kind) & set(\\\"ABC\\\"))\",\n \"def has_value(cls, value):\\n return value in [item.value for item in cls]\",\n \"def instance_of(cls):\\n def check(value):\\n return (\\n isinstance(value, cls),\\n u\\\"{value!r} is instance of {actual!s}, required {required!s}\\\".format(\\n value=value,\\n actual=fullyQualifiedName(type(value)),\\n required=fullyQualifiedName(cls),\\n ),\\n )\\n return check\",\n \"def _is_compositional_type(content_type: str) -> bool:\\n for valid_compositional_type in (\\n SPECIFICATION_COMPOSITIONAL_TYPES + PYTHON_COMPOSITIONAL_TYPES\\n ):\\n if content_type.startswith(valid_compositional_type):\\n return True\\n return False\",\n \"def scapy_packet_Packet_hasflag(self, field_name, value):\\n\\tfield, val = self.getfield_and_val(field_name)\\n\\tif isinstance(field, EnumField):\\n\\t\\tif val not in field.i2s:\\n\\t\\t\\treturn False\\n\\t\\treturn field.i2s[val] == value\\n\\telse:\\n\\t\\treturn (1 << field.names.index([value])) & self.__getattr__(field_name) != 0\",\n \"def test_type_builder_handles_enumerations_with_uppercase_values():\\n schema = [\\n SchemaEnum(\\n name=\\\"UppercaseEnum\\\",\\n value_type=\\\"string\\\",\\n values=[\\\"HELLO_WORLD\\\", \\\"UPPERCASE_VALUE\\\", \\\"SOME_VALUE\\\"],\\n ),\\n ]\\n\\n build_result = build_types(schema)\\n\\n assert len(build_result) == 1\\n assert build_result[0] == EnumDefinition(\\n name=\\\"UppercaseEnum\\\",\\n values=[\\n (\\\"HELLO_WORLD\\\", \\\"HELLO_WORLD\\\"),\\n (\\\"UPPERCASE_VALUE\\\", \\\"UPPERCASE_VALUE\\\"),\\n (\\\"SOME_VALUE\\\", \\\"SOME_VALUE\\\"),\\n ],\\n depends_on=set(),\\n )\",\n \"def is_composite_type(self):\\n return False\",\n \"def is_cc(test_cases):\\r\\n \\r\\n n_inputs=len(test_cases[0])\\r\\n cc=[]\\r\\n was_true=False\\r\\n was_false=False\\r\\n \\r\\n for input in range(n_inputs):\\r\\n was_true=False\\r\\n was_false=False\\r\\n for test_case in test_cases:\\r\\n if test_case[input] == True:\\r\\n was_true=True\\r\\n else:\\r\\n was_false=True\\r\\n if was_true and was_false:\\r\\n cc.append(True)\\r\\n else:\\r\\n cc.append(False) \\r\\n return all(cc)\",\n \"def _test_bit(expr: Expression, bit: int) -> bool:\\n masked = _simplify_masked(expr, 1 << bit)\\n return isinstance(masked, IntLiteral) and masked.value != 0\",\n \"def sdi_bus_valid(sdi_bus):\\n bus_upper = sdi_bus.upper()\\n if (\\\"PORT1\\\" in bus_upper) or (\\\"PORT2\\\" in bus_upper) or (\\\"RS485\\\" in bus_upper):\\n return True\\n else:\\n return False\",\n \"def __isValidRgbaColor(self, color):\\n rgba = []\\n \\n parts = color.split(\\\",\\\")\\n if len(parts) not in [3, 4]:\\n return False, []\\n \\n for part in parts:\\n try:\\n c = int(part)\\n except ValueError:\\n return False, []\\n \\n if c < 0 or c > 255:\\n return False, []\\n \\n rgba.append(c)\\n \\n return True, rgba\",\n \"def isValidFilter(klass):\\n if not isclass(klass):\\n logger.error(f\\\"{klass!r} is not a class\\\")\\n return False\\n if not callable(klass):\\n logger.error(f\\\"{klass!r} is not callable\\\")\\n return False\\n if getfullargspec(klass.__call__).args != getfullargspec(BaseFilter.__call__).args:\\n logger.error(f\\\"{klass!r} '__call__' method has incorrect signature\\\")\\n return False\\n return True\",\n \"def isa_binary_element(self, element):\\n\\n return len(self.above(element)) <= 2 and len(self.under(element)) <= 2\",\n \"def contains(self, other: 'BaseBox'):\\n return np.all(other.lower >= self.lower) and np.all(other.upper <= self.upper)\",\n \"def test_invalid_inputs(self):\\n f = gtrutils.check_petition_combos\\n \\n self.assertFalse( f(-1, 1, [], False, False))\\n self.assertFalse( f( 0, 1, [], False, False))\\n self.assertFalse( f( 1, 0, [], False, False))\\n self.assertFalse( f( 1, 1, [-1], False, False))\\n self.assertFalse( f( 1,-1, [], False, False))\\n self.assertFalse( f( 1, 1, [1], False, False)) # n_off_role can never be 1\\n self.assertFalse( f( 1, 1, [1], True, False)) # n_off_role can never be 1\\n self.assertFalse( f( 1, 1, [1], False, True)) # n_off_role can never be 1\\n self.assertFalse( f( 1, 1, [1], True, True)) # n_off_role can never be 1\\n self.assertFalse( f( 1, 1, [1,3], True, True)) # n_off_role can never be 1\\n\\n self.assertFalse( f( 3, 0, [2,3,3], False, True)) # n_off_role can never be 1\\n self.assertFalse( f( 3, 0, [2,3,3], True, False)) # n_off_role can never be 1\\n self.assertFalse( f( 2, 0, [2,3,3], False, True)) # n_off_role can never be 1\\n self.assertFalse( f( 2, 0, [2,3,3], True, False)) # n_off_role can never be 1\\n self.assertFalse( f( 5, 1, [6,6], True, False)) # n_off_role can never be 1\",\n \"def _isA(self, elementClass, category = ''):\\n if not isinstance(self, elementClass):\\n return False\\n if category and self.getCategory() != category:\\n return False\\n return True\",\n \"def _validate_value_type(value: Any, expected: Sequence[Type]) -> bool:\\n\\n for entry in expected:\\n if get_origin(entry) is None:\\n if type(value) == entry: # pylint: disable=unidiomatic-typecheck\\n return True\\n continue\\n if _validate_value_type(value, get_args(entry)):\\n return True\\n return False\",\n \"def test_quality_mask():\\n quality = np.array([0, 0, 1])\\n assert np.all(KeplerQualityFlags.create_quality_mask(quality, bitmask=0))\\n assert np.all(KeplerQualityFlags.create_quality_mask(quality, bitmask=None))\\n assert np.all(KeplerQualityFlags.create_quality_mask(quality, bitmask='none'))\\n assert (KeplerQualityFlags.create_quality_mask(quality, bitmask=1)).sum() == 2\\n assert (KeplerQualityFlags.create_quality_mask(quality, bitmask='hardest')).sum() == 2\\n # Do we see a ValueError if an invalid bitmask is passed?\\n with pytest.raises(ValueError) as err:\\n KeplerQualityFlags.create_quality_mask(quality, bitmask='invalidoption')\\n assert \\\"not supported\\\" in err.value.args[0]\",\n \"def validate_type(type):\\n\\n types_upper = [i.upper() for i in officeTypes]\\n if type.upper() in types_upper:\\n return True\\n return False\",\n \"def ISLOGICAL(value):\\n return isinstance(value, bool)\",\n \"def asCompositeType(klass):\\n\\n class _CompositeName(CompositeName):\\n\\n def mdl_fromString(_CNClass,aString):\\n # Parse plain composite name, using this as compound parser\\n name = CompositeName.parse(aString, klass)\\n if isinstance(name, klass):\\n return CompositeName([name])\\n return name\\n\\n mdl_fromString = classmethod(mdl_fromString)\\n\\n\\n def mdl_normalize(_CNClass, value):\\n if isinstance(value, klass):\\n # normalize compound as part of Composite\\n return CompositeName([value])\\n return CompositeName(value)\\n\\n mdl_normalize = classmethod(mdl_normalize)\\n\\n\\n return _CompositeName\",\n \"def test_type_builder_handles_top_level_enumerations():\\n schema = [\\n SchemaEnum(name=\\\"TestEnum\\\", value_type=\\\"string\\\", values=[\\\"a\\\", \\\"b\\\", \\\"c\\\"]),\\n ]\\n\\n build_result = build_types(schema)\\n\\n assert len(build_result) == 1\\n assert build_result[0] == EnumDefinition(\\n name=\\\"TestEnum\\\", values=[(\\\"A\\\", \\\"a\\\"), (\\\"B\\\", \\\"b\\\"), (\\\"C\\\", \\\"c\\\")], depends_on=set(),\\n )\",\n \"def is_acceptable(self, value: Any) -> bool:\\n if self == self.ARTIFACT_LIST:\\n return typing_utils.is_homogeneous_artifact_list(value)\\n elif self == self.ARTIFACT_MULTIMAP:\\n return typing_utils.is_artifact_multimap(value)\\n elif self == self.ARTIFACT_MULTIMAP_LIST:\\n return typing_utils.is_list_of_artifact_multimap(value)\\n raise NotImplementedError(f'Cannot check type for {self}.')\",\n \"def _check_bit(self, bit, mask=1, errmsg=None):\\n if self.mot_type == \\\"ims\\\":\\n if self._msta_bit(bit, mask):\\n if errmsg is not None:\\n print errmsg\\n return True\\n return False\",\n \"def issubclass_(arg1, arg2):\\n try:\\n return issubclass(arg1, arg2)\\n except TypeError:\\n return False\",\n \"def isbit(integer, nth_bit):\\n if nth_bit < 0:\\n raise ValueError('Negative bit number.')\\n mask = 1 << nth_bit\\n return integer & mask > 0\",\n \"def edge_case(values):\\r\\n for val in values:\\r\\n if val is True:\\r\\n return False\\r\\n return True\",\n \"def construction_for_another_type(cname, graphtype):\\n for t in constructions:\\n if t == graphtype:\\n continue\\n if cname in constructions[t]:\\n return True\\n return False\",\n \"def is_subtype_of(self, other):\\n if type(self) is not type(other):\\n return False\\n\\n if (not self._transform_is_composite and\\n self.transform_or_spec != other.transform_or_spec):\\n return False\\n\\n # pylint: disable=protected-access\\n try:\\n tf.nest.assert_same_structure((self._specs, self._unique_id_params),\\n (other._specs, other._unique_id_params))\\n except (TypeError, ValueError):\\n return False\\n\\n self_elements = tf.nest.flatten((self._specs, self._unique_id_params))\\n other_elements = tf.nest.flatten((other._specs, other._unique_id_params))\\n\\n def is_subtype_or_equal(a, b):\\n try:\\n return a.is_subtype_of(b)\\n except AttributeError:\\n return a == b\\n\\n return all(\\n is_subtype_or_equal(self_element, other_element)\\n for (self_element, other_element) in zip(self_elements, other_elements))\",\n \"def ColorIdentityHas(colours):\\n return And(*(search(field='colorIdentity', method=IN, value=c)\\n for c in colours.upper()))\",\n \"def validate_outcome_class(outcomes):\\n # Make sure the class is the same for all outcomes.\\n equal_classes = all(outcomes[0].__class__ == outcome.__class__\\n for outcome in outcomes)\\n\\n if not equal_classes:\\n raise ditException('Not all outcomes have the same class.')\\n else:\\n return True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5870301","0.58618695","0.553218","0.5408903","0.5404764","0.53083646","0.5269919","0.5266223","0.521553","0.51871705","0.5102369","0.50527793","0.5026475","0.49758133","0.4956287","0.49388525","0.4901828","0.48965237","0.48832533","0.48725867","0.48063046","0.47749615","0.47699323","0.47310603","0.47231966","0.4716611","0.46803445","0.46592766","0.46530652","0.46517265","0.46500415","0.46498787","0.46413028","0.46334824","0.4623244","0.4618382","0.46158293","0.45929372","0.4581162","0.45687085","0.45603815","0.45523942","0.45462754","0.45462754","0.4545241","0.45410624","0.4513057","0.4512746","0.45124242","0.45120978","0.44975007","0.44968572","0.44964784","0.44948813","0.44725206","0.44679764","0.4464947","0.44564137","0.44455093","0.44386914","0.44381443","0.44372144","0.44312367","0.44268265","0.4425408","0.4407936","0.44038594","0.4402092","0.44015318","0.4400953","0.439735","0.43944818","0.43937072","0.4388082","0.43825287","0.4381245","0.43749028","0.43748134","0.43709335","0.43661508","0.43605363","0.4354356","0.4353332","0.4351875","0.43511274","0.4349543","0.4334602","0.43302035","0.43294382","0.43217656","0.4314109","0.43023095","0.42997396","0.42980197","0.42970562","0.42963475","0.42954502","0.42928183","0.42884627","0.42882097"],"string":"[\n \"0.5870301\",\n \"0.58618695\",\n \"0.553218\",\n \"0.5408903\",\n \"0.5404764\",\n \"0.53083646\",\n \"0.5269919\",\n \"0.5266223\",\n \"0.521553\",\n \"0.51871705\",\n \"0.5102369\",\n \"0.50527793\",\n \"0.5026475\",\n \"0.49758133\",\n \"0.4956287\",\n \"0.49388525\",\n \"0.4901828\",\n \"0.48965237\",\n \"0.48832533\",\n \"0.48725867\",\n \"0.48063046\",\n \"0.47749615\",\n \"0.47699323\",\n \"0.47310603\",\n \"0.47231966\",\n \"0.4716611\",\n \"0.46803445\",\n \"0.46592766\",\n \"0.46530652\",\n \"0.46517265\",\n \"0.46500415\",\n \"0.46498787\",\n \"0.46413028\",\n \"0.46334824\",\n \"0.4623244\",\n \"0.4618382\",\n \"0.46158293\",\n \"0.45929372\",\n \"0.4581162\",\n \"0.45687085\",\n \"0.45603815\",\n \"0.45523942\",\n \"0.45462754\",\n \"0.45462754\",\n \"0.4545241\",\n \"0.45410624\",\n \"0.4513057\",\n \"0.4512746\",\n \"0.45124242\",\n \"0.45120978\",\n \"0.44975007\",\n \"0.44968572\",\n \"0.44964784\",\n \"0.44948813\",\n \"0.44725206\",\n \"0.44679764\",\n \"0.4464947\",\n \"0.44564137\",\n \"0.44455093\",\n \"0.44386914\",\n \"0.44381443\",\n \"0.44372144\",\n \"0.44312367\",\n \"0.44268265\",\n \"0.4425408\",\n \"0.4407936\",\n \"0.44038594\",\n \"0.4402092\",\n \"0.44015318\",\n \"0.4400953\",\n \"0.439735\",\n \"0.43944818\",\n \"0.43937072\",\n \"0.4388082\",\n \"0.43825287\",\n \"0.4381245\",\n \"0.43749028\",\n \"0.43748134\",\n \"0.43709335\",\n \"0.43661508\",\n \"0.43605363\",\n \"0.4354356\",\n \"0.4353332\",\n \"0.4351875\",\n \"0.43511274\",\n \"0.4349543\",\n \"0.4334602\",\n \"0.43302035\",\n \"0.43294382\",\n \"0.43217656\",\n \"0.4314109\",\n \"0.43023095\",\n \"0.42997396\",\n \"0.42980197\",\n \"0.42970562\",\n \"0.42963475\",\n \"0.42954502\",\n \"0.42928183\",\n \"0.42884627\",\n \"0.42882097\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6198896"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93188,"cells":{"query":{"kind":"string","value":"A utility function that checks if the enumeration class contains the provided value."},"document":{"kind":"string","value":"def is_enum_value(enumeration, potential_value):\n try:\n enumeration(potential_value)\n except ValueError:\n return False\n\n return 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 contains(cls, value):\n return value in cls.values()","def contains(cls, value):\n return any(value == item.value for item in cls)","def has_value(cls, value):\n return any(value == item.value for item in cls)","def has_value(cls, value):\n return any(value == item.value for item in cls)","def contains(self, value):\n return value in self.values","def has_value(cls, value):\n return value in [item.value for item in cls]","def has(cls, item):\n return item in cls.values()","def check_enum(enumerator, value):\n is_valid = False\n for data in enumerator:\n if data == value:\n is_valid = True\n break\n\n if is_valid:\n return value\n else:\n my_banner(\"Value must be from enum \" + enumerator +\" Value has been set to N/A\")\n return \"na\"","def __contains__(self, val):\n if self.lookup.get(val, 0) > 0:\n return True\n else:\n return False","def check_enum(self, name, values):\n v = self.__dict__.get(name)\n if v not in values:\n raise ValueError(\n \"Invalid value: {0}='{1}', not in '{2}'\".format(name, v, values))","def __contains__(self, value):\n\n try:\n # Just use __getitem__()\n self[value]\n except KeyError:\n return False\n else:\n return True","def __contains__(self, val):\n return val in [i[0] for i in self.registered_intents]","def __contains__(self, item): # __iter__ would do this job by itself\n return (item in self.__values)","def containsValue(self, value):\n for val in values():\n if val == value or val == value:\n return True\n return False","def is_valid_value(self, value):\n return value in self.values","def __contains__(cls, key):\n return cls.classCase(key) in cls._Registry","def __contains__(self, value):\n found = False\n for i in range(len(self.data)):\n if self.data[i] == value:\n return True\n return found","def test_get_enum_by_value():\n assert BusinessType.get_enum_by_value('CP') == BusinessType.COOPERATIVE\n assert BusinessType.get_enum_by_value('FM') == BusinessType.PARTNERSHIP_AND_SOLE_PROP\n assert BusinessType.get_enum_by_value('NOT_FOUND') is None","def contains(self, val):\n return False if not self.search(val) else True","def is_boost_enum(obj: Any) -> bool:\n for cls in type(obj).__bases__:\n if \"Boost.Python.enum\" in str(cls):\n return True\n return False","def has(self, v):\n return v in self.values","def contains(self, value):\n if self.root is None:\n return False\n else:\n if type(value) != self.typing: # not an error\n return False\n # TODO allow different yet comparable types\n else: \n hasElement, self.root = self.root.contains(value)\n return hasElement","def __contains__(self, item):\n\t\treturn item in self.__dict__.values()","def __contains__(self, value):\n return value in self.var_names","def is_valid(value: str) -> bool:\n if value is None:\n return not is_required\n return value in get_all_class_attr_values(constant_cls)","def __contains__(self, val):\n return val in self.ids or super().__contains__(val)","def __contains__(self, item):\n return item in self.__keys or item in self.__vals","def __contains__(self, flag):\n\n if isinstance(flag, six.integer_types):\n # Pretty easy\n return (self.bitflags & flag) == flag\n elif isinstance(flag, six.string_types):\n # Simple string\n return flag in self.flags\n else:\n try:\n # Make sure all the specified flags are present\n return all(str(self.eset[fl]) in self.flags\n for fl in flag)\n except KeyError:\n return False","def __contains__(self, v):\n for i in self:\n if v in i:\n return True\n False","def __contains__(self, item):\n return item.upper() in self.keys","def contains(self, value):\n if self.root is None:\n return False\n return self.root.contains(value)","def contains(self, val: float) -> bool:\n return self._check_lower(val) and self._check_upper(val)","def contains(self, x: object):\n return x in self.items","def __contains__(self, x):\n return x in (v for v, _ in self)","def __contains__(self, x):\n return x in (v for v, _ in self)","def matches(self, value):\n return value == self.attributes[AT.VALUE]","def __contains__(self, key):\n return self._lookup(key).value is not None","def contains(self, value: T) -> bool:\n def traverse(children: list) -> bool:\n for node in children:\n if node.value == value:\n return True\n else: \n if traverse(node.children):\n return True\n \n if self.value == value:\n return True\n elif traverse(self.children):\n return True\n else:\n return False","def __contains__(self, item):\n\t\tif isinstance(item, basestring):\n\t\t\treturn item in self._channels\n\t\telif hasattr(item, '__iter__'):\n\t\t\treturn all(ch in self._channels for ch in item)\n\t\telse:\n\t\t\treturn False","def contains(self, val):\n\t\treturn Contains(self, val)","def __contains__(self, key):\n return hasattr(self, key)","def contains(self, item):\n return self._dict.has_key(item)\n\n self.__contains__ = contains","def contains(self, val):\n val = self._conversion(val)\n if isinstance(val, TYPES[self.__set_type]):\n return self.__tree.search(val)\n else:\n return str(\"TypeError : Wrong Input\")","def __contains__(self, key):\n return self.keys[self._linear_probe(key, \"contains\")] is not None","def check_token(self, *args) -> bool:\n if len(args) == 1:\n if isinstance(args[0], str):\n return self.token_name == args[0]\n elif isinstance(args[0], _Enum):\n return self.token_name == args[0].name\n elif isinstance(args[0], _Sequence):\n return self.token_name in args[0]\n raise TypeError(\"_check_token() taking 1 argument, type: str, Enum or Sequence\")","def __contains__(self, key):\n try:\n if self[key]:\n return True\n except KeyError:\n return False","def __contains__(self, component):\n if issubclass(component, Component):\n try:\n my_component = self.type.components[component.interface]\n except KeyError:\n return False\n else:\n return issubclass(my_component, component)\n else:\n return component in self.type.components","def check(self, value) -> bool:\n return self._check_helper(value, raise_exceptions=False)","def __contains__(self, item: Any) -> bool:\n try:\n self.__getattr__(item)\n return True\n except RuntimeError:\n return False","def __contains__(self, key):\n found = True\n try:\n self.__getitem__(key)\n except:\n found = False\n return found","def __contains__(self, key):\n try:\n self._get(key)\n return True\n except Exception:\n return False","def __contains__(self, item):\r\n if isinstance(item, six.string_types):\r\n return item in self.iternames()\r\n else:\r\n # let's assume we were given a column\r\n return item in self.iterall()","def is_in(self, e):\n return e in self.vals","def __contains__(self, item):\n try:\n self[item]\n return True\n except KeyError:\n return False","def contains(self, value):\n for item in self.data:\n if item == value:\n return item\n return False","def contains(self, val):\n return not not self.search(val)","def is_isin(value):\n return True","def __contains__(self, elem):\n return elem in list(self)","def has_name(self, name):\n\t\treturn name in self.classes","def __contains__(self, item: Union[T, Rangelike]) -> bool:\n if self == item:\n return True\n with suppress(TypeError):\n if _is_iterable_non_string(item):\n with suppress(ValueError):\n return all(\n any(subitem in rng for rng in self._ranges)\n for subitem in RangeSet._to_rangeset(item)\n )\n return any(item in rng for rng in self._ranges)","def __contains__(self, key):\n try:\n self[key]\n return True\n except:\n return False","def is_valid_value(self, value):\n return value in self.categories","def has_value(value):\n return IsDictContainingValue(wrap_matcher(value))","def isin(self, item):\n return self.get(item) is not None","def __contains__(self, key):\n return key in self._mappings.keys()","def has_name(self, name):\n return name in self.classes","def __contains__(self, code: str) -> bool:\n return code in self._all_codes_map","def __contains__(self, arg):\r\n\r\n return arg in self.grfx[0]","def __contains__(self, key):\n return key in self.keys","def has_name(self, name):\n\t\t\treturn name in self.classes","def __contains__(self, item: OidValue) -> bool:\n item = to_int_tuple(item)\n return self.value == item[0 : len(self.value)]","def contains(self, value):\n\n node, parent, found = self.search(value)\n\n return found","def is_enum(self):\n return False","def __contains__(self, name):\n return hasattr(self, name)","def __contains__(self, name):\n return name in set(self)","def has_value(cls, value):\n return bool(isinstance(value, numbers.Number) or isinstance(value, time) or \\\n isinstance(value, datetime) or value)","def contains(self, key):\n\n return key in self.keys()","def __contains__(self, item):\n # return item in self._items\n # leverage improved performance index() function\n try:\n self.index(item)\n return True\n except ValueError:\n return False","def __contains__(self, item: Any) -> bool:\n try:\n return item in self.contents\n except TypeError:\n try:\n return item is self.contents\n except TypeError:\n return item == self.contents # type: ignore","def __contains__(self, name):\n try:\n self[name]\n return True\n except KeyError:\n return False","def contains(item, obj):\n return obj.__contains__(item)","def __contains__(self, item: Union[Callable, Type, int]) -> bool:\n if isinstance(item, int):\n return item in self._number_map\n if is_annotated_union(item):\n return item in self._constructors_set\n if isinstance(item, type):\n return item in self._combinator_map\n if isfunction(item):\n return item in self._function_map\n\n return False","def check_enumeration_style(ctx, stmt):\n elemtype = stmt.search_one(\"type\")\n if elemtype is None or elemtype.arg != \"enumeration\":\n return\n\n for enum in elemtype.search(\"enum\"):\n if re.match(r\"[a-z]\", enum.arg):\n err_add(ctx.errors, stmt.pos, \"OC_ENUM_CASE\",\n (enum.arg, enum.arg.upper().replace(\"-\", \"_\")))\n elif not re.match(r\"^[A-Z0-9][A-Z0-9\\_\\.]{0,}$\", enum.arg):\n err_add(ctx.errors, stmt.pos, \"OC_ENUM_UNDERSCORES\",\n (enum.arg, enum.arg.upper().replace(\"-\", \"_\")))","def contains(self, value: object) -> bool:\n # iterate tree for value\n curr = self.root\n while curr is not None:\n if value == curr.value:\n return True\n elif value < curr.value:\n curr = curr.left\n else:\n curr = curr.right\n\n # value !=found thus return False\n return False","def __contains__(self, team):\n ### INVARIANT: team is a Team class object.\n return team in self._conf_teams","def __contains__(self, key):\n return self.contains(key)","def __contains__(self, item):\n return self.settings.has(item)","def __contains__(self, i):\n return i in self._ar","def is_value_legit(self, value):\n return value in self.domain and value in self.possible_domain","def contains(self, item):\n if isinstance(item, dict):\n return _(item).all(lambda key: self._.get(key) == item[key])\n return item in self","def has_node(self, val):\n return val in self","def has_node(self, val):\n return val in self","def enum_check(*args, func=None):\n func = func or inspect.stack()[2][3]\n for var in args:\n if not isinstance(var, (enum.EnumMeta, aenum.EnumMeta)):\n name = type(var).__name__\n raise EnumError(\n 'Function {} expected enumeration, {} got instead.'.format(func, name))","def __contains__(self, atom_idx):\n if isinstance(atom_idx, Atom):\n return self.atom_list.__contains__(atom_idx)\n elif isinstance(atom_idx, str):\n return self.atom_dict.__contains__(atom_idx)\n raise TypeError, atom_idx","def __contains__(self, item):\n try:\n hdu = self[item] # noqa\n return True\n except Exception:\n return False","def __contains__(self, seq):\n return bool(libhts.faidx_has_seq(self._fai, seq))","def __contains__(self, item):\n if is_FSMState(item):\n return self.has_state(item)\n if is_FSMTransition(item):\n return self.has_transition(item)\n return False","def is_of_type(cls, value) -> bool:\n # UTF8 = 'utf-8'\n # UTF16 = 'utf-16'\n # UTF32 = 'utf-32'\n # ASCII = 'ascii'\n # BINARY = 'binary'\n # OCTAL = 'octal'\n # HEXADECIMAL = 'hexadecimal'\n # CP1252 = 'cp1252'\n # WINDOWS1252 = 'windows-1252'\n # UNICODEESCAPE = 'unicode-escape'\n\n v = None\n if cls == cls.UTF8 or cls == cls.UTF16 or cls == cls.UTF32 or cls == cls.UNICODEESCAPE:\n try:\n v = bytes(value)\n except:\n return False\n\n if cls == cls.ASCII:\n try:\n v = ascii(value)\n except:\n return False\n\n if cls == cls.BINARY:\n try:\n v = bin(value)\n except:\n return False\n\n if cls == cls.OCTAL:\n try:\n v = oct(value)\n except:\n return False\n\n if cls == cls.HEXADECIMAL:\n try:\n v = hex(value)\n except:\n return False\n\n if cls == cls.WINDOWS1252 or cls == cls.CP1252:\n try:\n v = str(value)\n except:\n return False\n return True","def in_list(value, arg):\r\n return value in arg","def contains(self, key: int) -> bool:\n return self._find_key(key, find_empty=False) >= 0"],"string":"[\n \"def contains(cls, value):\\n return value in cls.values()\",\n \"def contains(cls, value):\\n return any(value == item.value for item in cls)\",\n \"def has_value(cls, value):\\n return any(value == item.value for item in cls)\",\n \"def has_value(cls, value):\\n return any(value == item.value for item in cls)\",\n \"def contains(self, value):\\n return value in self.values\",\n \"def has_value(cls, value):\\n return value in [item.value for item in cls]\",\n \"def has(cls, item):\\n return item in cls.values()\",\n \"def check_enum(enumerator, value):\\n is_valid = False\\n for data in enumerator:\\n if data == value:\\n is_valid = True\\n break\\n\\n if is_valid:\\n return value\\n else:\\n my_banner(\\\"Value must be from enum \\\" + enumerator +\\\" Value has been set to N/A\\\")\\n return \\\"na\\\"\",\n \"def __contains__(self, val):\\n if self.lookup.get(val, 0) > 0:\\n return True\\n else:\\n return False\",\n \"def check_enum(self, name, values):\\n v = self.__dict__.get(name)\\n if v not in values:\\n raise ValueError(\\n \\\"Invalid value: {0}='{1}', not in '{2}'\\\".format(name, v, values))\",\n \"def __contains__(self, value):\\n\\n try:\\n # Just use __getitem__()\\n self[value]\\n except KeyError:\\n return False\\n else:\\n return True\",\n \"def __contains__(self, val):\\n return val in [i[0] for i in self.registered_intents]\",\n \"def __contains__(self, item): # __iter__ would do this job by itself\\n return (item in self.__values)\",\n \"def containsValue(self, value):\\n for val in values():\\n if val == value or val == value:\\n return True\\n return False\",\n \"def is_valid_value(self, value):\\n return value in self.values\",\n \"def __contains__(cls, key):\\n return cls.classCase(key) in cls._Registry\",\n \"def __contains__(self, value):\\n found = False\\n for i in range(len(self.data)):\\n if self.data[i] == value:\\n return True\\n return found\",\n \"def test_get_enum_by_value():\\n assert BusinessType.get_enum_by_value('CP') == BusinessType.COOPERATIVE\\n assert BusinessType.get_enum_by_value('FM') == BusinessType.PARTNERSHIP_AND_SOLE_PROP\\n assert BusinessType.get_enum_by_value('NOT_FOUND') is None\",\n \"def contains(self, val):\\n return False if not self.search(val) else True\",\n \"def is_boost_enum(obj: Any) -> bool:\\n for cls in type(obj).__bases__:\\n if \\\"Boost.Python.enum\\\" in str(cls):\\n return True\\n return False\",\n \"def has(self, v):\\n return v in self.values\",\n \"def contains(self, value):\\n if self.root is None:\\n return False\\n else:\\n if type(value) != self.typing: # not an error\\n return False\\n # TODO allow different yet comparable types\\n else: \\n hasElement, self.root = self.root.contains(value)\\n return hasElement\",\n \"def __contains__(self, item):\\n\\t\\treturn item in self.__dict__.values()\",\n \"def __contains__(self, value):\\n return value in self.var_names\",\n \"def is_valid(value: str) -> bool:\\n if value is None:\\n return not is_required\\n return value in get_all_class_attr_values(constant_cls)\",\n \"def __contains__(self, val):\\n return val in self.ids or super().__contains__(val)\",\n \"def __contains__(self, item):\\n return item in self.__keys or item in self.__vals\",\n \"def __contains__(self, flag):\\n\\n if isinstance(flag, six.integer_types):\\n # Pretty easy\\n return (self.bitflags & flag) == flag\\n elif isinstance(flag, six.string_types):\\n # Simple string\\n return flag in self.flags\\n else:\\n try:\\n # Make sure all the specified flags are present\\n return all(str(self.eset[fl]) in self.flags\\n for fl in flag)\\n except KeyError:\\n return False\",\n \"def __contains__(self, v):\\n for i in self:\\n if v in i:\\n return True\\n False\",\n \"def __contains__(self, item):\\n return item.upper() in self.keys\",\n \"def contains(self, value):\\n if self.root is None:\\n return False\\n return self.root.contains(value)\",\n \"def contains(self, val: float) -> bool:\\n return self._check_lower(val) and self._check_upper(val)\",\n \"def contains(self, x: object):\\n return x in self.items\",\n \"def __contains__(self, x):\\n return x in (v for v, _ in self)\",\n \"def __contains__(self, x):\\n return x in (v for v, _ in self)\",\n \"def matches(self, value):\\n return value == self.attributes[AT.VALUE]\",\n \"def __contains__(self, key):\\n return self._lookup(key).value is not None\",\n \"def contains(self, value: T) -> bool:\\n def traverse(children: list) -> bool:\\n for node in children:\\n if node.value == value:\\n return True\\n else: \\n if traverse(node.children):\\n return True\\n \\n if self.value == value:\\n return True\\n elif traverse(self.children):\\n return True\\n else:\\n return False\",\n \"def __contains__(self, item):\\n\\t\\tif isinstance(item, basestring):\\n\\t\\t\\treturn item in self._channels\\n\\t\\telif hasattr(item, '__iter__'):\\n\\t\\t\\treturn all(ch in self._channels for ch in item)\\n\\t\\telse:\\n\\t\\t\\treturn False\",\n \"def contains(self, val):\\n\\t\\treturn Contains(self, val)\",\n \"def __contains__(self, key):\\n return hasattr(self, key)\",\n \"def contains(self, item):\\n return self._dict.has_key(item)\\n\\n self.__contains__ = contains\",\n \"def contains(self, val):\\n val = self._conversion(val)\\n if isinstance(val, TYPES[self.__set_type]):\\n return self.__tree.search(val)\\n else:\\n return str(\\\"TypeError : Wrong Input\\\")\",\n \"def __contains__(self, key):\\n return self.keys[self._linear_probe(key, \\\"contains\\\")] is not None\",\n \"def check_token(self, *args) -> bool:\\n if len(args) == 1:\\n if isinstance(args[0], str):\\n return self.token_name == args[0]\\n elif isinstance(args[0], _Enum):\\n return self.token_name == args[0].name\\n elif isinstance(args[0], _Sequence):\\n return self.token_name in args[0]\\n raise TypeError(\\\"_check_token() taking 1 argument, type: str, Enum or Sequence\\\")\",\n \"def __contains__(self, key):\\n try:\\n if self[key]:\\n return True\\n except KeyError:\\n return False\",\n \"def __contains__(self, component):\\n if issubclass(component, Component):\\n try:\\n my_component = self.type.components[component.interface]\\n except KeyError:\\n return False\\n else:\\n return issubclass(my_component, component)\\n else:\\n return component in self.type.components\",\n \"def check(self, value) -> bool:\\n return self._check_helper(value, raise_exceptions=False)\",\n \"def __contains__(self, item: Any) -> bool:\\n try:\\n self.__getattr__(item)\\n return True\\n except RuntimeError:\\n return False\",\n \"def __contains__(self, key):\\n found = True\\n try:\\n self.__getitem__(key)\\n except:\\n found = False\\n return found\",\n \"def __contains__(self, key):\\n try:\\n self._get(key)\\n return True\\n except Exception:\\n return False\",\n \"def __contains__(self, item):\\r\\n if isinstance(item, six.string_types):\\r\\n return item in self.iternames()\\r\\n else:\\r\\n # let's assume we were given a column\\r\\n return item in self.iterall()\",\n \"def is_in(self, e):\\n return e in self.vals\",\n \"def __contains__(self, item):\\n try:\\n self[item]\\n return True\\n except KeyError:\\n return False\",\n \"def contains(self, value):\\n for item in self.data:\\n if item == value:\\n return item\\n return False\",\n \"def contains(self, val):\\n return not not self.search(val)\",\n \"def is_isin(value):\\n return True\",\n \"def __contains__(self, elem):\\n return elem in list(self)\",\n \"def has_name(self, name):\\n\\t\\treturn name in self.classes\",\n \"def __contains__(self, item: Union[T, Rangelike]) -> bool:\\n if self == item:\\n return True\\n with suppress(TypeError):\\n if _is_iterable_non_string(item):\\n with suppress(ValueError):\\n return all(\\n any(subitem in rng for rng in self._ranges)\\n for subitem in RangeSet._to_rangeset(item)\\n )\\n return any(item in rng for rng in self._ranges)\",\n \"def __contains__(self, key):\\n try:\\n self[key]\\n return True\\n except:\\n return False\",\n \"def is_valid_value(self, value):\\n return value in self.categories\",\n \"def has_value(value):\\n return IsDictContainingValue(wrap_matcher(value))\",\n \"def isin(self, item):\\n return self.get(item) is not None\",\n \"def __contains__(self, key):\\n return key in self._mappings.keys()\",\n \"def has_name(self, name):\\n return name in self.classes\",\n \"def __contains__(self, code: str) -> bool:\\n return code in self._all_codes_map\",\n \"def __contains__(self, arg):\\r\\n\\r\\n return arg in self.grfx[0]\",\n \"def __contains__(self, key):\\n return key in self.keys\",\n \"def has_name(self, name):\\n\\t\\t\\treturn name in self.classes\",\n \"def __contains__(self, item: OidValue) -> bool:\\n item = to_int_tuple(item)\\n return self.value == item[0 : len(self.value)]\",\n \"def contains(self, value):\\n\\n node, parent, found = self.search(value)\\n\\n return found\",\n \"def is_enum(self):\\n return False\",\n \"def __contains__(self, name):\\n return hasattr(self, name)\",\n \"def __contains__(self, name):\\n return name in set(self)\",\n \"def has_value(cls, value):\\n return bool(isinstance(value, numbers.Number) or isinstance(value, time) or \\\\\\n isinstance(value, datetime) or value)\",\n \"def contains(self, key):\\n\\n return key in self.keys()\",\n \"def __contains__(self, item):\\n # return item in self._items\\n # leverage improved performance index() function\\n try:\\n self.index(item)\\n return True\\n except ValueError:\\n return False\",\n \"def __contains__(self, item: Any) -> bool:\\n try:\\n return item in self.contents\\n except TypeError:\\n try:\\n return item is self.contents\\n except TypeError:\\n return item == self.contents # type: ignore\",\n \"def __contains__(self, name):\\n try:\\n self[name]\\n return True\\n except KeyError:\\n return False\",\n \"def contains(item, obj):\\n return obj.__contains__(item)\",\n \"def __contains__(self, item: Union[Callable, Type, int]) -> bool:\\n if isinstance(item, int):\\n return item in self._number_map\\n if is_annotated_union(item):\\n return item in self._constructors_set\\n if isinstance(item, type):\\n return item in self._combinator_map\\n if isfunction(item):\\n return item in self._function_map\\n\\n return False\",\n \"def check_enumeration_style(ctx, stmt):\\n elemtype = stmt.search_one(\\\"type\\\")\\n if elemtype is None or elemtype.arg != \\\"enumeration\\\":\\n return\\n\\n for enum in elemtype.search(\\\"enum\\\"):\\n if re.match(r\\\"[a-z]\\\", enum.arg):\\n err_add(ctx.errors, stmt.pos, \\\"OC_ENUM_CASE\\\",\\n (enum.arg, enum.arg.upper().replace(\\\"-\\\", \\\"_\\\")))\\n elif not re.match(r\\\"^[A-Z0-9][A-Z0-9\\\\_\\\\.]{0,}$\\\", enum.arg):\\n err_add(ctx.errors, stmt.pos, \\\"OC_ENUM_UNDERSCORES\\\",\\n (enum.arg, enum.arg.upper().replace(\\\"-\\\", \\\"_\\\")))\",\n \"def contains(self, value: object) -> bool:\\n # iterate tree for value\\n curr = self.root\\n while curr is not None:\\n if value == curr.value:\\n return True\\n elif value < curr.value:\\n curr = curr.left\\n else:\\n curr = curr.right\\n\\n # value !=found thus return False\\n return False\",\n \"def __contains__(self, team):\\n ### INVARIANT: team is a Team class object.\\n return team in self._conf_teams\",\n \"def __contains__(self, key):\\n return self.contains(key)\",\n \"def __contains__(self, item):\\n return self.settings.has(item)\",\n \"def __contains__(self, i):\\n return i in self._ar\",\n \"def is_value_legit(self, value):\\n return value in self.domain and value in self.possible_domain\",\n \"def contains(self, item):\\n if isinstance(item, dict):\\n return _(item).all(lambda key: self._.get(key) == item[key])\\n return item in self\",\n \"def has_node(self, val):\\n return val in self\",\n \"def has_node(self, val):\\n return val in self\",\n \"def enum_check(*args, func=None):\\n func = func or inspect.stack()[2][3]\\n for var in args:\\n if not isinstance(var, (enum.EnumMeta, aenum.EnumMeta)):\\n name = type(var).__name__\\n raise EnumError(\\n 'Function {} expected enumeration, {} got instead.'.format(func, name))\",\n \"def __contains__(self, atom_idx):\\n if isinstance(atom_idx, Atom):\\n return self.atom_list.__contains__(atom_idx)\\n elif isinstance(atom_idx, str):\\n return self.atom_dict.__contains__(atom_idx)\\n raise TypeError, atom_idx\",\n \"def __contains__(self, item):\\n try:\\n hdu = self[item] # noqa\\n return True\\n except Exception:\\n return False\",\n \"def __contains__(self, seq):\\n return bool(libhts.faidx_has_seq(self._fai, seq))\",\n \"def __contains__(self, item):\\n if is_FSMState(item):\\n return self.has_state(item)\\n if is_FSMTransition(item):\\n return self.has_transition(item)\\n return False\",\n \"def is_of_type(cls, value) -> bool:\\n # UTF8 = 'utf-8'\\n # UTF16 = 'utf-16'\\n # UTF32 = 'utf-32'\\n # ASCII = 'ascii'\\n # BINARY = 'binary'\\n # OCTAL = 'octal'\\n # HEXADECIMAL = 'hexadecimal'\\n # CP1252 = 'cp1252'\\n # WINDOWS1252 = 'windows-1252'\\n # UNICODEESCAPE = 'unicode-escape'\\n\\n v = None\\n if cls == cls.UTF8 or cls == cls.UTF16 or cls == cls.UTF32 or cls == cls.UNICODEESCAPE:\\n try:\\n v = bytes(value)\\n except:\\n return False\\n\\n if cls == cls.ASCII:\\n try:\\n v = ascii(value)\\n except:\\n return False\\n\\n if cls == cls.BINARY:\\n try:\\n v = bin(value)\\n except:\\n return False\\n\\n if cls == cls.OCTAL:\\n try:\\n v = oct(value)\\n except:\\n return False\\n\\n if cls == cls.HEXADECIMAL:\\n try:\\n v = hex(value)\\n except:\\n return False\\n\\n if cls == cls.WINDOWS1252 or cls == cls.CP1252:\\n try:\\n v = str(value)\\n except:\\n return False\\n return True\",\n \"def in_list(value, arg):\\r\\n return value in arg\",\n \"def contains(self, key: int) -> bool:\\n return self._find_key(key, find_empty=False) >= 0\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7130909","0.6671945","0.66446143","0.66446143","0.6463414","0.64291495","0.64076877","0.63996106","0.61606634","0.613417","0.61334","0.6130707","0.6110766","0.6105736","0.6105704","0.60750055","0.60390246","0.6028632","0.602763","0.60264736","0.60111135","0.59741986","0.5972562","0.5947551","0.58172387","0.5794406","0.5787283","0.57828224","0.5779117","0.57786983","0.57744914","0.57562023","0.5723498","0.5722505","0.5722505","0.5712859","0.5712289","0.5696037","0.5628074","0.56184494","0.56149423","0.56130683","0.5609264","0.55996364","0.55979705","0.5595615","0.5583901","0.557529","0.55702627","0.5559662","0.55583054","0.554727","0.55364835","0.5534317","0.55329776","0.55143774","0.551049","0.55025214","0.5495244","0.5487047","0.54692596","0.5460809","0.54568326","0.54545623","0.54526204","0.5448187","0.54420996","0.54416","0.5439557","0.54392135","0.5434277","0.5429703","0.5422432","0.54128134","0.54109913","0.5409714","0.5406659","0.5405096","0.53880113","0.53829396","0.5381852","0.53780735","0.53584445","0.53555167","0.5350942","0.5346883","0.534505","0.5337761","0.5330821","0.5327402","0.53148824","0.53148824","0.5311275","0.53073496","0.5305189","0.53047067","0.52955186","0.5295515","0.52906364","0.5290267"],"string":"[\n \"0.7130909\",\n \"0.6671945\",\n \"0.66446143\",\n \"0.66446143\",\n \"0.6463414\",\n \"0.64291495\",\n \"0.64076877\",\n \"0.63996106\",\n \"0.61606634\",\n \"0.613417\",\n \"0.61334\",\n \"0.6130707\",\n \"0.6110766\",\n \"0.6105736\",\n \"0.6105704\",\n \"0.60750055\",\n \"0.60390246\",\n \"0.6028632\",\n \"0.602763\",\n \"0.60264736\",\n \"0.60111135\",\n \"0.59741986\",\n \"0.5972562\",\n \"0.5947551\",\n \"0.58172387\",\n \"0.5794406\",\n \"0.5787283\",\n \"0.57828224\",\n \"0.5779117\",\n \"0.57786983\",\n \"0.57744914\",\n \"0.57562023\",\n \"0.5723498\",\n \"0.5722505\",\n \"0.5722505\",\n \"0.5712859\",\n \"0.5712289\",\n \"0.5696037\",\n \"0.5628074\",\n \"0.56184494\",\n \"0.56149423\",\n \"0.56130683\",\n \"0.5609264\",\n \"0.55996364\",\n \"0.55979705\",\n \"0.5595615\",\n \"0.5583901\",\n \"0.557529\",\n \"0.55702627\",\n \"0.5559662\",\n \"0.55583054\",\n \"0.554727\",\n \"0.55364835\",\n \"0.5534317\",\n \"0.55329776\",\n \"0.55143774\",\n \"0.551049\",\n \"0.55025214\",\n \"0.5495244\",\n \"0.5487047\",\n \"0.54692596\",\n \"0.5460809\",\n \"0.54568326\",\n \"0.54545623\",\n \"0.54526204\",\n \"0.5448187\",\n \"0.54420996\",\n \"0.54416\",\n \"0.5439557\",\n \"0.54392135\",\n \"0.5434277\",\n \"0.5429703\",\n \"0.5422432\",\n \"0.54128134\",\n \"0.54109913\",\n \"0.5409714\",\n \"0.5406659\",\n \"0.5405096\",\n \"0.53880113\",\n \"0.53829396\",\n \"0.5381852\",\n \"0.53780735\",\n \"0.53584445\",\n \"0.53555167\",\n \"0.5350942\",\n \"0.5346883\",\n \"0.534505\",\n \"0.5337761\",\n \"0.5330821\",\n \"0.5327402\",\n \"0.53148824\",\n \"0.53148824\",\n \"0.5311275\",\n \"0.53073496\",\n \"0.5305189\",\n \"0.53047067\",\n \"0.52955186\",\n \"0.5295515\",\n \"0.52906364\",\n \"0.5290267\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7098082"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":93189,"cells":{"query":{"kind":"string","value":"A utility function that checks if the tag is a valid attribute tag."},"document":{"kind":"string","value":"def is_attribute(tag, kmip_version=None):\n kmip_1_0_attribute_tags = [\n Tags.UNIQUE_IDENTIFIER,\n Tags.NAME,\n Tags.OBJECT_TYPE,\n Tags.CRYPTOGRAPHIC_ALGORITHM,\n Tags.CRYPTOGRAPHIC_LENGTH,\n Tags.CRYPTOGRAPHIC_PARAMETERS,\n Tags.CRYPTOGRAPHIC_DOMAIN_PARAMETERS,\n Tags.CERTIFICATE_TYPE,\n Tags.CERTIFICATE_IDENTIFIER,\n Tags.CERTIFICATE_SUBJECT,\n Tags.CERTIFICATE_ISSUER,\n Tags.DIGEST,\n Tags.OPERATION_POLICY_NAME,\n Tags.CRYPTOGRAPHIC_USAGE_MASK,\n Tags.LEASE_TIME,\n Tags.USAGE_LIMITS,\n Tags.STATE,\n Tags.INITIAL_DATE,\n Tags.ACTIVATION_DATE,\n Tags.PROCESS_START_DATE,\n Tags.PROTECT_STOP_DATE,\n Tags.DEACTIVATION_DATE,\n Tags.DESTROY_DATE,\n Tags.COMPROMISE_OCCURRENCE_DATE,\n Tags.COMPROMISE_DATE,\n Tags.REVOCATION_REASON,\n Tags.ARCHIVE_DATE,\n Tags.OBJECT_GROUP,\n Tags.LINK,\n Tags.APPLICATION_SPECIFIC_INFORMATION,\n Tags.CONTACT_INFORMATION,\n Tags.LAST_CHANGE_DATE,\n Tags.CUSTOM_ATTRIBUTE\n ]\n kmip_1_1_attribute_tags = copy.deepcopy(kmip_1_0_attribute_tags) + [\n Tags.CERTIFICATE_LENGTH,\n Tags.X_509_CERTIFICATE_IDENTIFIER,\n Tags.X_509_CERTIFICATE_SUBJECT,\n Tags.X_509_CERTIFICATE_ISSUER,\n Tags.DIGITAL_SIGNATURE_ALGORITHM,\n Tags.FRESH\n ]\n kmip_1_2_attribute_tags = copy.deepcopy(kmip_1_1_attribute_tags) + [\n Tags.ALTERNATIVE_NAME,\n Tags.KEY_VALUE_PRESENT,\n Tags.KEY_VALUE_LOCATION,\n Tags.ORIGINAL_CREATION_DATE\n ]\n kmip_1_3_attribute_tags = copy.deepcopy(kmip_1_2_attribute_tags) + [\n Tags.RANDOM_NUMBER_GENERATOR\n ]\n kmip_1_4_attribute_tags = copy.deepcopy(kmip_1_3_attribute_tags) + [\n Tags.PKCS12_FRIENDLY_NAME,\n Tags.DESCRIPTION,\n Tags.COMMENT,\n Tags.SENSITIVE,\n Tags.ALWAYS_SENSITIVE,\n Tags.EXTRACTABLE,\n Tags.NEVER_EXTRACTABLE\n ]\n kmip_2_0_attribute_tags = copy.deepcopy(kmip_1_4_attribute_tags) + [\n Tags.CERTIFICATE_SUBJECT_CN,\n Tags.CERTIFICATE_SUBJECT_O,\n Tags.CERTIFICATE_SUBJECT_OU,\n Tags.CERTIFICATE_SUBJECT_EMAIL,\n Tags.CERTIFICATE_SUBJECT_C,\n Tags.CERTIFICATE_SUBJECT_ST,\n Tags.CERTIFICATE_SUBJECT_L,\n Tags.CERTIFICATE_SUBJECT_UID,\n Tags.CERTIFICATE_SUBJECT_SERIAL_NUMBER,\n Tags.CERTIFICATE_SUBJECT_TITLE,\n Tags.CERTIFICATE_SUBJECT_DC,\n Tags.CERTIFICATE_SUBJECT_DN_QUALIFIER,\n Tags.CERTIFICATE_ISSUER_CN,\n Tags.CERTIFICATE_ISSUER_O,\n Tags.CERTIFICATE_ISSUER_OU,\n Tags.CERTIFICATE_ISSUER_EMAIL,\n Tags.CERTIFICATE_ISSUER_C,\n Tags.CERTIFICATE_ISSUER_ST,\n Tags.CERTIFICATE_ISSUER_L,\n Tags.CERTIFICATE_ISSUER_UID,\n Tags.CERTIFICATE_ISSUER_SERIAL_NUMBER,\n Tags.CERTIFICATE_ISSUER_TITLE,\n Tags.CERTIFICATE_ISSUER_DC,\n Tags.CERTIFICATE_ISSUER_DN_QUALIFIER,\n Tags.KEY_FORMAT_TYPE,\n Tags.NIST_KEY_TYPE,\n Tags.OPAQUE_DATA_TYPE,\n Tags.PROTECTION_LEVEL,\n Tags.PROTECTION_PERIOD,\n Tags.PROTECTION_STORAGE_MASK,\n Tags.QUANTUM_SAFE,\n Tags.SHORT_UNIQUE_IDENTIFIER,\n Tags.ATTRIBUTE\n ]\n kmip_2_0_attribute_tags.remove(Tags.CERTIFICATE_IDENTIFIER)\n kmip_2_0_attribute_tags.remove(Tags.CERTIFICATE_SUBJECT)\n kmip_2_0_attribute_tags.remove(Tags.CERTIFICATE_ISSUER)\n kmip_2_0_attribute_tags.remove(Tags.OPERATION_POLICY_NAME)\n kmip_2_0_attribute_tags.remove(Tags.CUSTOM_ATTRIBUTE)\n\n if kmip_version == KMIPVersion.KMIP_1_0:\n return tag in kmip_1_0_attribute_tags\n elif kmip_version == KMIPVersion.KMIP_1_1:\n return tag in kmip_1_1_attribute_tags\n elif kmip_version == KMIPVersion.KMIP_1_2:\n return tag in kmip_1_2_attribute_tags\n elif kmip_version == KMIPVersion.KMIP_1_3:\n return tag in kmip_1_3_attribute_tags\n elif kmip_version == KMIPVersion.KMIP_1_4:\n return tag in kmip_1_4_attribute_tags\n elif kmip_version == KMIPVersion.KMIP_2_0:\n return tag in kmip_2_0_attribute_tags\n else:\n all_attribute_tags = set(\n kmip_1_0_attribute_tags +\n kmip_1_1_attribute_tags +\n kmip_1_2_attribute_tags +\n kmip_1_3_attribute_tags +\n kmip_1_4_attribute_tags +\n kmip_2_0_attribute_tags\n )\n return tag in all_attribute_tags"},"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 is_valid_attribute(self, attr):\n try:\n self.validate_attribute(attr)\n return True\n except etal.LabelsSchemaError:\n return False","def is_valid_attribute(self, attr):\n try:\n self.validate_attribute(attr)\n return True\n except etal.LabelsSchemaError:\n return False","def validate_attribute(self, attr):\n self.attrs.validate_attribute(attr)","def is_valid_attribute(self, attr):\n return self.is_valid(attr)","def is_element_attribute(element, attribute_name):\n return element.get(attribute_name) is not None","def is_valid_attribute_name(self, name):\n try:\n self.validate_attribute_name(name)\n return True\n except etal.LabelsSchemaError:\n return False","def is_valid_attributes(self, attrs):\n try:\n self.validate_attributes(attrs)\n return True\n except etal.LabelsSchemaError:\n return False","def validate(attrs):\n try:\n #required_attributes = ('qquuid', 'qqfilename')\n #[attrs.get(k) for k,v in attrs.items()]\n return True\n except Exception, e:\n return False","def validate_attributes(self, attrs):\n self.attrs.validate(attrs)","def validate(attrs):\n print \"I GOT HERE.\"\n try:\n #required_attributes = ('qquuid', 'qqfilename')\n #[attrs.get(k) for k,v in attrs.items()]\n return True\n except Exception, e:\n return False","def validate_tag(tag=None):\n if not tag:\n raise AttributeError('Tag cannot be empty')\n\n if tag not in TAGS:\n raise ValueError('{0} tag is not supported')","def hasAttr(self, *args):\n return _libsbml.XMLToken_hasAttr(self, *args)","def validate_attribute(self, attr):\n self.validate(attr)","def is_valid(self, attr: Optional[str] = None) -> bool:\n try:\n self.validate(attr)\n except (TypeError, ValueError):\n return False\n return True","def is_valid_tag(tag):\n if not tag or ':' not in tag or len(tag) > TAG_MAX_LEN:\n return False\n # Care only about the key. Value can be anything (including empty string).\n return bool(TAG_KEY_RE.match(tag.split(':', 1)[0]))","def validate_attribute(self, attr):\n self.validate_attribute_name(attr.name)\n self.schema[attr.name].validate_attribute(attr)","def isAttribute(self, p_int): # real signature unknown; restored from __doc__\n return False","def valid_att_in_field(arch, **kwargs):\n return not arch.xpath('//field[not(@name)]')","def is_attribute(self):\r\n return conf.lib.clang_isAttribute(self)","def is_valid(self, attribute: Attribute) -> bool:\n return self.get_data_type() == attribute.type","def validate_attribute_name(self, name):\n if not self.has_attribute(name):\n raise AttributeContainerSchemaError(\n \"Attribute '%s' is not allowed by the schema\" % name\n )","def is_attr_exist(self, section_name: str, attr_name: str) -> bool:\n pass","def assert_valid_attribute(self, name):\n if name.startswith('_'):\n return\n self.assert_known_field(name)","def isValidTagName(s):\n if s.lower().startswith(\"xml\"):\n return False\n return re.match(\"[^\\W\\d][\\w\\-_.]*\", s)","def is_valid_type(self, attr: Optional[str] = None) -> bool:\n try:\n self.validate_type(attr)\n except TypeError:\n return False\n return True","def has_attr(self, key):\n return key in self.attrs","def validate_string_attribute(tag, attribute_name, attribute_value):\n if not attribute_value:\n return\n\n if not isinstance(attribute_value, str):\n raise AttributeValueError('<{tag}>: {attribute_name} should be a '\n 'string value.'\n .format(tag=tag,\n attribute_name=attribute_name))","def is_valid_keypoints_attribute(self, label, attr):\n try:\n self.validate_keypoints_attribute(label, attr)\n return True\n except etal.LabelsSchemaError:\n return False","def valid_mitre_att(self, rule_to_validate_mitre_att, tag_index):\r\n self.required_fields[MITRE_ATT].attributefound()\r\n self.required_fields_index[self.required_fields[MITRE_ATT].position].increment_count()\r\n\r\n metadata = rule_to_validate_mitre_att[METADATA]\r\n mitre_att_to_validate = str(metadata[tag_index][MITRE_ATT]).upper()\r\n metadata[tag_index][MITRE_ATT] = mitre_att_to_validate\r\n if self.validate_mitre_att_by_id(mitre_att_to_validate):\r\n self.required_fields[MITRE_ATT].attributevalid()\r\n else:\r\n self.required_fields[MITRE_ATT].attributeinvalid()\r\n\r\n return self.required_fields[MITRE_ATT].valid","def test_attribute(self):\n xp = XPathQuery(\"/foo[@attrib1]\")\n self.assertEqual(xp.matches(self.e), True)","def hasAttribute(self, *args):\n return _libsbml.XMLAttributes_hasAttribute(self, *args)","def is_valid_keypoints_attributes(self, label, attrs):\n try:\n self.validate_keypoints_attributes(label, attrs)\n return True\n except etal.LabelsSchemaError:\n return False","def checkattr(name):\n\n def check(obj):\n try:\n attrgetter(name)(obj)\n return True\n except AttributeError:\n return False\n\n return check","def validate_boolean_attribute(tag, attribute_name, attribute_value):\n if not attribute_value:\n return\n\n if not isinstance(attribute_value, bool):\n raise AttributeError('<{tag}>: {attribute_name} attribute should be a '\n 'boolean value.'\n .format(tag=tag, attribute_name=attribute_name))","def htmlIsScriptAttribute(name):\n ret = libxml2mod.htmlIsScriptAttribute(name)\n return ret","def has_attribute(*attrs):\n\n @meta\n def check(cls):\n return all(hasattr(cls, a) for a in attrs)\n\n return check","def validate_number_attribute(tag, attribute_name, attribute_value):\n if not attribute_value:\n return\n\n # If the given attribute value is either integer/float, then return the\n # value.\n if isinstance(attribute_value, (int, float)):\n return attribute_value\n # Give attribute value can be a string. For example, the given attribute\n # value can be '1'. When we do int('1') --> returns 1. The same logic\n # works in float values also. So, if we do float('1.23') --> returns 1.23.\n # If both the cases fail, then we raise an AttributeError.\n elif isinstance(attribute_value, str):\n try:\n return int(attribute_value)\n except ValueError:\n try:\n return float(attribute_value)\n except ValueError:\n raise AttributeValueError('<{tag}>: {attribute} attribute '\n 'should be an integer or float value'\n .format(tag=tag,\n attribute=attribute_name))\n else:\n # In rest all the cases, the attribute value is not a valid int/float\n # value.\n raise AttributeValueError('<{tag}>: {attribute} attribute should be an'\n ' integer or float value'\n .format(tag=tag, attribute=attribute_name))","def hasAttribute(self, attrib):\n return self._dqa(attrib) in self.attributes","def check_attributes(self):\n self.assertEqual(type(self.amenity_1.name), str)","def validate(self, attr):\n if attr.name != self.name:\n raise AttributeSchemaError(\n \"Expected name '%s'; found '%s'\" % (self.name, attr.name)\n )\n\n self.validate_type(attr)\n\n if not self.is_valid_value(attr.value):\n raise AttributeSchemaError(\n \"Value '%s' of attribute '%s' is not allowed by the \"\n \"schema \" % (attr.value, attr.name)\n )","def hasAttribute(self, p_str, p_str_1=None): # real signature unknown; restored from __doc__ with multiple overloads\n return False","def is_attname(name):\n test = re.search(\"^@[a-z]+\", name)\n if test:\n return True\n else:\n return False","def valid_att_in_label(arch, **kwargs):\n return not arch.xpath('//label[not(@for) and not(descendant::input)]')","def validateAttribute(self, attributeName):\n if (not attributeName in self._attributes):\n raise pcssErrors.PcssGlobalException(\"Error: attempted to set attribute %s which is not a valid pfa attribute\" % attributeName)","def validate_date_attribute(tag, attribute_name, attribute_value):\n if not attribute_value:\n return\n\n # TODO: This can be extended to multiple datetime types. For example,\n # packages like zulu, Arrow, etc. have their own types but they all are\n # valid datetime types. Those can be added in the future.\n if isinstance(attribute_value, (datetime.datetime, datetime.date)):\n return attribute_value\n else:\n raise AttributeError('<{tag}>: {attribute} attribute should be a '\n 'date/datetime value.'\n .format(tag=tag, attribute=attribute_name))","def validate_type(self, attr):\n if not isinstance(attr, self._attr_cls):\n raise AttributeSchemaError(\n \"Expected attribute '%s' to have type '%s'; found '%s'\"\n % (attr.name, self.type, etau.get_class_name(attr))\n )","def _entry_tag_is_valid(entry: _LexiconEntry) -> None:\n tag = _tag_of(entry)\n\n if tag not in tags.VALID_TAGS:\n raise InvalidLexiconEntryError(\n \"Entry 'tag' field has invalid value. It can only be one of the valid\"\n \" tags that are defined in 'morphotactics_compiler/tags.py'.\")","def compareAttribute(self, attrib, value):\n return self.attributes.get(self._dqa(attrib), None) == value","def validNormalizeAttributeValue(self, doc, name, value):\n if doc is None: doc__o = None\n else: doc__o = doc._o\n ret = libxml2mod.xmlValidNormalizeAttributeValue(doc__o, self._o, name, value)\n return ret","def check_param(cls, key, val) -> None:\n\n # Check if attribute is valid for this resource at all\n if key not in cls._Attributes:\n raise TypeError(\"Unexpected attribute '{}' for resource '{}'\".format(\n key,\n cls))\n\n Attribute = cls._Attributes[key]\n\n # Check if attribute is null and is allowed to be null\n if Attribute['optional'] and val is None:\n return\n\n # Check if attribute has correct type\n if Attribute['list']:\n msg = \"Attribute '{}' of resource {} has to be of type list of '{}'\".format(\n key,\n cls,\n Attribute['type'])\n if not isinstance(val, list):\n raise TypeError(msg)\n for item in val:\n if not isinstance(item, Attribute['type']):\n raise TypeError(msg)\n else:\n msg = \"Attribute '{}' of resource {} has to be of type '{}'\".format(\n key,\n cls,\n Attribute['type'])\n if not isinstance(val, Attribute['type']):\n raise TypeError(msg)\n\n # Check all checks\n if 'checks' in Attribute:\n msg = \"Illegal value '{}' for attribute '{}' of resource {}\".format(\n val,\n key,\n cls)\n for value_check in Attribute['checks']:\n if value_check(cls, val) is False:\n raise ValueError(msg)","def _validability(self, ability):\n return isinstance(ability, AttributeAbility)","def check(self, description: Description) -> bool:\n # if the name of the attribute is not present, return false.\n name = self.attribute_name\n if name not in description.values:\n return False\n\n # if the type of the value is different from the type of the attribute, return false.\n value = description.values[name]\n if type(self.constraint_type.value) in {list, tuple, set} and not isinstance(\n value, type(next(iter(self.constraint_type.value)))\n ):\n return False\n if type(self.constraint_type.value) not in {\n list,\n tuple,\n set,\n } and not isinstance(value, type(self.constraint_type.value)):\n return False\n\n # dispatch the check to the right implementation for the concrete constraint type.\n return self.constraint_type.check(value)","def testattributes(self):\n for attr in AmuletAbility.attributes:\n a = AmuletAbility('Attribute', attr=attr)\n self.assert_(attr in str(a))\n self.assertEqual(a.attribute, attr)\n self.assertTrue(isinstance(a.AC, int))\n self.assertTrue(isinstance(a.description(), str))","def is_format_wrong(soup):\n a = soup.find('a')\n if a.has_attr('faire'):\n return True\n return False","def validate_attribute_values(tag,\n attribute_name,\n attribute_value,\n default_values):\n if not attribute_value:\n return\n\n if attribute_value not in default_values:\n raise TagAttributeError('<{tag}>: {attribute_name} attribute '\n 'values should be one of these: {values}'\n .format(tag=tag,\n attribute_name=attribute_name,\n values=','.join(default_values)))","def has_attribute_type(self, attribute: str, typ: Optional[Type]) -> bool:\n if not self.has_attribute(attribute):\n return False\n\n attr_node = self.get_attribute(attribute).yaml_node\n\n if typ in scalar_type_to_tag:\n tag = scalar_type_to_tag[typ]\n return cast(str, attr_node.tag) == tag\n elif typ == list:\n return isinstance(attr_node, yaml.SequenceNode)\n elif typ == dict:\n return isinstance(attr_node, yaml.MappingNode)\n\n raise ValueError('Invalid argument for typ attribute')","def attribute_exists(se: SchemaExplorer, attribute_label: str) -> bool:\n schema_graph = se.get_nx_schema()\n\n if attribute_label in schema_graph.nodes:\n return True\n return False","def has_attribute_key(graph_element, attribute_key):\n return attribute_key in graph_element.get_attributes().keys() # return whether key is present","def has_attribute(self, name):\n\n pass","def validateOneAttribute(self, doc, elem, attr, value):\n if doc is None: doc__o = None\n else: doc__o = doc._o\n if elem is None: elem__o = None\n else: elem__o = elem._o\n if attr is None: attr__o = None\n else: attr__o = attr._o\n ret = libxml2mod.xmlValidateOneAttribute(self._o, doc__o, elem__o, attr__o, value)\n return ret","def _is_encodable_attribute(name):\n if name == '_meta':\n return True\n elif name.startswith(\"_\") or name.startswith(\"__\") or name == \"ext\":\n return False\n else:\n return True","def validate(self, attr=None, notattr=None):\n\n if attr is not None:\n specified_attrs = {attr: self.attributes[attr]}\n else:\n specified_attrs = self.attributes\n\n for attr, attr_structure in specified_attrs.items():\n if notattr is not None and attr is notattr:\n continue\n\n attrval = getattr(self, attr)\n if attrval is None or attrval == {}:\n continue\n\n attr_schema = attr_structure['schema']\n validatedattrval = attr_schema.validate(attrval)\n setattr(self, attr, validatedattrval)","def has_attributes(self):\n return bool(self.attrs)","def sk_attr(est, attr):\n from sklearn.utils.validation import check_is_fitted\n from sklearn.exceptions import NotFittedError\n try:\n check_is_fitted(est, attr)\n return True\n except NotFittedError:\n return False","def is_valid_tag(self, tag):\n\n if tag.has_attr('href') and len(tag['href']) > 0:\n href = tag['href']\n complete_href = self.session.complete_url(href)\n\n is_relative = self.url in complete_href\n is_visited = complete_href in self.visited_paths\n is_style_sheet = tag.name == \"link\"\n is_jumpTo = \"#\" in href\n is_mailTo = \"mailto\" in href\n is_js = \"javascript:\" in href\n return is_relative and \\\n not (is_visited or is_style_sheet or is_jumpTo or is_mailTo or is_js)\n else:\n return False","def __datatype_check(self, record_attribute, attribute_schema):\n if 'INT' in attribute_schema[TYPE_KEY].upper():\n if record_attribute.isdigit():\n return True\n elif attribute_schema[TYPE_KEY].upper() in DECIMAL_TYPES:\n if record_attribute.isdecimal():\n return True\n elif 'CHAR' in attribute_schema[TYPE_KEY].upper() \\\n or 'TEXT' in attribute_schema[TYPE_KEY].upper():\n if type(record_attribute) is str:\n return True\n else:\n IS_VALID_FILE = False\n return False","def test_attribute():\n params = dict(name=\"test\", type_=str, is_required=True)\n\n assert Attribute(**params) == Attribute(**params)\n assert Attribute(**params) is not None\n assert Attribute(**params) != Attribute(name=\"another\", type_=int, is_required=True)\n assert (\n str(Attribute(**params))\n == \"Attribute(name=test,type=<class 'str'>,is_required=True)\"\n )","def validate_time_attribute(tag, attribute_name, attribute_value):\n if not attribute_value:\n return\n\n # TODO: This can be extended to multiple time types. For example,\n # packages like zulu, Arrow, etc. have their own types but they all are\n # valid time types. Those can be added in the future.\n if isinstance(attribute_value, datetime.time):\n return attribute_value\n else:\n raise AttributeError('<{tag}>: {attribute} attribute should be a '\n 'time value.'\n .format(tag=tag, attribute=attribute_name))","def isMyKeyword(self, attributes): \n return self.attributePattern.match(attributes) != None","def hasAttributeElement(self, timeout=20.0, commandId=None, expectedText=None):\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\n \n valueLayer = TestTemplates.TemplateLayer(name=\"\")\n if expectedText is not None:\n valueLayer.addKey(name=\"value\", data=expectedText)\n return self.isActionAccepted(timeout=timeout, commandName=Command.GET_ELEMENT_ATTRIBUTE, \n commandId=commandId, expectedValue=valueLayer)","def require_attribute_value(\n self, attribute: str,\n value: Union[int, str, float, bool, None]) -> None:\n self.require_mapping()\n found = False\n for key_node, value_node in self.yaml_node.value:\n if (key_node.tag == 'tag:yaml.org,2002:str'\n and key_node.value == attribute):\n found = True\n node = Node(value_node)\n if not node.is_scalar(type(value)):\n raise RecognitionError(\n ('Incorrect attribute type where value {}'\n ' of type {} was required').format(\n value, type(value)))\n if node.get_value() != value:\n raise RecognitionError((\n 'Incorrect attribute value {} where {} was required'\n ).format(value_node.value, value))\n\n if not found:\n raise RecognitionError(\n 'Required key \"{}\" not found'.format(attribute))","def UseAttribute(self) -> bool:","def testinvalidattribute(self):\n self.assertRaises(AbilityError, AmuletAbility, 'Attribute', attr='Dam')\n self.assertRaises(AbilityError, AmuletAbility, 'Attribute', attr='')\n self.assertRaises(AbilityError, \n AmuletAbility, 'Control NPC', attr='ST')","def _check_attrs(cfg, attrs):\n for a in attrs:\n if (not hasattr(cfg, a)) or getattr(cfg, a) is None:\n print(\"{0} parameter is not set\".format(a))\n sys.exit(UNKNOWN)","def is_linguistic_tag(tag):\r\n if tag.startswith(\"&\"):\r\n return True\r\n if any(x in tag for x in [\"<abbr>\", \"<abbr \", \"</abbr>\"]):\r\n return True\r\n return False","def validNormalizeAttributeValue(self, elem, name, value):\n if elem is None: elem__o = None\n else: elem__o = elem._o\n ret = libxml2mod.xmlValidNormalizeAttributeValue(self._o, elem__o, name, value)\n return ret","def test_get_attrib(self):\n self.assertEqual(\"true\", get_attrib(self.xml, \"exists\"))\n self.assertEqual(0, get_attrib(self.xml, \"default\", default=0))\n self.assertEqual(23, get_attrib(self.xml, \"integer\", cast=int))\n self.assertEqual(1.354, get_attrib(self.xml, \"float\", cast=float))\n self.assertRaises(ValueError, get_attrib, *(self.xml, \"noexist\", \"unittest\"))","def has_attribute(self, name):\n return name in self.schema","def attributeEqual(self, key, value=''):\n # value='' must be same as the default parameter of method getAttribute\n val = self.attr(key)\n if isinstance(val, type(value)) and val == value:\n return True\n return False","def is_tag(t):\n return len(t) > 1 and t.startswith('#') and not t.startswith('##') and t","def is_tag(value):\r\n tag_names = parse_tag_input(value)\r\n if len(tag_names) > 1:\r\n raise ValidationError(_('Multiple tags were given.'))\r\n elif len(tag_names[0]) > settings.MAX_TAG_LENGTH:\r\n raise forms.ValidationError(\r\n _('A tag may be no more than %s characters long.') % settings.MAX_TAG_LENGTH)\r\n return value","def isAttributesEmpty(self):\n return _libsbml.XMLToken_isAttributesEmpty(self)","def _should_be_filtered(self, tag, attrs):\n \n # Test if the node's tag should be filtered\n if self.__ignores[0] and tag in self.__ignores[0]:\n return False\n \n # Test if the node's attributes should be filtered\n filters = self.__ignores[1][any_tag]\n if tag in self.__ignores[1]:\n filters |= self.__ignores[1][tag]\n\n try:\n if any('.%s' % attr[1] in filters for attr in attrs if attr[0] == 'class'):\n return False\n except KeyError:\n pass\n\n try:\n if any('#%s' % attr[1] in filters for attr in attrs if attr[0] == 'id'):\n return False\n except KeyError:\n pass\n\n return True","def check_var_attrs(self, cls, node):\n ast = node.ast\n declarator = ast.declarator\n attrs = declarator.attrs\n for attr in attrs:\n if attr[0] == \"_\": # internal attribute\n continue\n # XXX - deref on class/struct members\n if attr not in [\"name\", \"readonly\", \"dimension\", \"deref\"]:\n raise RuntimeError(\n \"Illegal attribute '{}' for variable '{}' at line {}\".format(\n attr, node.name, node.linenumber\n ) + \"\\nonly 'name', 'readonly', 'dimension' and 'deref' are allowed on variables\"\n )\n\n is_ptr = declarator.is_indirect()\n if attrs[\"dimension\"] and not is_ptr:\n raise RuntimeError(\n \"dimension attribute can only be \"\n \"used on pointer and references\"\n )\n\n self.parse_attrs(node, ast)","def validateOneAttribute(self, ctxt, elem, attr, value):\n if ctxt is None: ctxt__o = None\n else: ctxt__o = ctxt._o\n if elem is None: elem__o = None\n else: elem__o = elem._o\n if attr is None: attr__o = None\n else: attr__o = attr._o\n ret = libxml2mod.xmlValidateOneAttribute(ctxt__o, self._o, elem__o, attr__o, value)\n return ret","def validate(self, attrs):\n tag_name = attrs['tag_name']\n club = attrs['club']\n request = self.context['request']\n profile = UserProfile.objects.get(user=request.user)\n if (club not in profile.get_club_privileges() and\n club not in profile.get_workshop_privileges().values_list('club', flat=True)):\n raise serializers.ValidationError(\"You are not allowed to create tag for this club\")\n if Tag.objects.filter(tag_name=tag_name, club=club):\n raise serializers.ValidationError(\"The tag already exists for this club\")\n return attrs","def require_attribute_value_not(\n self, attribute: str,\n value: Union[int, str, float, bool, None]) -> None:\n self.require_mapping()\n found = False\n for key_node, value_node in self.yaml_node.value:\n if (key_node.tag == 'tag:yaml.org,2002:str'\n and key_node.value == attribute):\n found = True\n node = Node(value_node)\n if not node.is_scalar(type(value)):\n return\n if node.get_value() == value:\n raise RecognitionError(\n (\n 'Incorrect attribute value {} where {} was not'\n ' allowed').format(value_node.value, value))\n\n if not found:\n raise RecognitionError(\n 'Required key \"{}\" not found'.format(attribute))","def validate(self, attrs: dict):\n attr_types_set = {attr.lower() for attr in attrs.keys()}\n\n missing_required = self.required_attrs - attr_types_set\n if missing_required:\n missing_required = ', '.join(missing_required)\n raise SchemaValidationError(f'Missing required attributes: {missing_required}')\n\n not_required = attr_types_set - self.required_attrs\n not_allowed = not_required - self.allowed_attrs\n if not_allowed:\n not_allowed = ', '.join(not_allowed)\n raise SchemaValidationError(f'Attribute types are not allowed: {not_allowed}')\n\n self.attr_type_validate(attrs)","def class_attr(self, attr, ignore_protected):\n protected = False if not ignore_protected else self.protected_attr(attr)\n return re.match('^(?!__).*', attr) and not callable(getattr(self, attr)) and not protected","def hasRequiredAttributes(self):\n return _libsbml.Input_hasRequiredAttributes(self)","def validate_tag(self, tag_field):\n if not tag_field.data or tag_field.data == '':\n raise ValidationError('All users must be tagged')\n return True","def is_attr_exist(self, section_name: str, attr_name: str) -> bool:\n success = False\n try:\n response = self._vault_api.read_secret(path=section_name.upper(), mount_point=self.mount_point)\n keys = list(response[\"data\"][\"data\"].keys())\n success = attr_name.upper() in keys\n except InvalidPath:\n pass\n return success","def check_claim_attrs(claim_attrs, expected_claim):\n for key in expected_claim.keys():\n if claim_attrs[key] != expected_claim[key][0]:\n return False\n return True","def _MatchDeviceAttribute(required_attr, device_attrs):\n if required_attr.name not in device_attrs:\n logging.debug(\n 'No %s in %s.',\n required_attr.name, device_attrs.get('device_serial'))\n return False\n operator = required_attr.operator or '='\n if operator not in _OPERATOR_TO_PREDICTOR:\n # This should never happen, since we check the expression in\n # request_api._ParseAttributeRequirement.\n raise ValueError('Operator \"%s\" is not supported.' % operator)\n\n device_attr_value = device_attrs[required_attr.name]\n required_value = required_attr.value\n if required_attr.operator in _LIST_OPERATORS:\n required_value = required_value.split(',')\n if required_attr.name in common.NUMBER_DEVICE_ATTRIBUTES:\n if isinstance(required_value, list):\n required_value = map(common.ParseFloat, required_value)\n else:\n required_value = common.ParseFloat(required_value)\n if required_value is None:\n # This should never happen, since we check the expression in\n # request_api._ParseAttributeRequirement.\n raise ValueError(\n \"%s can not compare to a non-number value '%s'\" %\n (required_attr.name, required_attr.value))\n device_attr_value = common.ParseFloat(device_attr_value)\n if device_attr_value is None:\n logging.debug(\n 'Device attr %s is a non-number \"%s\".',\n required_attr.name, device_attrs[required_attr.name])\n return False\n return _OPERATOR_TO_PREDICTOR[operator](device_attr_value, required_value)","def _static_hasattr(value, attr):\n try:\n object.__getattribute__(value, attr)\n except AttributeError:\n return False\n else:\n return True","def check_global_attr_iso8601(ds, attr):\n\n if attr not in ds.ncattrs():\n return 0\n\n global_attr = getattr(ds, attr)\n\n try:\n parser.isoparse(global_attr)\n return 2\n except ValueError:\n return 1","def GetValidAttributeValues(self, attr):\n return None","def _checkAttributeIndex(self, index):\n\n if index > len(self._attributes):\n raise IndexError(\"'\" + str(index) + \"' is out of the range of 'attributes' array.\")\n\n return True","def _validate_item_required_attrs(self, item):\n if not getattr(item, \"title\", None):\n raise ValueError(\"Required attribute title is not set.\")\n\n if not getattr(item, \"published\", None):\n raise ValueError(\"Required attribute published is not set.\")\n\n if not getattr(item, \"link\", None):\n raise ValueError(\"Required attribute link is not set.\")\n\n return True","def filterattrs(event):\n for a in ['description', 'summary', 'location']:\n if not hasattr(event, a):\n return False\n return True"],"string":"[\n \"def is_valid_attribute(self, attr):\\n try:\\n self.validate_attribute(attr)\\n return True\\n except etal.LabelsSchemaError:\\n return False\",\n \"def is_valid_attribute(self, attr):\\n try:\\n self.validate_attribute(attr)\\n return True\\n except etal.LabelsSchemaError:\\n return False\",\n \"def validate_attribute(self, attr):\\n self.attrs.validate_attribute(attr)\",\n \"def is_valid_attribute(self, attr):\\n return self.is_valid(attr)\",\n \"def is_element_attribute(element, attribute_name):\\n return element.get(attribute_name) is not None\",\n \"def is_valid_attribute_name(self, name):\\n try:\\n self.validate_attribute_name(name)\\n return True\\n except etal.LabelsSchemaError:\\n return False\",\n \"def is_valid_attributes(self, attrs):\\n try:\\n self.validate_attributes(attrs)\\n return True\\n except etal.LabelsSchemaError:\\n return False\",\n \"def validate(attrs):\\n try:\\n #required_attributes = ('qquuid', 'qqfilename')\\n #[attrs.get(k) for k,v in attrs.items()]\\n return True\\n except Exception, e:\\n return False\",\n \"def validate_attributes(self, attrs):\\n self.attrs.validate(attrs)\",\n \"def validate(attrs):\\n print \\\"I GOT HERE.\\\"\\n try:\\n #required_attributes = ('qquuid', 'qqfilename')\\n #[attrs.get(k) for k,v in attrs.items()]\\n return True\\n except Exception, e:\\n return False\",\n \"def validate_tag(tag=None):\\n if not tag:\\n raise AttributeError('Tag cannot be empty')\\n\\n if tag not in TAGS:\\n raise ValueError('{0} tag is not supported')\",\n \"def hasAttr(self, *args):\\n return _libsbml.XMLToken_hasAttr(self, *args)\",\n \"def validate_attribute(self, attr):\\n self.validate(attr)\",\n \"def is_valid(self, attr: Optional[str] = None) -> bool:\\n try:\\n self.validate(attr)\\n except (TypeError, ValueError):\\n return False\\n return True\",\n \"def is_valid_tag(tag):\\n if not tag or ':' not in tag or len(tag) > TAG_MAX_LEN:\\n return False\\n # Care only about the key. Value can be anything (including empty string).\\n return bool(TAG_KEY_RE.match(tag.split(':', 1)[0]))\",\n \"def validate_attribute(self, attr):\\n self.validate_attribute_name(attr.name)\\n self.schema[attr.name].validate_attribute(attr)\",\n \"def isAttribute(self, p_int): # real signature unknown; restored from __doc__\\n return False\",\n \"def valid_att_in_field(arch, **kwargs):\\n return not arch.xpath('//field[not(@name)]')\",\n \"def is_attribute(self):\\r\\n return conf.lib.clang_isAttribute(self)\",\n \"def is_valid(self, attribute: Attribute) -> bool:\\n return self.get_data_type() == attribute.type\",\n \"def validate_attribute_name(self, name):\\n if not self.has_attribute(name):\\n raise AttributeContainerSchemaError(\\n \\\"Attribute '%s' is not allowed by the schema\\\" % name\\n )\",\n \"def is_attr_exist(self, section_name: str, attr_name: str) -> bool:\\n pass\",\n \"def assert_valid_attribute(self, name):\\n if name.startswith('_'):\\n return\\n self.assert_known_field(name)\",\n \"def isValidTagName(s):\\n if s.lower().startswith(\\\"xml\\\"):\\n return False\\n return re.match(\\\"[^\\\\W\\\\d][\\\\w\\\\-_.]*\\\", s)\",\n \"def is_valid_type(self, attr: Optional[str] = None) -> bool:\\n try:\\n self.validate_type(attr)\\n except TypeError:\\n return False\\n return True\",\n \"def has_attr(self, key):\\n return key in self.attrs\",\n \"def validate_string_attribute(tag, attribute_name, attribute_value):\\n if not attribute_value:\\n return\\n\\n if not isinstance(attribute_value, str):\\n raise AttributeValueError('<{tag}>: {attribute_name} should be a '\\n 'string value.'\\n .format(tag=tag,\\n attribute_name=attribute_name))\",\n \"def is_valid_keypoints_attribute(self, label, attr):\\n try:\\n self.validate_keypoints_attribute(label, attr)\\n return True\\n except etal.LabelsSchemaError:\\n return False\",\n \"def valid_mitre_att(self, rule_to_validate_mitre_att, tag_index):\\r\\n self.required_fields[MITRE_ATT].attributefound()\\r\\n self.required_fields_index[self.required_fields[MITRE_ATT].position].increment_count()\\r\\n\\r\\n metadata = rule_to_validate_mitre_att[METADATA]\\r\\n mitre_att_to_validate = str(metadata[tag_index][MITRE_ATT]).upper()\\r\\n metadata[tag_index][MITRE_ATT] = mitre_att_to_validate\\r\\n if self.validate_mitre_att_by_id(mitre_att_to_validate):\\r\\n self.required_fields[MITRE_ATT].attributevalid()\\r\\n else:\\r\\n self.required_fields[MITRE_ATT].attributeinvalid()\\r\\n\\r\\n return self.required_fields[MITRE_ATT].valid\",\n \"def test_attribute(self):\\n xp = XPathQuery(\\\"/foo[@attrib1]\\\")\\n self.assertEqual(xp.matches(self.e), True)\",\n \"def hasAttribute(self, *args):\\n return _libsbml.XMLAttributes_hasAttribute(self, *args)\",\n \"def is_valid_keypoints_attributes(self, label, attrs):\\n try:\\n self.validate_keypoints_attributes(label, attrs)\\n return True\\n except etal.LabelsSchemaError:\\n return False\",\n \"def checkattr(name):\\n\\n def check(obj):\\n try:\\n attrgetter(name)(obj)\\n return True\\n except AttributeError:\\n return False\\n\\n return check\",\n \"def validate_boolean_attribute(tag, attribute_name, attribute_value):\\n if not attribute_value:\\n return\\n\\n if not isinstance(attribute_value, bool):\\n raise AttributeError('<{tag}>: {attribute_name} attribute should be a '\\n 'boolean value.'\\n .format(tag=tag, attribute_name=attribute_name))\",\n \"def htmlIsScriptAttribute(name):\\n ret = libxml2mod.htmlIsScriptAttribute(name)\\n return ret\",\n \"def has_attribute(*attrs):\\n\\n @meta\\n def check(cls):\\n return all(hasattr(cls, a) for a in attrs)\\n\\n return check\",\n \"def validate_number_attribute(tag, attribute_name, attribute_value):\\n if not attribute_value:\\n return\\n\\n # If the given attribute value is either integer/float, then return the\\n # value.\\n if isinstance(attribute_value, (int, float)):\\n return attribute_value\\n # Give attribute value can be a string. For example, the given attribute\\n # value can be '1'. When we do int('1') --> returns 1. The same logic\\n # works in float values also. So, if we do float('1.23') --> returns 1.23.\\n # If both the cases fail, then we raise an AttributeError.\\n elif isinstance(attribute_value, str):\\n try:\\n return int(attribute_value)\\n except ValueError:\\n try:\\n return float(attribute_value)\\n except ValueError:\\n raise AttributeValueError('<{tag}>: {attribute} attribute '\\n 'should be an integer or float value'\\n .format(tag=tag,\\n attribute=attribute_name))\\n else:\\n # In rest all the cases, the attribute value is not a valid int/float\\n # value.\\n raise AttributeValueError('<{tag}>: {attribute} attribute should be an'\\n ' integer or float value'\\n .format(tag=tag, attribute=attribute_name))\",\n \"def hasAttribute(self, attrib):\\n return self._dqa(attrib) in self.attributes\",\n \"def check_attributes(self):\\n self.assertEqual(type(self.amenity_1.name), str)\",\n \"def validate(self, attr):\\n if attr.name != self.name:\\n raise AttributeSchemaError(\\n \\\"Expected name '%s'; found '%s'\\\" % (self.name, attr.name)\\n )\\n\\n self.validate_type(attr)\\n\\n if not self.is_valid_value(attr.value):\\n raise AttributeSchemaError(\\n \\\"Value '%s' of attribute '%s' is not allowed by the \\\"\\n \\\"schema \\\" % (attr.value, attr.name)\\n )\",\n \"def hasAttribute(self, p_str, p_str_1=None): # real signature unknown; restored from __doc__ with multiple overloads\\n return False\",\n \"def is_attname(name):\\n test = re.search(\\\"^@[a-z]+\\\", name)\\n if test:\\n return True\\n else:\\n return False\",\n \"def valid_att_in_label(arch, **kwargs):\\n return not arch.xpath('//label[not(@for) and not(descendant::input)]')\",\n \"def validateAttribute(self, attributeName):\\n if (not attributeName in self._attributes):\\n raise pcssErrors.PcssGlobalException(\\\"Error: attempted to set attribute %s which is not a valid pfa attribute\\\" % attributeName)\",\n \"def validate_date_attribute(tag, attribute_name, attribute_value):\\n if not attribute_value:\\n return\\n\\n # TODO: This can be extended to multiple datetime types. For example,\\n # packages like zulu, Arrow, etc. have their own types but they all are\\n # valid datetime types. Those can be added in the future.\\n if isinstance(attribute_value, (datetime.datetime, datetime.date)):\\n return attribute_value\\n else:\\n raise AttributeError('<{tag}>: {attribute} attribute should be a '\\n 'date/datetime value.'\\n .format(tag=tag, attribute=attribute_name))\",\n \"def validate_type(self, attr):\\n if not isinstance(attr, self._attr_cls):\\n raise AttributeSchemaError(\\n \\\"Expected attribute '%s' to have type '%s'; found '%s'\\\"\\n % (attr.name, self.type, etau.get_class_name(attr))\\n )\",\n \"def _entry_tag_is_valid(entry: _LexiconEntry) -> None:\\n tag = _tag_of(entry)\\n\\n if tag not in tags.VALID_TAGS:\\n raise InvalidLexiconEntryError(\\n \\\"Entry 'tag' field has invalid value. It can only be one of the valid\\\"\\n \\\" tags that are defined in 'morphotactics_compiler/tags.py'.\\\")\",\n \"def compareAttribute(self, attrib, value):\\n return self.attributes.get(self._dqa(attrib), None) == value\",\n \"def validNormalizeAttributeValue(self, doc, name, value):\\n if doc is None: doc__o = None\\n else: doc__o = doc._o\\n ret = libxml2mod.xmlValidNormalizeAttributeValue(doc__o, self._o, name, value)\\n return ret\",\n \"def check_param(cls, key, val) -> None:\\n\\n # Check if attribute is valid for this resource at all\\n if key not in cls._Attributes:\\n raise TypeError(\\\"Unexpected attribute '{}' for resource '{}'\\\".format(\\n key,\\n cls))\\n\\n Attribute = cls._Attributes[key]\\n\\n # Check if attribute is null and is allowed to be null\\n if Attribute['optional'] and val is None:\\n return\\n\\n # Check if attribute has correct type\\n if Attribute['list']:\\n msg = \\\"Attribute '{}' of resource {} has to be of type list of '{}'\\\".format(\\n key,\\n cls,\\n Attribute['type'])\\n if not isinstance(val, list):\\n raise TypeError(msg)\\n for item in val:\\n if not isinstance(item, Attribute['type']):\\n raise TypeError(msg)\\n else:\\n msg = \\\"Attribute '{}' of resource {} has to be of type '{}'\\\".format(\\n key,\\n cls,\\n Attribute['type'])\\n if not isinstance(val, Attribute['type']):\\n raise TypeError(msg)\\n\\n # Check all checks\\n if 'checks' in Attribute:\\n msg = \\\"Illegal value '{}' for attribute '{}' of resource {}\\\".format(\\n val,\\n key,\\n cls)\\n for value_check in Attribute['checks']:\\n if value_check(cls, val) is False:\\n raise ValueError(msg)\",\n \"def _validability(self, ability):\\n return isinstance(ability, AttributeAbility)\",\n \"def check(self, description: Description) -> bool:\\n # if the name of the attribute is not present, return false.\\n name = self.attribute_name\\n if name not in description.values:\\n return False\\n\\n # if the type of the value is different from the type of the attribute, return false.\\n value = description.values[name]\\n if type(self.constraint_type.value) in {list, tuple, set} and not isinstance(\\n value, type(next(iter(self.constraint_type.value)))\\n ):\\n return False\\n if type(self.constraint_type.value) not in {\\n list,\\n tuple,\\n set,\\n } and not isinstance(value, type(self.constraint_type.value)):\\n return False\\n\\n # dispatch the check to the right implementation for the concrete constraint type.\\n return self.constraint_type.check(value)\",\n \"def testattributes(self):\\n for attr in AmuletAbility.attributes:\\n a = AmuletAbility('Attribute', attr=attr)\\n self.assert_(attr in str(a))\\n self.assertEqual(a.attribute, attr)\\n self.assertTrue(isinstance(a.AC, int))\\n self.assertTrue(isinstance(a.description(), str))\",\n \"def is_format_wrong(soup):\\n a = soup.find('a')\\n if a.has_attr('faire'):\\n return True\\n return False\",\n \"def validate_attribute_values(tag,\\n attribute_name,\\n attribute_value,\\n default_values):\\n if not attribute_value:\\n return\\n\\n if attribute_value not in default_values:\\n raise TagAttributeError('<{tag}>: {attribute_name} attribute '\\n 'values should be one of these: {values}'\\n .format(tag=tag,\\n attribute_name=attribute_name,\\n values=','.join(default_values)))\",\n \"def has_attribute_type(self, attribute: str, typ: Optional[Type]) -> bool:\\n if not self.has_attribute(attribute):\\n return False\\n\\n attr_node = self.get_attribute(attribute).yaml_node\\n\\n if typ in scalar_type_to_tag:\\n tag = scalar_type_to_tag[typ]\\n return cast(str, attr_node.tag) == tag\\n elif typ == list:\\n return isinstance(attr_node, yaml.SequenceNode)\\n elif typ == dict:\\n return isinstance(attr_node, yaml.MappingNode)\\n\\n raise ValueError('Invalid argument for typ attribute')\",\n \"def attribute_exists(se: SchemaExplorer, attribute_label: str) -> bool:\\n schema_graph = se.get_nx_schema()\\n\\n if attribute_label in schema_graph.nodes:\\n return True\\n return False\",\n \"def has_attribute_key(graph_element, attribute_key):\\n return attribute_key in graph_element.get_attributes().keys() # return whether key is present\",\n \"def has_attribute(self, name):\\n\\n pass\",\n \"def validateOneAttribute(self, doc, elem, attr, value):\\n if doc is None: doc__o = None\\n else: doc__o = doc._o\\n if elem is None: elem__o = None\\n else: elem__o = elem._o\\n if attr is None: attr__o = None\\n else: attr__o = attr._o\\n ret = libxml2mod.xmlValidateOneAttribute(self._o, doc__o, elem__o, attr__o, value)\\n return ret\",\n \"def _is_encodable_attribute(name):\\n if name == '_meta':\\n return True\\n elif name.startswith(\\\"_\\\") or name.startswith(\\\"__\\\") or name == \\\"ext\\\":\\n return False\\n else:\\n return True\",\n \"def validate(self, attr=None, notattr=None):\\n\\n if attr is not None:\\n specified_attrs = {attr: self.attributes[attr]}\\n else:\\n specified_attrs = self.attributes\\n\\n for attr, attr_structure in specified_attrs.items():\\n if notattr is not None and attr is notattr:\\n continue\\n\\n attrval = getattr(self, attr)\\n if attrval is None or attrval == {}:\\n continue\\n\\n attr_schema = attr_structure['schema']\\n validatedattrval = attr_schema.validate(attrval)\\n setattr(self, attr, validatedattrval)\",\n \"def has_attributes(self):\\n return bool(self.attrs)\",\n \"def sk_attr(est, attr):\\n from sklearn.utils.validation import check_is_fitted\\n from sklearn.exceptions import NotFittedError\\n try:\\n check_is_fitted(est, attr)\\n return True\\n except NotFittedError:\\n return False\",\n \"def is_valid_tag(self, tag):\\n\\n if tag.has_attr('href') and len(tag['href']) > 0:\\n href = tag['href']\\n complete_href = self.session.complete_url(href)\\n\\n is_relative = self.url in complete_href\\n is_visited = complete_href in self.visited_paths\\n is_style_sheet = tag.name == \\\"link\\\"\\n is_jumpTo = \\\"#\\\" in href\\n is_mailTo = \\\"mailto\\\" in href\\n is_js = \\\"javascript:\\\" in href\\n return is_relative and \\\\\\n not (is_visited or is_style_sheet or is_jumpTo or is_mailTo or is_js)\\n else:\\n return False\",\n \"def __datatype_check(self, record_attribute, attribute_schema):\\n if 'INT' in attribute_schema[TYPE_KEY].upper():\\n if record_attribute.isdigit():\\n return True\\n elif attribute_schema[TYPE_KEY].upper() in DECIMAL_TYPES:\\n if record_attribute.isdecimal():\\n return True\\n elif 'CHAR' in attribute_schema[TYPE_KEY].upper() \\\\\\n or 'TEXT' in attribute_schema[TYPE_KEY].upper():\\n if type(record_attribute) is str:\\n return True\\n else:\\n IS_VALID_FILE = False\\n return False\",\n \"def test_attribute():\\n params = dict(name=\\\"test\\\", type_=str, is_required=True)\\n\\n assert Attribute(**params) == Attribute(**params)\\n assert Attribute(**params) is not None\\n assert Attribute(**params) != Attribute(name=\\\"another\\\", type_=int, is_required=True)\\n assert (\\n str(Attribute(**params))\\n == \\\"Attribute(name=test,type=<class 'str'>,is_required=True)\\\"\\n )\",\n \"def validate_time_attribute(tag, attribute_name, attribute_value):\\n if not attribute_value:\\n return\\n\\n # TODO: This can be extended to multiple time types. For example,\\n # packages like zulu, Arrow, etc. have their own types but they all are\\n # valid time types. Those can be added in the future.\\n if isinstance(attribute_value, datetime.time):\\n return attribute_value\\n else:\\n raise AttributeError('<{tag}>: {attribute} attribute should be a '\\n 'time value.'\\n .format(tag=tag, attribute=attribute_name))\",\n \"def isMyKeyword(self, attributes): \\n return self.attributePattern.match(attributes) != None\",\n \"def hasAttributeElement(self, timeout=20.0, commandId=None, expectedText=None):\\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\\n \\n valueLayer = TestTemplates.TemplateLayer(name=\\\"\\\")\\n if expectedText is not None:\\n valueLayer.addKey(name=\\\"value\\\", data=expectedText)\\n return self.isActionAccepted(timeout=timeout, commandName=Command.GET_ELEMENT_ATTRIBUTE, \\n commandId=commandId, expectedValue=valueLayer)\",\n \"def require_attribute_value(\\n self, attribute: str,\\n value: Union[int, str, float, bool, None]) -> None:\\n self.require_mapping()\\n found = False\\n for key_node, value_node in self.yaml_node.value:\\n if (key_node.tag == 'tag:yaml.org,2002:str'\\n and key_node.value == attribute):\\n found = True\\n node = Node(value_node)\\n if not node.is_scalar(type(value)):\\n raise RecognitionError(\\n ('Incorrect attribute type where value {}'\\n ' of type {} was required').format(\\n value, type(value)))\\n if node.get_value() != value:\\n raise RecognitionError((\\n 'Incorrect attribute value {} where {} was required'\\n ).format(value_node.value, value))\\n\\n if not found:\\n raise RecognitionError(\\n 'Required key \\\"{}\\\" not found'.format(attribute))\",\n \"def UseAttribute(self) -> bool:\",\n \"def testinvalidattribute(self):\\n self.assertRaises(AbilityError, AmuletAbility, 'Attribute', attr='Dam')\\n self.assertRaises(AbilityError, AmuletAbility, 'Attribute', attr='')\\n self.assertRaises(AbilityError, \\n AmuletAbility, 'Control NPC', attr='ST')\",\n \"def _check_attrs(cfg, attrs):\\n for a in attrs:\\n if (not hasattr(cfg, a)) or getattr(cfg, a) is None:\\n print(\\\"{0} parameter is not set\\\".format(a))\\n sys.exit(UNKNOWN)\",\n \"def is_linguistic_tag(tag):\\r\\n if tag.startswith(\\\"&\\\"):\\r\\n return True\\r\\n if any(x in tag for x in [\\\"<abbr>\\\", \\\"<abbr \\\", \\\"</abbr>\\\"]):\\r\\n return True\\r\\n return False\",\n \"def validNormalizeAttributeValue(self, elem, name, value):\\n if elem is None: elem__o = None\\n else: elem__o = elem._o\\n ret = libxml2mod.xmlValidNormalizeAttributeValue(self._o, elem__o, name, value)\\n return ret\",\n \"def test_get_attrib(self):\\n self.assertEqual(\\\"true\\\", get_attrib(self.xml, \\\"exists\\\"))\\n self.assertEqual(0, get_attrib(self.xml, \\\"default\\\", default=0))\\n self.assertEqual(23, get_attrib(self.xml, \\\"integer\\\", cast=int))\\n self.assertEqual(1.354, get_attrib(self.xml, \\\"float\\\", cast=float))\\n self.assertRaises(ValueError, get_attrib, *(self.xml, \\\"noexist\\\", \\\"unittest\\\"))\",\n \"def has_attribute(self, name):\\n return name in self.schema\",\n \"def attributeEqual(self, key, value=''):\\n # value='' must be same as the default parameter of method getAttribute\\n val = self.attr(key)\\n if isinstance(val, type(value)) and val == value:\\n return True\\n return False\",\n \"def is_tag(t):\\n return len(t) > 1 and t.startswith('#') and not t.startswith('##') and t\",\n \"def is_tag(value):\\r\\n tag_names = parse_tag_input(value)\\r\\n if len(tag_names) > 1:\\r\\n raise ValidationError(_('Multiple tags were given.'))\\r\\n elif len(tag_names[0]) > settings.MAX_TAG_LENGTH:\\r\\n raise forms.ValidationError(\\r\\n _('A tag may be no more than %s characters long.') % settings.MAX_TAG_LENGTH)\\r\\n return value\",\n \"def isAttributesEmpty(self):\\n return _libsbml.XMLToken_isAttributesEmpty(self)\",\n \"def _should_be_filtered(self, tag, attrs):\\n \\n # Test if the node's tag should be filtered\\n if self.__ignores[0] and tag in self.__ignores[0]:\\n return False\\n \\n # Test if the node's attributes should be filtered\\n filters = self.__ignores[1][any_tag]\\n if tag in self.__ignores[1]:\\n filters |= self.__ignores[1][tag]\\n\\n try:\\n if any('.%s' % attr[1] in filters for attr in attrs if attr[0] == 'class'):\\n return False\\n except KeyError:\\n pass\\n\\n try:\\n if any('#%s' % attr[1] in filters for attr in attrs if attr[0] == 'id'):\\n return False\\n except KeyError:\\n pass\\n\\n return True\",\n \"def check_var_attrs(self, cls, node):\\n ast = node.ast\\n declarator = ast.declarator\\n attrs = declarator.attrs\\n for attr in attrs:\\n if attr[0] == \\\"_\\\": # internal attribute\\n continue\\n # XXX - deref on class/struct members\\n if attr not in [\\\"name\\\", \\\"readonly\\\", \\\"dimension\\\", \\\"deref\\\"]:\\n raise RuntimeError(\\n \\\"Illegal attribute '{}' for variable '{}' at line {}\\\".format(\\n attr, node.name, node.linenumber\\n ) + \\\"\\\\nonly 'name', 'readonly', 'dimension' and 'deref' are allowed on variables\\\"\\n )\\n\\n is_ptr = declarator.is_indirect()\\n if attrs[\\\"dimension\\\"] and not is_ptr:\\n raise RuntimeError(\\n \\\"dimension attribute can only be \\\"\\n \\\"used on pointer and references\\\"\\n )\\n\\n self.parse_attrs(node, ast)\",\n \"def validateOneAttribute(self, ctxt, elem, attr, value):\\n if ctxt is None: ctxt__o = None\\n else: ctxt__o = ctxt._o\\n if elem is None: elem__o = None\\n else: elem__o = elem._o\\n if attr is None: attr__o = None\\n else: attr__o = attr._o\\n ret = libxml2mod.xmlValidateOneAttribute(ctxt__o, self._o, elem__o, attr__o, value)\\n return ret\",\n \"def validate(self, attrs):\\n tag_name = attrs['tag_name']\\n club = attrs['club']\\n request = self.context['request']\\n profile = UserProfile.objects.get(user=request.user)\\n if (club not in profile.get_club_privileges() and\\n club not in profile.get_workshop_privileges().values_list('club', flat=True)):\\n raise serializers.ValidationError(\\\"You are not allowed to create tag for this club\\\")\\n if Tag.objects.filter(tag_name=tag_name, club=club):\\n raise serializers.ValidationError(\\\"The tag already exists for this club\\\")\\n return attrs\",\n \"def require_attribute_value_not(\\n self, attribute: str,\\n value: Union[int, str, float, bool, None]) -> None:\\n self.require_mapping()\\n found = False\\n for key_node, value_node in self.yaml_node.value:\\n if (key_node.tag == 'tag:yaml.org,2002:str'\\n and key_node.value == attribute):\\n found = True\\n node = Node(value_node)\\n if not node.is_scalar(type(value)):\\n return\\n if node.get_value() == value:\\n raise RecognitionError(\\n (\\n 'Incorrect attribute value {} where {} was not'\\n ' allowed').format(value_node.value, value))\\n\\n if not found:\\n raise RecognitionError(\\n 'Required key \\\"{}\\\" not found'.format(attribute))\",\n \"def validate(self, attrs: dict):\\n attr_types_set = {attr.lower() for attr in attrs.keys()}\\n\\n missing_required = self.required_attrs - attr_types_set\\n if missing_required:\\n missing_required = ', '.join(missing_required)\\n raise SchemaValidationError(f'Missing required attributes: {missing_required}')\\n\\n not_required = attr_types_set - self.required_attrs\\n not_allowed = not_required - self.allowed_attrs\\n if not_allowed:\\n not_allowed = ', '.join(not_allowed)\\n raise SchemaValidationError(f'Attribute types are not allowed: {not_allowed}')\\n\\n self.attr_type_validate(attrs)\",\n \"def class_attr(self, attr, ignore_protected):\\n protected = False if not ignore_protected else self.protected_attr(attr)\\n return re.match('^(?!__).*', attr) and not callable(getattr(self, attr)) and not protected\",\n \"def hasRequiredAttributes(self):\\n return _libsbml.Input_hasRequiredAttributes(self)\",\n \"def validate_tag(self, tag_field):\\n if not tag_field.data or tag_field.data == '':\\n raise ValidationError('All users must be tagged')\\n return True\",\n \"def is_attr_exist(self, section_name: str, attr_name: str) -> bool:\\n success = False\\n try:\\n response = self._vault_api.read_secret(path=section_name.upper(), mount_point=self.mount_point)\\n keys = list(response[\\\"data\\\"][\\\"data\\\"].keys())\\n success = attr_name.upper() in keys\\n except InvalidPath:\\n pass\\n return success\",\n \"def check_claim_attrs(claim_attrs, expected_claim):\\n for key in expected_claim.keys():\\n if claim_attrs[key] != expected_claim[key][0]:\\n return False\\n return True\",\n \"def _MatchDeviceAttribute(required_attr, device_attrs):\\n if required_attr.name not in device_attrs:\\n logging.debug(\\n 'No %s in %s.',\\n required_attr.name, device_attrs.get('device_serial'))\\n return False\\n operator = required_attr.operator or '='\\n if operator not in _OPERATOR_TO_PREDICTOR:\\n # This should never happen, since we check the expression in\\n # request_api._ParseAttributeRequirement.\\n raise ValueError('Operator \\\"%s\\\" is not supported.' % operator)\\n\\n device_attr_value = device_attrs[required_attr.name]\\n required_value = required_attr.value\\n if required_attr.operator in _LIST_OPERATORS:\\n required_value = required_value.split(',')\\n if required_attr.name in common.NUMBER_DEVICE_ATTRIBUTES:\\n if isinstance(required_value, list):\\n required_value = map(common.ParseFloat, required_value)\\n else:\\n required_value = common.ParseFloat(required_value)\\n if required_value is None:\\n # This should never happen, since we check the expression in\\n # request_api._ParseAttributeRequirement.\\n raise ValueError(\\n \\\"%s can not compare to a non-number value '%s'\\\" %\\n (required_attr.name, required_attr.value))\\n device_attr_value = common.ParseFloat(device_attr_value)\\n if device_attr_value is None:\\n logging.debug(\\n 'Device attr %s is a non-number \\\"%s\\\".',\\n required_attr.name, device_attrs[required_attr.name])\\n return False\\n return _OPERATOR_TO_PREDICTOR[operator](device_attr_value, required_value)\",\n \"def _static_hasattr(value, attr):\\n try:\\n object.__getattribute__(value, attr)\\n except AttributeError:\\n return False\\n else:\\n return True\",\n \"def check_global_attr_iso8601(ds, attr):\\n\\n if attr not in ds.ncattrs():\\n return 0\\n\\n global_attr = getattr(ds, attr)\\n\\n try:\\n parser.isoparse(global_attr)\\n return 2\\n except ValueError:\\n return 1\",\n \"def GetValidAttributeValues(self, attr):\\n return None\",\n \"def _checkAttributeIndex(self, index):\\n\\n if index > len(self._attributes):\\n raise IndexError(\\\"'\\\" + str(index) + \\\"' is out of the range of 'attributes' array.\\\")\\n\\n return True\",\n \"def _validate_item_required_attrs(self, item):\\n if not getattr(item, \\\"title\\\", None):\\n raise ValueError(\\\"Required attribute title is not set.\\\")\\n\\n if not getattr(item, \\\"published\\\", None):\\n raise ValueError(\\\"Required attribute published is not set.\\\")\\n\\n if not getattr(item, \\\"link\\\", None):\\n raise ValueError(\\\"Required attribute link is not set.\\\")\\n\\n return True\",\n \"def filterattrs(event):\\n for a in ['description', 'summary', 'location']:\\n if not hasattr(event, a):\\n return False\\n return True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71051097","0.71051097","0.68592334","0.67489237","0.6746817","0.6668083","0.6662779","0.66370493","0.6567249","0.6491474","0.64705056","0.6454897","0.64076465","0.6375244","0.6368247","0.62872916","0.622392","0.61547047","0.61213416","0.6109168","0.6107715","0.60963625","0.60590523","0.602804","0.60012394","0.5983227","0.5979157","0.5936251","0.5912777","0.5885872","0.5860559","0.58413815","0.58345497","0.58037573","0.5796229","0.5792322","0.57852805","0.5765373","0.5734033","0.57238305","0.571153","0.5708705","0.5701176","0.56796","0.565688","0.5648645","0.5641132","0.56398463","0.5625106","0.5614053","0.56098956","0.557436","0.55729425","0.557218","0.5562394","0.55551946","0.5554898","0.55543125","0.55417264","0.554126","0.5534328","0.55284095","0.5525245","0.5517567","0.5516548","0.55152774","0.5496808","0.5488135","0.5485716","0.54664344","0.5464797","0.5429286","0.5418892","0.5409519","0.5407129","0.54069084","0.5405572","0.53983927","0.5396532","0.53955454","0.53931487","0.53909427","0.5375301","0.53695035","0.5360928","0.534179","0.53411645","0.5337569","0.5336886","0.5336347","0.5326683","0.5324458","0.5309865","0.53076255","0.52910274","0.5281917","0.52735895","0.5270231","0.5270175","0.5268587"],"string":"[\n \"0.71051097\",\n \"0.71051097\",\n \"0.68592334\",\n \"0.67489237\",\n \"0.6746817\",\n \"0.6668083\",\n \"0.6662779\",\n \"0.66370493\",\n \"0.6567249\",\n \"0.6491474\",\n \"0.64705056\",\n \"0.6454897\",\n \"0.64076465\",\n \"0.6375244\",\n \"0.6368247\",\n \"0.62872916\",\n \"0.622392\",\n \"0.61547047\",\n \"0.61213416\",\n \"0.6109168\",\n \"0.6107715\",\n \"0.60963625\",\n \"0.60590523\",\n \"0.602804\",\n \"0.60012394\",\n \"0.5983227\",\n \"0.5979157\",\n \"0.5936251\",\n \"0.5912777\",\n \"0.5885872\",\n \"0.5860559\",\n \"0.58413815\",\n \"0.58345497\",\n \"0.58037573\",\n \"0.5796229\",\n \"0.5792322\",\n \"0.57852805\",\n \"0.5765373\",\n \"0.5734033\",\n \"0.57238305\",\n \"0.571153\",\n \"0.5708705\",\n \"0.5701176\",\n \"0.56796\",\n \"0.565688\",\n \"0.5648645\",\n \"0.5641132\",\n \"0.56398463\",\n \"0.5625106\",\n \"0.5614053\",\n \"0.56098956\",\n \"0.557436\",\n \"0.55729425\",\n \"0.557218\",\n \"0.5562394\",\n \"0.55551946\",\n \"0.5554898\",\n \"0.55543125\",\n \"0.55417264\",\n \"0.554126\",\n \"0.5534328\",\n \"0.55284095\",\n \"0.5525245\",\n \"0.5517567\",\n \"0.5516548\",\n \"0.55152774\",\n \"0.5496808\",\n \"0.5488135\",\n \"0.5485716\",\n \"0.54664344\",\n \"0.5464797\",\n \"0.5429286\",\n \"0.5418892\",\n \"0.5409519\",\n \"0.5407129\",\n \"0.54069084\",\n \"0.5405572\",\n \"0.53983927\",\n \"0.5396532\",\n \"0.53955454\",\n \"0.53931487\",\n \"0.53909427\",\n \"0.5375301\",\n \"0.53695035\",\n \"0.5360928\",\n \"0.534179\",\n \"0.53411645\",\n \"0.5337569\",\n \"0.5336886\",\n \"0.5336347\",\n \"0.5326683\",\n \"0.5324458\",\n \"0.5309865\",\n \"0.53076255\",\n \"0.52910274\",\n \"0.5281917\",\n \"0.52735895\",\n \"0.5270231\",\n \"0.5270175\",\n \"0.5268587\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6629096"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":93190,"cells":{"query":{"kind":"string","value":"Creates a graph from saved GraphDef file and returns a saver."},"document":{"kind":"string","value":"def create_graph():\n # Creates graph from saved graph_def.pb.\n with tf.gfile.FastGFile(os.path.join(\n '/home/ubuntu/hdd/tensorFlowDic/', 'classify_image_graph_def.pb'), 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n _ = tf.import_graph_def(graph_def, name='')"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def create_graph():\n # Creates graph from saved graph_def.pb.\n with tf.gfile.FastGFile(modelFullPath, 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n _ = tf.import_graph_def(graph_def, name='')","def create_graph():\n # Creates graph from saved graph_def.pb.\n with tf.gfile.FastGFile(os.path.join(\n FLAGS.model_dir, pbfilename), 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n _ = tf.import_graph_def(graph_def, name='')","def create_graph():\n\t# Creates graph from saved graph_def.pb.\n\twith tf.gfile.FastGFile(modelFullPath, 'rb') as f:\n\t\tgraph_def = tf.GraphDef()\n\t\tgraph_def.ParseFromString(f.read())\n\t\t_ = tf.import_graph_def(graph_def, name='')","def create_graph():\n # Creates graph from saved graph_def.pb.\n with tf.gfile.FastGFile(sys.argv[1], 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n _ = tf.import_graph_def(graph_def, name='')","def create_graph():\n with tf.gfile.FastGFile(os.path.join(\n config['inference']['model_dir'], 'output_graph.pb'), 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n _ = tf.import_graph_def(graph_def, name='')","def create_graph():\n with gfile.FastGFile(os.path.join(\n FLAGS.model_dir, FLAGS.model_name), 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n _ = tf.import_graph_def(graph_def, name='')","def create_graph():\n\t# Creates graph from saved graph_def.pb.\n\twith tf.gfile.FastGFile('./models/inception_v4.pb', 'rb') as f:\n\t\tgraph_def = tf.GraphDef()\n\t\tgraph_def.ParseFromString(f.read())\n\t\t_ = tf.import_graph_def(graph_def, name='')","def create_graph():\n # Creates graph from saved graph_def.pb.\n\n # with tf.gfile.FastGFile(os.path.join(\n # FLAGS.model_dir, 'classify_image_graph_def.pb'), 'rb') as f:\n with tf.gfile.FastGFile(os.path.join(\n FLAGS.model_dir, 'output_graph.pb'), 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n _ = tf.import_graph_def(graph_def, name='')","def load_graph_def(filename):\n input_graph_def = tf.GraphDef()\n with gfile.FastGFile(filename, 'rb') as file:\n data = file.read()\n input_graph_def.ParseFromString(data)\n return input_graph_def","def create_graph():\n # Creates graph from saved graph_def.pb.\n with tf.gfile.FastGFile(os.path.join(\n MODEL_DIR, 'classify_image_graph_def.pb'), 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n _ = tf.import_graph_def(graph_def, name='')","def _load_graph(self, graph_file):\n graph = tf.Graph()\n with graph.as_default():\n od_graph_def = tf.GraphDef()\n with tf.gfile.GFile(graph_file, 'rb') as fid:\n serialized_graph = fid.read()\n od_graph_def.ParseFromString(serialized_graph)\n tf.import_graph_def(od_graph_def, name='')\n return graph","def save_graph(graph, graph_file_name, module_spec, class_count):\n sess, _, _, _, _, _ = build_eval_session(module_spec, class_count)\n save_graph_to_file(graph_file_name, sess)","def load_graph(self, graph_file):\n graph = tf.Graph()\n with graph.as_default():\n od_graph_def = tf.GraphDef()\n with tf.gfile.GFile(graph_file, 'rb') as fid:\n serialized_graph = fid.read()\n od_graph_def.ParseFromString(serialized_graph)\n tf.import_graph_def(od_graph_def, name='')\n return graph","def create_graph():\n # Creates graph from saved graph_def.pb.\n with tf.gfile.FastGFile(os.path.join(\n FLAGS.model_dir, 'classify_image_graph_def.pb'), 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n _ = tf.import_graph_def(graph_def, name='')","def create_graph():\n # Creates graph from saved graph_def.pb.\n with gfile.FastGFile(os.path.join(\n FLAGS.model_dir, 'classify_image_graph_def.pb'), 'r') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n _ = tf.import_graph_def(graph_def, name='')","def create_graph():\n # Creates graph from saved graph_def.pb.\n with tf.gfile.FastGFile(os.path.join(FLAGS.model_dir, r'/home/lg/Desktop/finetune/frozen_inception_v3_299.pb'), 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n _ = tf.import_graph_def(graph_def,return_elements=['InceptionV3/Predictions/Reshape_1:0'], name='lg')","def get_graph_def_from_disk(filename):\n with gfile.FastGFile(filename, 'rb') as f:\n return graph_pb2.GraphDef.FromString(f.read())","def saveGraph(self, filename):\n nx.write_yaml(self.G,filename)","def load_graph(filename):\n with tf.gfile.GFile(filename, 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n tf.import_graph_def(graph_def, name='')","def load_graph(path):\n with tf.gfile.GFile(path, \"rb\") as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n\n # Imports the graph_def into a new Graph and returns it\n with tf.Graph().as_default() as graph:\n tf.import_graph_def(graph_def, name=\"model\")\n return graph","def saveGraph (self, filename) :\n\t\tss = \"digraph {\\n\"\n\t\tfor key, rules in self.production_rules.items() :\n\t\t\tfor rule in rules :\n\t\t\t\tr = [op.val for op in rule]\n\t\t\t\tr = [i.replace (\"-\", \"\") for i in r]\n\t\t\t\tr = [i.replace (\".\", \"\") for i in r]\n\t\t\t\tr = [i.replace (\"\\'\\'\", \"eps\") for i in r]\n\t\t\t\tr = [i.replace (\"\\\"\\\"\", \"eps\") for i in r]\n\t\t\t\tr = [i.replace (\"/\", \"_\") for i in r]\n\t\t\t\tk = key.replace (\"-\", \"\")\n\t\t\t\tk = k.replace (\"/\", \"_\")\n\t\t\t\tk = k.replace (\".\", \"_tok\")\n\t\t\t\tss += \"\\t\" + k + \" -> \" \n\t\t\t\tss += \" -> \".join (r)\n\t\t\t\tss += \" ;\\n\"\n\t\tss += \"}\"\n\t\tfilestream = open (filename + '.dot', 'w') \n\t\tfilestream.write(ss)\n\t\tfilestream.close ()\n\t\tcmd = 'dot -Tpng -o ' + filename + '.png ' + filename + '.dot'\n\t\tos.system (cmd)\n\t\tcmd = 'rm ' + filename + '.dot'\n\t\tos.system (cmd)","def load_graph(filename):\n with tf.gfile.FastGFile(filename, 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n tf.import_graph_def(graph_def, name='')","def load_graph(filename):\n with tf.gfile.FastGFile(filename, 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n tf.import_graph_def(graph_def, name='')","def build_graph(self, save_model_path):\n if os.path.exists(\"{}.meta\".format(save_model_path)):\n logger.info(\"Graph existed, ready to be reloaded...\")\n else:\n logger.info(\"No graph can be loaded, so create a new graph...\")\n tf.reset_default_graph()\n # placeholders\n x = self.neural_net_image_input((32, 32, 3))\n y = self.neural_net_label_input(10)\n keep_prob = self.neural_net_keep_prob_input()\n\n # model\n logits_out = self.conv_net(x, keep_prob)\n\n # Name logits_out\n logits_out = tf.identity(logits_out, name='logits')\n\n # loss and optimizer\n loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits_out, labels=y), name='cost')\n optimzer = tf.train.AdamOptimizer(name='optimizer').minimize(loss)\n\n # Accuracy\n correct_pred = tf.equal(tf.argmax(y, axis=1), tf.argmax(logits_out, axis=1))\n accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32), name='accuracy')\n\n # print(type(tf.Variable(1)))\n saver = tf.train.Saver()\n if not os.path.exists('./savedModel'):\n os.mkdir('./savedModel')\n with tf.Session() as sess:\n sess.run(tf.global_variables_initializer())\n saver.save(sess, './savedModel/cnn-model')","def load_graph(filename):\n\twith tf.gfile.FastGFile(filename, 'rb') as f:\n\t\tgraph_def = tf.GraphDef()\n\t\tgraph_def.ParseFromString(f.read())\n\t\ttf.import_graph_def(graph_def, name='')","def load_graph(graph_file):\n graph = tf.Graph()\n with graph.as_default():\n od_graph_def = tf.compat.v1.GraphDef()\n with tf.io.gfile.GFile(graph_file, 'rb') as fid:\n serialized_graph = fid.read()\n od_graph_def.ParseFromString(serialized_graph)\n tf.import_graph_def(od_graph_def, name='')\n return graph","def writeGraph2File(self, file, genGraph=1, isRootNode=0, rootNodeName = \"rootNode\", \\\r\n indent=\" \", genConstraints = 0, fileName = '', genGGcode = 0, parentName=\"self\", \\\r\n genImports = 0, depth = 1, nodesToGenList = [] ):\r\n\r\n # generate code for the nodes...\r\n counter =0\r\n if( not nodesToGenList ):\r\n for nodetype in self.nodeTypes:\t\t\t\t\t\t# iterate on all the node types...\r\n for node in self.listNodes[nodetype]:\t\t\t\t\t# Iterate on all the nodes of each type\r\n node.genAttributesCode(file, genGraph, None, isRootNode, rootNodeName, indent, genConstraints, 1, genGGcode, parentName, genImports, depth + 1 )\r\n if self.isSubclass(node, 'ASG'):\t\t\t\t\t# if it is a subclass of ASG, ws should include the file generated (hierarchical modeling)\r\n newFile = fileName+str(counter)\r\n file.write(indent+'exec \"from '+newFile+' import '+newFile+'\\\\n\" in self.__dict__, self.__dict__\\n')\r\n file.write(indent+'self.'+newFile+'(self, self.obj'+str(node.objectNumber)+') \\n\\n')\r\n counter = counter + 1\r\n else:\r\n for node in nodesToGenList:\t\t\t\t\r\n node.genAttributesCode(file, genGraph, None, isRootNode, rootNodeName, indent, genConstraints, 1, genGGcode, parentName, genImports, depth + 1 )\r\n if self.isSubclass(node, 'ASG'):\t\t\t\t\t# if it is a subclass of ASG, ws should include the file generated (hierarchical modeling)\r\n newFile = fileName+str(counter)\r\n file.write(indent+'exec \"from '+newFile+' import '+newFile+'\\\\n\" in self.__dict__, self.__dict__\\n')\r\n file.write(indent+'self.'+newFile+'(self, self.obj'+str(node.objectNumber)+') \\n\\n')\r\n counter = counter + 1\r\n \r\n \r\n # if fileName has a value, we are saving a model, we must generate a function to hold the connections...\r\n if fileName != '':\r\n # if we are not dealing with a hierarchical model, an extra method is not needed..\r\n hierarchical = self.isHierarchical()\r\n if hierarchical:\r\n file.write('\\ndef '+fileName+'_connections(self, rootNode):\\n')\r\n\r\n\r\n #-------- Modified by Ximeng Sun / Apr 9,2005 for large conn nums --------\r\n file.write('\\n')\r\n writed = 0\r\n # generate code for the connections...\r\n if( not nodesToGenList ):\r\n for nodetype in self.nodeTypes:\r\n for node in self.listNodes[nodetype]:\r\n if isRootNode: \r\n if(node.__dict__.has_key('name')):\r\n debugName = ' named ' + node.name.toString() + '\\n'\r\n else:\r\n debugName = ' of type ' + node.__class__.__name__ + '\\n'\r\n file.write(indent+'# Connections for obj'+str(node.objectNumber)\r\n +' (graphObject_: '+node.graphObject_.tag + ')' + debugName)\r\n file.write(indent+'self.drawConnections(\\n')\r\n res = node.genConnectionsCode(file, genGraph, isRootNode, \r\n indent, 1, writed)\r\n if isRootNode: \r\n file.write(' )\\n')\r\n else:\r\n for node in nodesToGenList:\r\n if isRootNode: file.write(indent+'self.drawConnections(')\r\n res = node.genConnectionsCode(file, genGraph, isRootNode, indent, 1, \r\n writed, nodesToGenList = nodesToGenList)\r\n if isRootNode: file.write(' )\\n')\r\n file.write('\\n')\r\n #------------ End of modification by Ximeng Sun / Apr 9,2005 -------------\r\n \r\n \r\n # if rootNode and I'm generating a function (filename != '')\r\n # then call subModel's functions for connections...\r\n if isRootNode and fileName != '': # if main model\r\n counter = 0\r\n if( not nodesToGenList ):\r\n for nodetype in self.nodeTypes: # iterate, to search for all submodels\r\n for node in self.listNodes[nodetype]:\r\n if self.isSubclass(node, 'ASG'): # found a submodel\r\n file.write(indent+'self.'+fileName+str(counter)+'_connections( self, self.obj'+str(node.objectNumber)+')\\n')\r\n writed = 1\r\n counter = counter + 1\r\n else:\r\n for node in nodesToGenList:\r\n if self.isSubclass(node, 'ASG'): # found a submodel\r\n file.write(indent+'self.'+fileName+str(counter)+'_connections( self, self.obj'+str(node.objectNumber)+')\\n')\r\n writed = 1\r\n counter = counter + 1\r\n \r\n \r\n if fileName != '' and (not writed) and hierarchical: # we must write 'pass', because nothing has been writed in the function!!\r\n file.write(indent+'pass\\n')","def write_graph(self, graph_def):\n write_name = self.params.model_name+\"_v\"+self.params.version+\".pb\"\n self.writer = tf.compat.v1.summary.FileWriter(self.params.save_dir, graph=self.graph)\n tf.io.write_graph(graph_def,\n logdir=self.params.save_dir, name=write_name, as_text=False)\n self.logger.log_info(\"Graph def saved in file %s\"%self.params.save_dir+write_name)","def save_graph(self, filename, fileType):\n if fileType == \"GML Format\":\n nx.write_gml(self.graph, filename+\".gml\")\n if fileType == \"Adjacency list\":\n nx.write_adjlist(self.graph, filename+\".adjlist\")\n if fileType == \"YAML\":\n nx.write_yaml(self.graph, filename + \".yaml\")","def load_graph(self,frozen_file_name):\n with tf.gfile.GFile(frozen_file_name, \"rb\") as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n with tf.Graph().as_default() as graph:\n tf.import_graph_def(\n graph_def,\n input_map=None,\n return_elements=None,\n name=\"prefix\",\n op_dict=None,\n producer_op_list=None\n )\n return graph","def CreateGraph(graph_def):\n option = GetGlobalOptions()\n LogMetaGraph(graph_def)\n ExportMetaGraph(graph_def)\n return _C.CreateGraph(\n _stringify_proto(graph_def),\n option['log_optimized_graph'],\n )","def create_graph(self, modelDir):\n # Creates graph from saved graph_def.pb.\n with tf.gfile.FastGFile(os.path.join(\n modelDir, 'classify_image_graph_def.pb'), 'rb') as f:\n \tgraph_def = tf.GraphDef()\n \tgraph_def.ParseFromString(f.read())\n \t_ = tf.import_graph_def(graph_def, name='')","def savegraph(self, path):\n\n raise NotImplementedError","def make_graph_from_file(filename):\n file = open(filename, \"r\")\n lines = file.readlines()\n file.close()\n\n # Check if it is a graph or digraph\n graph_or_digraph_str = lines[0].strip() if len(lines) > 0 else None\n if graph_or_digraph_str != \"G\" and graph_or_digraph_str != \"D\":\n raise Exception(\"File must start with G or D.\")\n is_bidirectional = graph_or_digraph_str == \"G\"\n\n g = Graph()\n\n # Add all vertices\n for vertex_key in lines[1].strip(\"() \\n\").split(\",\"):\n g.add_vertex(vertex_key)\n\n # Add all edges\n for line in lines[2:]:\n # Split components of edge\n new_edge = line.strip(\"() \\n\").split(\",\")\n if len(new_edge) < 2 or len(new_edge) > 3:\n raise Exception(\"Lines adding edges must include 2 or 3 values\")\n\n # Get vertices\n vertex1, vertex2 = new_edge[:2]\n\n # Get weight if it exists\n weight = int(new_edge[2]) if len(new_edge) == 3 else None\n\n # Add edge(s)\n g.add_edge(vertex1, vertex2, weight)\n if is_bidirectional:\n g.add_edge(vertex2, vertex1, weight)\n\n return g\n # Check if first line is 'G' or 'D' and store the value. If neither, raise an exception\n # For each vertex id in first line, add a vertex to the graph\n # For each of the following lines:\n # Extract the vertex ids and the (optional) weight, and add an edge to the graph\n # If it is a Graph and not a Digraph, add another edge in the opposite direction\n # Raise an exception if line contains too many (or too few) item\n raise Exception(f\"File must begin with G or D, found {firstline}\")","def get_graph_def_from_resource(filename):\n return graph_pb2.GraphDef.FromString(resource_loader.load_resource(filename))","def read_graph(filename):\n with open(filename) as f:\n g = eval(f.read())\n return g","def write_graph(build_graph, out_dir):\n g = ops.Graph()\n with g.as_default():\n build_graph(out_dir)\n filename = os.path.join(out_dir, 'test_graph_%s.pb' % build_graph.__name__)\n with open(filename, 'wb') as f:\n f.write(g.as_graph_def().SerializeToString())","def __load_graph(self, sess, save_model_path):\n graph = {}\n\n loader = tf.train.import_meta_graph(save_model_path + '.meta')\n loader.restore(sess, save_model_path)\n\n graph['x'] = sess.graph.get_tensor_by_name(\"x:0\")\n graph['y'] = sess.graph.get_tensor_by_name(\"y:0\")\n graph['keep_prob'] = sess.graph.get_tensor_by_name(\"keep_prob:0\")\n graph['cost'] = sess.graph.get_tensor_by_name('cost:0')\n graph['accuracy'] = sess.graph.get_tensor_by_name('accuracy:0')\n graph['logits'] = sess.graph.get_tensor_by_name(\"logits:0\")\n graph['optimizer'] = sess.graph.get_operation_by_name(\"optimizer\")\n\n logger.info(\"model is ready, good to go!\")\n return graph","def save_graph(self):\n with tf.Session(graph=self.graph) as sess:\n saver = tf.train.Saver()\n sess.run(tf.global_variables_initializer())\n\n save_path = saver.save(sess, os.path.join(MODELS_PATH, \"model\"))\n print(\"Model saved in path: %s\" % save_path)\n\n with open(os.path.join(MODELS_PATH, \".model.inputs\"), \"w\") as file:\n for v in self.inputs.values():\n file.write(v.name + \"\\n\")\n with open(os.path.join(MODELS_PATH, \".model.output\"), \"w\") as file:\n file.write(self.output.name)","def build_saver(self):\n #this is used to restore and save the graph default_saver.restore\n\n default_saver = tf.train.Saver(max_to_keep=3, allow_empty=True)\n self.savers = {self.name: default_saver}","def load_graph(net_file):\n path, filename = os.path.split(net_file)\n net_name = os.path.splitext(filename)[0]\n # get full path\n path = os.path.abspath(path)\n pickle_dir = path + os.sep + \"cache\"\n if not os.path.isdir(pickle_dir):\n os.mkdir(pickle_dir)\n pickle_file = \"{0}/{1}.pickle\".format(pickle_dir, net_name)\n if (os.path.isfile(pickle_file) and\n os.stat(net_file).st_mtime < os.stat(pickle_file).st_mtime):\n # Pickle file exists, and source_file is older\n graph = nx.read_gpickle(pickle_file)\n else:\n # No pickle file, or is outdated\n graph = nx.read_gml(net_file)\n nx.write_gpickle(graph, pickle_file)\n # ANK only understands GML files cleaned by topzootools\n if 'Creator' in graph.graph:\n if graph.graph['Creator'] == \"Topology Zoo Toolset\":\n # Graph has been processed by topzootools into suitable \n # format for ank\n return graph\n elif graph.graph['Creator'] == ' \"yFiles\"':\n # Note yFiles has quotes and leading space after nx parsing\n #TODO: try and use topzootools module (if installed)\n # to do conversion\n # to a /tmp file\n LOG.warn(\"Using GML file exported from yED, \"\n \"Please use TopZooTools to convert yED GML file\"\n \" into Topology Zoo format for use in AutoNetkit\")\n #TODO: make this throw exception so that program exits\n return None\n else:\n #Unknown file creator, may be user manually created, but warn\n LOG.warn(\"Unknown GML file creator\")\n return graph\n else:\n # No creator specified\n return graph","def create():\n # for clean test cases, first the available databases will be flushed\n get_redis().flushdb()\n graph = FileStructureProcessor()\n return graph.get_graph()","def save_graph(self, path):\n if path.split('.')[-1]=='gexf':\n nx.write_gexf(self.graph, path)\n else:\n nx.write_gpickle(self.graph, path)","def obtain_graph(parsed):\n try:\n graphtype = parsed['graphtype']\n except KeyError:\n raise InternalBug(\n \"Unknown graph type has been accepted on command line.\")\n\n assert graphtype in constructions\n\n if parsed['construction'] in constructions[graphtype]:\n obtain_G = constructions[graphtype][parsed['construction']]\n G = obtain_G(parsed)\n\n else:\n assert parsed['construction'] is None\n assert 'filename' in parsed\n assert 'fileformat' in parsed\n filename = parsed['filename']\n fileformat = parsed['fileformat']\n G = read_graph_from_input(graphtype, filename, fileformat)\n\n # Add planted cliques\n if graphtype == 'simple':\n if 'plantclique' in parsed:\n G = modify_simple_graph_plantclique(parsed, G)\n elif graphtype == 'bipartite':\n if 'plantbiclique' in parsed:\n G = modify_bipartite_graph_plantbiclique(parsed, G)\n # Add random edges\n if 'addedges' in parsed:\n G = modify_graph_addedges(parsed, G)\n\n # Output the graph when requested\n if 'save' in parsed:\n saveformat, savefilename = parsed['save']\n writeGraph(G, savefilename, graphtype, saveformat)\n\n assert hasattr(G, 'name')\n return G","def save_network(self, sess, filename):\n dir_path = os.path.dirname(os.path.realpath(__file__))\n dir_path += '/Models/'\n dir_path += filename\n saver = tf.train.Saver()\n saver.save(sess, dir_path)","def _save_model(graph_or_sess):\r\n if isinstance(graph_or_sess, tf.Graph):\r\n ops = graph_or_sess.get_operations()\r\n for op in ops:\r\n if 'variable' in op.type.lower():\r\n raise ValueError('Please input a frozen graph (no variables). Or pass in the session object.')\r\n\r\n with graph_or_sess.as_default():\r\n sess = tf.Session(config=configProto)\r\n\r\n fake_var = tf.Variable([0.0], name=\"fake_var\")\r\n sess.run(tf.global_variables_initializer())\r\n else:\r\n sess=graph_or_sess\r\n\r\n PATH = os.path.join(\"model\", \"tmp-model\")\r\n make_dir(path = os.path.dirname(PATH))\r\n saver = tf.train.Saver()\r\n #i should deal with the case in which sess is closed.\r\n saver.save(sess, PATH)\r\n\r\n if isinstance(graph_or_sess, tf.Graph):\r\n sess.close()\r\n\r\n return PATH + \".meta\"","def createModel(config_path, checkpoint_path, graph_path):\n\n global build_graph, prev_classes\n\n trt_graph = None\n input_names = None\n \n if build_graph:\n frozen_graph, input_names, output_names = build_detection_graph(\n config=config_path,\n checkpoint=checkpoint_path\n )\n \n trt_graph = trt.create_inference_graph(\n input_graph_def=frozen_graph,\n outputs=output_names,\n max_batch_size=1,\n max_workspace_size_bytes=1 << 25,\n precision_mode='FP16',\n minimum_segment_size=50\n )\n\n with open(graph_path, 'wb') as f:\n f.write(trt_graph.SerializeToString())\n\n with open('config.txt', 'r+') as json_file: \n data = json.load(json_file)\n data['model'] = []\n data['model'] = [{'input_names': input_names}]\n json_file.seek(0)\n json_file.truncate()\n json.dump(data, json_file)\n\n else:\n with open(graph_path, 'rb') as f:\n trt_graph = tf.GraphDef()\n trt_graph.ParseFromString(f.read())\n with open('config.txt') as json_file: \n data = json.load(json_file)\n input_names = data['model'][0]['input_names']\n\n return Model(trt_graph, input_names)","def get_graph_binary(self):\n with open(os.path.join(self.network_dir,\"graph\"), mode='rb') as file:\n graph = file.read()\n return graph","def graph(automaton,graph_name=\"finite_state_machine\",file_name=\"finite_state_machine.gv\"):\n letter = next(iter(automaton.states))[0]\n grph = Digraph(graph_name,filename=file_name)\n grph.attr(rankdir=letter, size='8,5')\n #specifying final nodes \n grph.attr('node', shape='doublecircle')\n for state in automaton.final_states:\n grph.node(state)\n #creating edges\n \n grph.attr('node', shape='circle')\n if(isinstance(automaton,DFA)):\n grph =addEdgesDFA(grph,automaton)\n grph.edge(\"\",automaton.initial_state,\"\")\n grph.edge(\"\",automaton.initial_state,\"\")\n else:\n grph =addEdgesNFA(grph,automaton) \n return grph","def build_graph(file_name):\n graph = MyGraph()\n with open(file_name, 'r') as fin:\n line = fin.readline().replace('\\n', '')\n while line != \"\":\n vals = line.split(':')\n graph.add_node(vals[0], pos=(int(vals[1]),int(vals[2])))\n line = fin.readline().replace('\\n', '')\n dest = fin.readline().replace('\\n','').split('\\t')\n line = fin.readline().replace('\\n', '')\n edges = []\n while line != '':\n node_info = line.split('\\t')\n src = node_info[0]\n for node in range(1,len(node_info)):\n if node_info[node] != '':\n if (dest[node],src) not in edges:\n edges.append((src,dest[node], node_info[node]))\n line = fin.readline().replace('\\n','')\n for edge in edges:\n graph.add_edge(edge[0], edge[1], weight=int(edge[2]))\n\n return graph","def save(self, filepath, overwrite=True, include_optimizer=True):\n if not self._is_graph_network:\n raise NotImplementedError\n\n from tensorflow.python.keras._impl.keras.models import save_model # pylint: disable=g-import-not-at-top\n save_model(self, filepath, overwrite, include_optimizer)","def load_network(self, sess, filename):\n dir_path = os.path.dirname(os.path.realpath(__file__))\n dir_path += '/Models/'\n dir_path += filename\n saver = tf.train.Saver()\n saver.restore(sess, dir_path)","def load(self, saved_model_dir_or_frozen_graph: Text):\n if not self.sess:\n self.sess = self._build_session()\n self.signitures = {\n 'image_files': 'image_files:0',\n 'image_arrays': 'image_arrays:0',\n 'prediction': 'detections:0',\n }\n\n # Load saved model if it is a folder.\n if tf.io.gfile.isdir(saved_model_dir_or_frozen_graph):\n return tf.saved_model.load(self.sess, ['serve'],\n saved_model_dir_or_frozen_graph)\n\n # Load a frozen graph.\n graph_def = tf.GraphDef()\n with tf.gfile.GFile(saved_model_dir_or_frozen_graph, 'rb') as f:\n graph_def.ParseFromString(f.read())\n return tf.import_graph_def(graph_def, name='')","def write_graph(g, filename):\n with open(filename, 'w') as f:\n f.write(repr(g))","def dump_graph(self) -> str:\n graph_dot_file = f'{self._name}.dot'\n graph_diagram_file = f'{self._name}.svg'\n write_dot(self._graph, graph_dot_file)\n subprocess.check_output(\n shlex.split(f'dot -Tsvg {graph_dot_file} -o {graph_diagram_file}')\n )\n return graph_diagram_file","def __init__(self, MY_GRAPH_PATH):\n self.graph = tf.Graph()\n\n graph_def = None\n with tf.gfile.FastGFile(MY_GRAPH_PATH, 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n\n if graph_def is None:\n raise RuntimeError('Cannot find inference graph in tar archive.')\n\n with self.graph.as_default():\n tf.import_graph_def(graph_def, name='')\n\n self.sess = tf.Session(graph=self.graph)","def tf_load_model(model_file):\n\n graph = tf.Graph()\n graph_def = tf.compat.v1.GraphDef()\n\n with open(model_file, \"rb\") as f:\n graph_def.ParseFromString(f.read())\n with graph.as_default():\n tf.import_graph_def(graph_def)\n\n return graph","def read_graph_file(path):\n\n node_graph = graph_pb2.Scene()\n\n if not os.path.exists(path):\n getLog().error(\"Missing graph file: {}\".format(path))\n return\n\n with open(path, \"rb\") as read_file:\n node_graph.ParseFromString(read_file.read())\n\n return node_graph","def trace_to_graph(infile):\n assert '.tr' in infile\n outfile = infile.replace('.tr', '.graph')\n\n infile = open(infile)\n outfile = open(outfile, 'w')\n\n for line in infile:\n if line.startswith('module:'):\n tokens = line.split(' ')\n module_name = tokens[1]\n outfile.write('module: %s' % module_name)\n continue\n elif line.startswith('num_nodes:'):\n tokens = line.split(' ')\n num_nodes = int(tokens[1])\n outfile.write('%s\\n' % num_nodes)\n continue\n elif not line.startswith('ID:'): # skip the header lines\n continue\n elif 'DST:' not in line: # skip single qubit gates\n continue\n\n tokens = line.split(' ')\n assert tokens[4].startswith('SRC:')\n assert tokens[6].startswith('DST:')\n src = int(tokens[5])\n dst = int(tokens[7])\n assert src < num_nodes\n assert dst < num_nodes\n outfile.write('%s %s\\n' % (src, dst))","def _build_graph(self):\n\n self.graph = tf.Graph()\n\n # set self.graph as default graph\n with self.graph.as_default():\n # # clear old variables\n # tf.reset_default_graph()\n\n # set random seed\n if self.random_seed is not None:\n tf.set_random_seed(self.random_seed)\n\n self._create_placeholders()\n self._create_variables()\n\n self._create_prediction()\n\n self._create_loss()\n self._create_optimizer()\n\n self._init = tf.global_variables_initializer()\n\n self.saver = tf.train.Saver()\n\n # create session\n self.sess = tf.Session(graph=self.graph)","def load_graph(self, filename):\n try:\n file_extention = list(filename.split(\".\"))[-1]\n if file_extention == \"gml\":\n self.graph = nx.read_gml(filename)\n if file_extention == \"adjlist\":\n self.graph = nx.read_adjlist(filename)\n if file_extention == \"yaml\":\n self.graph = nx.read_yaml(filename)\n except Exception as e:\n print(\"Error in loading Graph file: The error is\", e)","def restore(cls, \n session, \n param_dir):\n with open(cls._parameters_file(param_dir)) as f:\n parameters = json.load(f)\n\n # Encapsulate training parameters\n training_parameters = TrainingParameters(parameters[\"training_epochs\"])\n\n # Encapsulate model hyperparameters\n model_parameters = ModelParameters(\n parameters[\"learning_rate\"],\n parameters[\"momentum\"],\n parameters[\"model\"],\n parameters[\"input_keep_probability\"],\n parameters[\"output_keep_probability\"],\n parameters[\"sequence_length\"],\n parameters[\"input_dimension\"],\n parameters[\"batch_size\"], \n parameters[\"state_size\"], \n parameters[\"n_layers\"],\n parameters[\"n_classes\"])\n\n # Encapsulate directories name\n directories = Directories(parameters[\"log_dir\"],\n parameters[\"checkpoint_dir\"])\n\n model = cls(\n model_parameters,\n training_parameters,\n directories)\n\n # Load the saved meta graph and restore variables\n checkpoint_file = tf.train.latest_checkpoint(directories.checkpoint_dir)\n print(\"restoring graph from {} ...\".format(checkpoint_file))\n # Restore an empty computational graph\n #saver = tf.train.import_meta_graph(\"{}.meta\".format(checkpoint_file))\n \n # Restore an already existing graph\n saver = tf.train.Saver()\n saver.restore(session, checkpoint_file)\n\n return model","def save_graph(graph_list: Union[Graph, List[Graph]], f: IO[str]):\n if type(graph_list) is list:\n write_graph_list(graph_list, f)\n else:\n write_graph_list([graph_list], f)","def create_graph_from_store(graph_name, store_type, port=8000):\n return SharedMemoryDGLGraph(graph_name, port)","def __init__(self, graph_path):\n self.graph = tf.Graph()\n graph_path = Path(graph_path)\n if not graph_path.exists():\n raise FileNotFoundError(\"The graph path not exists.\")\n\n graph_def = tf.compat.v1.GraphDef()\n loaded = graph_def.ParseFromString(open(graph_path, 'rb').read())\n\n if graph_def is None:\n raise RuntimeError('Graph load failed.')\n\n with self.graph.as_default():\n tf.import_graph_def(graph_def, name='')\n\n config = tf.ConfigProto()\n # config.gpu_options.visible_device_list = '1'\n config.gpu_options.allow_growth = True\n\n self.sess = tf.Session(graph=self.graph, config=config)","def save_graph(graph, file_name):\r\n print \"Saving network into \"+file_name\r\n f = open(file_name, 'w')\r\n f.write(str(len(graph))+'\\n')\r\n for citizen in graph:\r\n f.write(str(citizen.id) + ';' + str(citizen.location) + ';' + str(citizen.influence_level) + ';' + \\\r\n str(citizen.proactivity_level) + '\\n')\r\n for op in citizen.opinions.keys():\r\n value = citizen.opinions[op].weight\r\n f.write(str(op)+':'+str(value)+';')\r\n f.write('\\n')\r\n for friend in citizen.friends:\r\n f.write(str(friend.id) + ';')\r\n f.write('\\n')\r\n f.close()","def make_graph(self):\n\n # the root node\n self.graph.node(self.playbook_filename, style=\"dotted\", id=\"root_node\")\n\n # loop through the plays\n for play_counter, play in enumerate(self.playbook.get_plays(), 1):\n\n # the load basedir is relative to the playbook path\n if play._included_path is not None:\n self.data_loader.set_basedir(play._included_path)\n else:\n self.data_loader.set_basedir(self.playbook._basedir)\n self.display.vvv(\"Loader basedir set to {}\".format(self.data_loader.get_basedir()))\n\n play_vars = self.variable_manager.get_vars(play)\n play_hosts = [h.get_name() for h in self.inventory_manager.get_hosts(self.template(play.hosts, play_vars))]\n play_name = \"Play #{}: {} ({})\".format(play_counter, clean_name(play.get_name()), len(play_hosts))\n play_name = self.template(play_name, play_vars)\n\n self.display.banner(\"Graphing \" + play_name)\n\n play_id = \"play_\" + str(uuid.uuid4())\n\n self.graph_representation.add_node(play_id)\n\n with self.graph.subgraph(name=play_name) as play_subgraph:\n color, play_font_color = get_play_colors(play)\n # play node\n play_subgraph.node(play_name, id=play_id, style=\"filled\", shape=\"box\", color=color,\n fontcolor=play_font_color, tooltip=\" \".join(play_hosts))\n\n # edge from root node to plays\n play_edge_id = \"edge_\" + str(uuid.uuid4())\n play_subgraph.edge(self.playbook_filename, play_name, id=play_edge_id, style=\"bold\",\n label=str(play_counter), color=color, fontcolor=color)\n\n # loop through the pre_tasks\n self.display.v(\"Graphing pre_tasks...\")\n nb_pre_tasks = 0\n for pre_task_block in play.pre_tasks:\n nb_pre_tasks = self._include_tasks_in_blocks(current_play=play, graph=play_subgraph,\n parent_node_name=play_name, parent_node_id=play_id,\n block=pre_task_block, color=color,\n current_counter=nb_pre_tasks, play_vars=play_vars,\n node_name_prefix=\"[pre_task] \")\n\n # loop through the roles\n self.display.v(\"Graphing roles...\")\n role_number = 0\n for role in play.get_roles():\n # Don't insert tasks from ``import/include_role``, preventing duplicate graphing\n if role.from_include:\n continue\n\n # the role object doesn't inherit the tags from the play. So we add it manually.\n role.tags = role.tags + play.tags\n if not role.evaluate_tags(only_tags=self.options.tags, skip_tags=self.options.skip_tags,\n all_vars=play_vars):\n self.display.vv(\"The role '{}' is skipped due to the tags.\".format(role.get_name()))\n # Go to the next role\n continue\n\n role_number += 1\n role_name = \"[role] \" + clean_name(role.get_name())\n\n with self.graph.subgraph(name=role_name, node_attr={}) as role_subgraph:\n current_counter = role_number + nb_pre_tasks\n role_id = \"role_\" + str(uuid.uuid4())\n edge_id = \"edge_\" + str(uuid.uuid4())\n\n role_subgraph.node(role_name, id=role_id)\n # edge from play to role\n role_subgraph.edge(play_name, role_name, label=str(current_counter), color=color,\n fontcolor=color, id=edge_id)\n\n self.graph_representation.add_link(play_id, edge_id)\n self.graph_representation.add_link(edge_id, role_id)\n\n # loop through the tasks of the roles\n if self.options.include_role_tasks:\n role_tasks_counter = 0\n for block in role.compile(play):\n role_tasks_counter = self._include_tasks_in_blocks(current_play=play,\n graph=role_subgraph,\n parent_node_name=role_name,\n parent_node_id=role_id, block=block,\n color=color, play_vars=play_vars,\n current_counter=role_tasks_counter,\n node_name_prefix=\"[task] \")\n role_tasks_counter += 1\n self.display.v(\"{} roles added to the graph\".format(role_number))\n\n # loop through the tasks\n self.display.v(\"Graphing tasks...\")\n nb_tasks = 0\n for task_block in play.tasks:\n nb_tasks = self._include_tasks_in_blocks(current_play=play, graph=play_subgraph,\n parent_node_name=play_name, parent_node_id=play_id,\n block=task_block, color=color,\n current_counter=role_number + nb_pre_tasks,\n play_vars=play_vars, node_name_prefix=\"[task] \")\n\n # loop through the post_tasks\n self.display.v(\"Graphing post_tasks...\")\n for post_task_block in play.post_tasks:\n self._include_tasks_in_blocks(current_play=play, graph=play_subgraph, parent_node_name=play_name,\n parent_node_id=play_id, block=post_task_block, color=color,\n current_counter=nb_tasks, play_vars=play_vars,\n node_name_prefix=\"[post_task] \")\n\n self.display.banner(\"Done graphing {}\".format(play_name))\n self.display.display(\"\") # just an empty line\n # moving to the next play","def FromFile(cls, path: pathlib.Path, ir_id: int):\n with open(path, \"rb\") as f:\n graph_tuple = pickle.load(f)\n\n return cls.CreateFromGraphTuple(graph_tuple, ir_id)","def create_graph(self, ctx: Context, graph_input: str) -> DefaultEmbed:\n with TemporaryFile(suffix=\".png\") as buffer:\n with Graph(ctx, buffer, *self.calculate(graph_input)) as embed:\n return embed","def loadgraph(self, path):\n\n raise NotImplementedError","def get_graph_proto(graph_or_graph_def, as_text=True):\n # tf.train.write_graph(session.graph.as_graph_def(), path.join(\n # \".\", \"graph\"), \"{}.pb\".format(name), False)\n if isinstance(graph_or_graph_def, ops.Graph):\n graph_def = graph_or_graph_def.as_graph_def()\n else:\n graph_def = graph_or_graph_def\n\n if as_text:\n return str(graph_def)\n else:\n return graph_def.SerializeToString()","def parse_graphml_file(filename: str, digraph=True):\n graphml_graph = nx.read_graphml(filename)\n if digraph:\n graphml_graph = graphml_graph.to_directed()\n\n return graphml_graph","def __init__(self, path):\n self.graph = tf.Graph()\n\n graph_def = None\n tf.reset_default_graph()\n with tf.gfile.GFile(path, 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n\n if graph_def is None:\n raise RuntimeError('Cannot find inference graph in tar archive.')\n\n with self.graph.as_default():\n tf.import_graph_def(graph_def, name='')\n\n self.sess = tf.Session(graph=self.graph)","def save_graph(graph_list: Union[Graph, List[Graph]], f: IO[str], options=[]):\n if type(graph_list) is list:\n write_graph_list(graph_list, f, options)\n else:\n write_graph_list([graph_list], f, options)","def save_graphs(name, path):\n # Generate Fiber Density vs. Wedges graph\n save_graph_fiber_vs_wedges(name, path)\n\n # Generate Fiber Density vs. Rings graph\n save_graph_fiber_vs_rings(name, path)","def load_graph(frozen_graph_filename, input_shape, namespace_prefix=\"\", old_input=None):\n # Load graph def from protobuff and import the definition\n with tf.gfile.GFile(frozen_graph_filename, \"rb\") as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n\n if old_input is None:\n with tf.Graph().as_default() as graph:\n tf.import_graph_def(graph_def, name=namespace_prefix)\n else:\n with tf.Graph().as_default() as graph:\n tf_new_input = tf.placeholder(tf.float32, shape=input_shape, name=\"input_tensor\")\n tf.import_graph_def(graph_def, input_map={old_input: tf_new_input}, name=namespace_prefix)\n return graph","def convert_ckpt_to_saved_model(checkpoint_path, saved_model_path, signature, proto_fields, meta_graph_path=None,\n graph=None, session=None):\n from diplomacy_research.utils.tensorflow import tf, graph_util, build_tensor_info, saved_model_builder, \\\n signature_def_utils, tag_constants, variables, PREDICT_METHOD_NAME\n\n # Loading the checkpoint from disk\n if graph is None or session is None:\n graph, session = load_graph_from_ckpt(checkpoint_path,\n meta_graph_path=meta_graph_path,\n graph=graph,\n session=session)\n # Converting graph to constant\n input_graph_def = graph.as_graph_def()\n output_keys = [k for k in graph.get_all_collection_keys() if ('variable' not in k.lower()\n and '_step' not in k\n and '_op' not in k\n and '_context' not in k\n and not k.startswith('_')\n and not k.endswith('_ta')\n and 'summaries' not in k\n and 'is_trainable' not in k)]\n\n # Finding output nodes and extra tags\n extra_tags = {}\n output_nodes = []\n for key in output_keys:\n nodes_in_collection = graph.get_collection(key)\n for node in nodes_in_collection:\n if isinstance(node, variables.PartitionedVariable):\n output_nodes += [var.name for var in node._get_variable_list()] # pylint: disable=protected-access\n elif hasattr(node, 'name'):\n output_nodes += [node.name]\n else:\n extra_tags.setdefault(key, [])\n extra_tags[key] += [node]\n\n # Converting graph to constant\n output_graph_def = graph_util.convert_variables_to_constants(session,\n input_graph_def,\n [node.split(':')[0] for node in output_nodes])\n\n # Storing date/time, original filename, and launch args\n created_date = datetime.fromtimestamp(time.time(), timezone('America/Montreal'))\n extra_tags['tag/created_date'] = [created_date.strftime(\"%Y-%m-%d %H:%M:%S %Z\")]\n extra_tags['tag/filename'] = [saved_model_path.split('/')[-1]]\n extra_tags['tag/launch_cmd'] = [' '.join(sys.argv)]\n\n # Importing in a new graph\n output_graph = tf.Graph()\n with output_graph.as_default():\n tf.import_graph_def(output_graph_def)\n\n # Finding placeholders, features, and outputs\n features, placeholders, outputs = {}, {}, {}\n collection_keys = graph.get_all_collection_keys()\n for key in collection_keys:\n node = graph.get_collection(key)\n if isinstance(node, list) and node: # If list, getting first element\n node = node[0]\n if key.startswith('feature'):\n features[key.replace('feature_', '')] = output_graph.get_tensor_by_name('import/' + node.name)\n elif key.startswith('placeholder'):\n placeholders[key.replace('placeholder_', '')] = output_graph.get_tensor_by_name('import/' + node.name)\n elif hasattr(node, 'name'):\n try:\n outputs[key] = output_graph.get_tensor_by_name('import/' + node.name)\n except (KeyError, ValueError):\n continue\n\n # Adding extra tags\n for key in extra_tags:\n for value in extra_tags[key]:\n output_graph.add_to_collection(key, value)\n\n # Converting sparse fields\n proto_fields = BaseBuilder.parse_sparse_fields(proto_fields)\n\n # Building signature\n signature_def = {}\n for method_name in signature:\n method_placeholders = signature.get(method_name).get('placeholders', {})\n method_outputs = signature.get(method_name).get('outputs', [])\n\n # Skipping method if we are missing some outputs\n missing_outputs = [output_name for output_name in method_outputs if output_name not in outputs]\n if missing_outputs:\n LOGGER.warning('Unable to build method %s using the provided signature.', method_name)\n continue\n\n signature_inputs = {feature_name: build_tensor_info(features[feature_name]) for feature_name in features\n if feature_name in proto_fields}\n for ph_name in method_placeholders:\n signature_inputs[ph_name] = build_tensor_info(placeholders[ph_name])\n signature_outputs = {'%03d_%s' % (output_id, output_name): build_tensor_info(outputs[output_name])\n for output_id, output_name in enumerate(method_outputs)}\n\n signature_def[method_name] = signature_def_utils.build_signature_def(inputs=signature_inputs,\n outputs=signature_outputs,\n method_name=PREDICT_METHOD_NAME)\n\n # Saving to disk\n with output_graph.as_default():\n temp_model_path = '/'.join(saved_model_path.split('/')[:-1] + ['__%s__' % saved_model_path.split('/')[-1]])\n\n # Deleting from disk to avoid 'Directory already exists'\n shutil.rmtree(saved_model_path, ignore_errors=True)\n shutil.rmtree(temp_model_path, ignore_errors=True)\n\n # Saving to a temporary path, to make sure the serving does not try to load the version before it is ready\n builder = saved_model_builder.SavedModelBuilder(temp_model_path)\n builder.add_meta_graph_and_variables(session,\n [tag_constants.SERVING],\n signature_def_map=signature_def,\n clear_devices=True)\n builder.save()\n\n # Renaming to the correct path\n shutil.move(temp_model_path, saved_model_path)\n\n # Returning\n return graph, session","def create_graph(dot, filename=\"network\"):\n proc = subprocess.Popen('dot -Tpng > %s.png' % filename,\n shell=True,\n stdin=subprocess.PIPE\n )\n proc.communicate(dot.encode('utf_8'))\n execvp('open', ['open', '%s.png'%filename,])","def read_graph(filename, directed=True):\n if not directed:\n G = nx.Graph()\n else:\n G = nx.DiGraph()\n with open(filename) as f:\n for line in f:\n d = line.split()\n G.add_edge(int(d[0]), int(d[1]))\n print('Read Graph')\n return G","def getGraph(self, data):\n graphuri = self.getGraphURI(data)\n # TODO: consider using temporary disk storage to not overload server\n # ... or stop parsing graph by some other means\n g = Graph(identifier=graphuri)\n\n if data['filedata'] and data['filedata'] != NOT_CHANGED:\n # uploaded file ...\n fmt = guessRDFFileFormat(data['format'],\n data['filedata'].contentType,\n data['filedata'].filename)\n g.parse(StringIO(data['filedata'].data), format=fmt)\n elif data['downloadurl']:\n # TODO: would be nice to check graph for graphuri, but it is\n # already a bit late here... needs improvement\n fmt = guessRDFFileFormat(data['format'], '', '')\n g.parse(data['downloadurl'], format=fmt)\n return g","def build_graph(self):\n self.import_tree(ZOO_PATH, self.import_zoo, self.verify_zoos)\n self.import_tree(WILD_PATH, self.import_wild, self.verify_wilds)\n self.import_tree(PANDA_PATH, self.import_redpanda, self.verify_pandas)\n self.import_tree(MEDIA_PATH, self.import_media, self.verify_media)","def load_graph(f: IO[str], graph_class=Graph) -> list[Graph]:\n return read_graph_list(graph_class, f)","def load_graph(self,dataset):\n dataset = cd.build_dataset_from_name(dataset)\n self.data = dataset[0]\n G = nx.Graph()\n G.add_edges_from(self.data.edge_index.t().tolist())\n return G","def create_graph(gene, generation, gene_number):\n f = Digraph('finite_state_machine', filename='saved_data/gen'+str(generation)+'/'+str(gene_number))\n f.attr(rankdir='BT', size='8,5')\n\n f.attr('node', shape='circle')\n list_of_connections = gene.return_connections()\n list_of_nodes = gene.return_nodes()\n\n with f.subgraph(name='cluster_input') as c:\n c.attr(style='filled', color='lightgrey')\n c.node_attr.update(style='filled', color='white')\n for node in list_of_nodes:\n if node[1] == 'input':\n c.node(str(node[0]))\n c.attr(label='input')\n\n with f.subgraph(name='cluster_output') as c:\n c.attr(style='filled', color='lightgrey')\n c.node_attr.update(style='filled', color='white')\n for node in list_of_nodes:\n if node[1] == 'output':\n c.node(str(node[0]))\n c.attr(label='output')\n for connection in list_of_connections:\n if connection[3]:\n f.edge(str(connection[0]), str(connection[1]), str(\"%.2f\" % round(connection[2], 2)))\n else :\n f.edge(str(connection[0]), str(connection[1]), str(\"%.2f\" % round(connection[2], 2)), style=\"dotted\")\n\n f.render()","def _store_graph(self, graph, name=None):\n if graph == self:\n raise ValueError(\"Cannot add graph into itself\")\n if name is None:\n root = self\n else:\n # When a name is specified, create or merge into a new subgraph\n try:\n root = self._items[name]\n if isinstance(root, NodeDef):\n raise ValueError(\"Graph already contains node by name %s\" % name)\n except KeyError:\n root = SubGraph(self._prefix + (name,), self._downstream, self._upstream, self._root)\n self._items[name] = root\n\n # Function for recursively copying over the source graph structure to the target\n def _copy_structure(source_graph, target_graph, prefix):\n for key, value in source_graph._items.items():\n if isinstance(value, NodeDef):\n target_graph._store_node(value)\n else:\n new_prefix = prefix + (key,)\n\n try:\n new_graph = target_graph._items[key]\n except KeyError:\n target_graph._items[key] = new_graph = SubGraph(new_prefix,\n self._downstream,\n self._upstream,\n self._root)\n\n _copy_structure(value, new_graph, new_prefix)\n\n _copy_structure(graph, root, root._prefix)\n\n def _copy_edges(source_edges, target_edges):\n for source, targets in source_edges.items():\n target_edge = target_edges[root._prefix + source]\n\n # Filter out edge definitions already present.\n # This needs to be done in two passes because there can be deliberately duplicate edge definitions\n # for nodes.\n rebased_targets = []\n for target in targets:\n edge = EdgeDef(root._prefix + target.node, target.param)\n if edge not in target_edge:\n rebased_targets.append(edge)\n\n target_edge.extend(rebased_targets)\n\n _copy_edges(graph._downstream, self._downstream)\n _copy_edges(graph._upstream, self._upstream)","def save_render(self, savefile=\"tree.gv\"):\n from graphviz import Source\n src = Source(self.get_dot())\n path = 'graphviz/{}'.format(savefile)\n src.render(path)","def load_graph(self, path):\n if path.split('.')[-1]=='gexf':\n self.graph = nx.read_gexf(path)\n else:\n self.graph = nx.read_gpickle(path)","def create_graph(self,root_path):\n graph = self.graph\n\n #get the path lists recursively from the root directory \n path_list = sorted(Path(root_path).rglob('*'))\n # create the necessary amount of vertices \n graph.add_vertices(len(path_list)+1)\n \n # these list will be used for inserting to sqlite database\n vertices = []\n edges = []\n\n # now the edges have to be created, and the vertices need the file informations\n # first is the root vertex\n temp=graph.vs[0]\n temp[\"name\"]=root_path\n temp[\"parent\"]=\"\"\n temp[\"size\"]=os.stat(root_path).st_size\n temp[\"last_modified\"]=os.stat(root_path).st_mtime\n temp[\"last_accessed\"]=os.stat(root_path).st_atime\n \n vertices.append((0,temp[\"name\"],temp[\"parent\"],temp[\"size\"],temp[\"last_modified\"],temp[\"last_accessed\"]))\n\n # walking through the paths, the vertices get the informations, and the egdes will be created\n for i, file in enumerate(path_list):\n temp=graph.vs[i+1]\n temp[\"name\"]=file.as_posix()\n temp[\"parent\"]=file.parent.as_posix()\n temp[\"size\"]=os.stat(file).st_size\n temp[\"last_modified\"]=os.stat(file).st_mtime\n temp[\"last_accessed\"]=os.stat(file).st_atime\n vertices.append((temp.index,temp[\"name\"],temp[\"parent\"],temp[\"size\"],temp[\"last_modified\"],temp[\"last_accessed\"]))\n \n parent_id=graph.vs.find(name=temp[\"parent\"]).index\n # Egde is defined beetween the current vertex and its parent\n graph.add_edges([(i+1,parent_id)])\n edges.append((i+1,parent_id))\n\n # save the created Graph object into the connected redis database as JSON\n cache= get_redis()\n cache.execute_command('JSON.SET', 'vertices_name','.',json.dumps(self.graph.vs[\"name\"]))\n cache.execute_command('JSON.SET', 'vertices_parent','.',json.dumps(self.graph.vs[\"parent\"]))\n cache.execute_command('JSON.SET', 'vertices_size','.',json.dumps(self.graph.vs[\"size\"]))\n cache.execute_command('JSON.SET', 'vertices_last_modified','.',json.dumps(self.graph.vs[\"last_modified\"]))\n cache.execute_command('JSON.SET', 'vertices_last_accessed','.',json.dumps(self.graph.vs[\"last_accessed\"]))\n cache.execute_command('JSON.SET', 'edges','.',json.dumps(self.graph.get_edgelist()))\n\n # save the created Graph object into the connected sqlite database \n conn = get_sqlite()\n c = conn.cursor()\n c.execute('DROP TABLE IF EXISTS vertices')\n c.execute('DROP TABLE IF EXISTS edges')\n c.execute('CREATE TABLE vertices (id, name, parent, size, last_modified, last_accessed)')\n c.execute('CREATE TABLE edges (start, end)')\n c.executemany('INSERT INTO vertices VALUES (?,?,?,?,?,?)', vertices)\n c.executemany('INSERT INTO edges VALUES (?,?)', edges)\n conn.commit()\n\n # optionally create image from the Graph object\n # unfortunatelly this feature not working correctly now\n plot(graph,\"plot.png\", layout=\"tree\")","def create_visual_graph(self):\n if self.predict_new and self.prediction_without_covid_case:\n self.predict_co2_emission_future()\n self.save_prediction_df()\n else:\n self.restore_prediction_df()\n if not self.analysis_plot:\n self.predict_co2_emission_future()\n self.save_prediction_df()\n\n self.do_plot()\n self.output_graph_file = OUTPUT_GRAPH_PATH\n return self.output_graph_file","def gen_graph(file_path, data_string):\n with open(file_path, 'w+') as f:\n f.write(data_string)\n os.system('python files/termgraph.py {}'.format(file_path))","def load_graph(file_name, directed=True):\n G = nx.DiGraph() if directed else nx.Graph()\n with open(file_name, \"r\") as f:\n for line in f:\n tokens = line.split()\n u = int(tokens[0])\n v = int(tokens[1])\n if len(tokens) > 2:\n w = float(tokens[2])\n G.add_edge(u, v, weight=w)\n else:\n G.add_edge(u,v)\n return G","def save_to(self, file_path, size=(8196, 4096)):\n # create graph\n g = Graph(directed=True)\n\n for node in self.graph:\n g.add_vertex(node.article.unescaped_identifier)\n\n for source in self.graph:\n for target in source.edges:\n g.add_edge(source.article.unescaped_identifier, target.article.unescaped_identifier)\n\n # create properties\n vertex_labels = list(map(lambda x: x.article.unescaped_identifier, self.graph))\n vertex_label_colors = list(map(self.__vertex_label_colors, self.graph))\n vertex_label_sizes = list(map(self.__vertex_label_sizes, self.graph))\n\n # plot graph to file\n # format is implicitly given by file extension and automatically\n # determined by igraph\n plot(g, file_path,\n # set image resolution\n bbox=(0, 0, size[0], size[1]),\n # set image margin to allow long labels to be displayed correctly\n margin=128,\n # allow curved edges to reduce intersections\n autocurve=True,\n # choose graph layout\n # layout='large_graph',\n layout='fr',\n niter=2000,\n # set vertex options\n vertex_size=5,\n vertex_color='#ff9999',\n vertex_frame_color='#777777',\n # set edge options\n edge_width=0.5,\n edge_color='#999999',\n edge_arrow_size=0.5,\n # set label options\n vertex_label=vertex_labels,\n vertex_label_color=vertex_label_colors,\n vertex_label_size=vertex_label_sizes)","def saveSettings(self):\n self.genFiles.applyData()\n self.genGraph.applyData()","def save(self, filename):\n self.graph.save(filename)\n with open(filename + \".json\", \"w\") as f:\n f.write(json.dumps(self.params))","def import_graph(graph_def, t_input=None, scope='import', forget_xy_shape=True):\n graph = tf.get_default_graph()\n assert graph.unique_name(scope, False) == scope, (\n 'Scope \"%s\" already exists. Provide explicit scope names when '\n 'importing multiple instances of the model.') % scope\n t_input, t_prep_input = self.create_input(t_input, forget_xy_shape)\n tf.import_graph_def(\n graph_def, {self.input_name: t_prep_input}, name=scope)\n self.post_import(scope)","def post(self, sketch_id, graph_id):\n sketch = Sketch.query.get_with_acl(sketch_id)\n if not sketch:\n abort(HTTP_STATUS_CODE_NOT_FOUND, \"No sketch found with this ID.\")\n\n if not sketch.has_permission(current_user, \"write\"):\n abort(\n HTTP_STATUS_CODE_FORBIDDEN,\n \"User does not have write access controls on sketch.\",\n )\n\n graph = Graph.query.get(graph_id)\n if not graph:\n abort(HTTP_STATUS_CODE_NOT_FOUND, \"No graph found with this ID.\")\n\n if not sketch.id == graph.sketch.id:\n abort(HTTP_STATUS_CODE_BAD_REQUEST, \"Graph does not belong to this sketch.\")\n\n form = request.json\n if not form:\n form = request.data\n\n name = form.get(\"name\")\n if name:\n graph.name = name\n\n description = form.get(\"description\")\n if description:\n graph.description = description\n\n elements = form.get(\"elements\")\n if elements:\n graph.graph_elements = json.dumps(elements)\n\n graph_config = form.get(\"graph_config\")\n graph_json = \"\"\n if graph_config:\n if isinstance(graph_config, dict):\n graph_json = json.dumps(graph_config)\n elif isinstance(graph_config, str):\n graph_json = graph_config\n if graph_json:\n graph.graph_config = graph_json\n\n db_session.add(graph)\n db_session.commit()\n\n # Update the last activity of a sketch.\n utils.update_sketch_last_activity(sketch)\n\n return self.to_json(graph, status_code=HTTP_STATUS_CODE_CREATED)","def save(self, save_path):\n self.graph.saver.save(self.sess, save_path)","def save(self, save_path):\n self.graph.saver.save(self.sess, save_path)","def save_taskgraph(self, filename):\n\n if not TaskGraph.__SETUP_YAML_ONCE:\n TaskGraph.setup_yaml()\n\n # we want -id to be first in the resulting yaml file.\n tlist_od = self.export_task_speclist()\n with open(filename, 'w') as fh:\n ruamel.yaml.dump(tlist_od, fh, default_flow_style=False)","def graph(graph_file):\n return render_template(graph_file)"],"string":"[\n \"def create_graph():\\n # Creates graph from saved graph_def.pb.\\n with tf.gfile.FastGFile(modelFullPath, 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n _ = tf.import_graph_def(graph_def, name='')\",\n \"def create_graph():\\n # Creates graph from saved graph_def.pb.\\n with tf.gfile.FastGFile(os.path.join(\\n FLAGS.model_dir, pbfilename), 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n _ = tf.import_graph_def(graph_def, name='')\",\n \"def create_graph():\\n\\t# Creates graph from saved graph_def.pb.\\n\\twith tf.gfile.FastGFile(modelFullPath, 'rb') as f:\\n\\t\\tgraph_def = tf.GraphDef()\\n\\t\\tgraph_def.ParseFromString(f.read())\\n\\t\\t_ = tf.import_graph_def(graph_def, name='')\",\n \"def create_graph():\\n # Creates graph from saved graph_def.pb.\\n with tf.gfile.FastGFile(sys.argv[1], 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n _ = tf.import_graph_def(graph_def, name='')\",\n \"def create_graph():\\n with tf.gfile.FastGFile(os.path.join(\\n config['inference']['model_dir'], 'output_graph.pb'), 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n _ = tf.import_graph_def(graph_def, name='')\",\n \"def create_graph():\\n with gfile.FastGFile(os.path.join(\\n FLAGS.model_dir, FLAGS.model_name), 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n _ = tf.import_graph_def(graph_def, name='')\",\n \"def create_graph():\\n\\t# Creates graph from saved graph_def.pb.\\n\\twith tf.gfile.FastGFile('./models/inception_v4.pb', 'rb') as f:\\n\\t\\tgraph_def = tf.GraphDef()\\n\\t\\tgraph_def.ParseFromString(f.read())\\n\\t\\t_ = tf.import_graph_def(graph_def, name='')\",\n \"def create_graph():\\n # Creates graph from saved graph_def.pb.\\n\\n # with tf.gfile.FastGFile(os.path.join(\\n # FLAGS.model_dir, 'classify_image_graph_def.pb'), 'rb') as f:\\n with tf.gfile.FastGFile(os.path.join(\\n FLAGS.model_dir, 'output_graph.pb'), 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n _ = tf.import_graph_def(graph_def, name='')\",\n \"def load_graph_def(filename):\\n input_graph_def = tf.GraphDef()\\n with gfile.FastGFile(filename, 'rb') as file:\\n data = file.read()\\n input_graph_def.ParseFromString(data)\\n return input_graph_def\",\n \"def create_graph():\\n # Creates graph from saved graph_def.pb.\\n with tf.gfile.FastGFile(os.path.join(\\n MODEL_DIR, 'classify_image_graph_def.pb'), 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n _ = tf.import_graph_def(graph_def, name='')\",\n \"def _load_graph(self, graph_file):\\n graph = tf.Graph()\\n with graph.as_default():\\n od_graph_def = tf.GraphDef()\\n with tf.gfile.GFile(graph_file, 'rb') as fid:\\n serialized_graph = fid.read()\\n od_graph_def.ParseFromString(serialized_graph)\\n tf.import_graph_def(od_graph_def, name='')\\n return graph\",\n \"def save_graph(graph, graph_file_name, module_spec, class_count):\\n sess, _, _, _, _, _ = build_eval_session(module_spec, class_count)\\n save_graph_to_file(graph_file_name, sess)\",\n \"def load_graph(self, graph_file):\\n graph = tf.Graph()\\n with graph.as_default():\\n od_graph_def = tf.GraphDef()\\n with tf.gfile.GFile(graph_file, 'rb') as fid:\\n serialized_graph = fid.read()\\n od_graph_def.ParseFromString(serialized_graph)\\n tf.import_graph_def(od_graph_def, name='')\\n return graph\",\n \"def create_graph():\\n # Creates graph from saved graph_def.pb.\\n with tf.gfile.FastGFile(os.path.join(\\n FLAGS.model_dir, 'classify_image_graph_def.pb'), 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n _ = tf.import_graph_def(graph_def, name='')\",\n \"def create_graph():\\n # Creates graph from saved graph_def.pb.\\n with gfile.FastGFile(os.path.join(\\n FLAGS.model_dir, 'classify_image_graph_def.pb'), 'r') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n _ = tf.import_graph_def(graph_def, name='')\",\n \"def create_graph():\\n # Creates graph from saved graph_def.pb.\\n with tf.gfile.FastGFile(os.path.join(FLAGS.model_dir, r'/home/lg/Desktop/finetune/frozen_inception_v3_299.pb'), 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n _ = tf.import_graph_def(graph_def,return_elements=['InceptionV3/Predictions/Reshape_1:0'], name='lg')\",\n \"def get_graph_def_from_disk(filename):\\n with gfile.FastGFile(filename, 'rb') as f:\\n return graph_pb2.GraphDef.FromString(f.read())\",\n \"def saveGraph(self, filename):\\n nx.write_yaml(self.G,filename)\",\n \"def load_graph(filename):\\n with tf.gfile.GFile(filename, 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n tf.import_graph_def(graph_def, name='')\",\n \"def load_graph(path):\\n with tf.gfile.GFile(path, \\\"rb\\\") as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n\\n # Imports the graph_def into a new Graph and returns it\\n with tf.Graph().as_default() as graph:\\n tf.import_graph_def(graph_def, name=\\\"model\\\")\\n return graph\",\n \"def saveGraph (self, filename) :\\n\\t\\tss = \\\"digraph {\\\\n\\\"\\n\\t\\tfor key, rules in self.production_rules.items() :\\n\\t\\t\\tfor rule in rules :\\n\\t\\t\\t\\tr = [op.val for op in rule]\\n\\t\\t\\t\\tr = [i.replace (\\\"-\\\", \\\"\\\") for i in r]\\n\\t\\t\\t\\tr = [i.replace (\\\".\\\", \\\"\\\") for i in r]\\n\\t\\t\\t\\tr = [i.replace (\\\"\\\\'\\\\'\\\", \\\"eps\\\") for i in r]\\n\\t\\t\\t\\tr = [i.replace (\\\"\\\\\\\"\\\\\\\"\\\", \\\"eps\\\") for i in r]\\n\\t\\t\\t\\tr = [i.replace (\\\"/\\\", \\\"_\\\") for i in r]\\n\\t\\t\\t\\tk = key.replace (\\\"-\\\", \\\"\\\")\\n\\t\\t\\t\\tk = k.replace (\\\"/\\\", \\\"_\\\")\\n\\t\\t\\t\\tk = k.replace (\\\".\\\", \\\"_tok\\\")\\n\\t\\t\\t\\tss += \\\"\\\\t\\\" + k + \\\" -> \\\" \\n\\t\\t\\t\\tss += \\\" -> \\\".join (r)\\n\\t\\t\\t\\tss += \\\" ;\\\\n\\\"\\n\\t\\tss += \\\"}\\\"\\n\\t\\tfilestream = open (filename + '.dot', 'w') \\n\\t\\tfilestream.write(ss)\\n\\t\\tfilestream.close ()\\n\\t\\tcmd = 'dot -Tpng -o ' + filename + '.png ' + filename + '.dot'\\n\\t\\tos.system (cmd)\\n\\t\\tcmd = 'rm ' + filename + '.dot'\\n\\t\\tos.system (cmd)\",\n \"def load_graph(filename):\\n with tf.gfile.FastGFile(filename, 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n tf.import_graph_def(graph_def, name='')\",\n \"def load_graph(filename):\\n with tf.gfile.FastGFile(filename, 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n tf.import_graph_def(graph_def, name='')\",\n \"def build_graph(self, save_model_path):\\n if os.path.exists(\\\"{}.meta\\\".format(save_model_path)):\\n logger.info(\\\"Graph existed, ready to be reloaded...\\\")\\n else:\\n logger.info(\\\"No graph can be loaded, so create a new graph...\\\")\\n tf.reset_default_graph()\\n # placeholders\\n x = self.neural_net_image_input((32, 32, 3))\\n y = self.neural_net_label_input(10)\\n keep_prob = self.neural_net_keep_prob_input()\\n\\n # model\\n logits_out = self.conv_net(x, keep_prob)\\n\\n # Name logits_out\\n logits_out = tf.identity(logits_out, name='logits')\\n\\n # loss and optimizer\\n loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits_out, labels=y), name='cost')\\n optimzer = tf.train.AdamOptimizer(name='optimizer').minimize(loss)\\n\\n # Accuracy\\n correct_pred = tf.equal(tf.argmax(y, axis=1), tf.argmax(logits_out, axis=1))\\n accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32), name='accuracy')\\n\\n # print(type(tf.Variable(1)))\\n saver = tf.train.Saver()\\n if not os.path.exists('./savedModel'):\\n os.mkdir('./savedModel')\\n with tf.Session() as sess:\\n sess.run(tf.global_variables_initializer())\\n saver.save(sess, './savedModel/cnn-model')\",\n \"def load_graph(filename):\\n\\twith tf.gfile.FastGFile(filename, 'rb') as f:\\n\\t\\tgraph_def = tf.GraphDef()\\n\\t\\tgraph_def.ParseFromString(f.read())\\n\\t\\ttf.import_graph_def(graph_def, name='')\",\n \"def load_graph(graph_file):\\n graph = tf.Graph()\\n with graph.as_default():\\n od_graph_def = tf.compat.v1.GraphDef()\\n with tf.io.gfile.GFile(graph_file, 'rb') as fid:\\n serialized_graph = fid.read()\\n od_graph_def.ParseFromString(serialized_graph)\\n tf.import_graph_def(od_graph_def, name='')\\n return graph\",\n \"def writeGraph2File(self, file, genGraph=1, isRootNode=0, rootNodeName = \\\"rootNode\\\", \\\\\\r\\n indent=\\\" \\\", genConstraints = 0, fileName = '', genGGcode = 0, parentName=\\\"self\\\", \\\\\\r\\n genImports = 0, depth = 1, nodesToGenList = [] ):\\r\\n\\r\\n # generate code for the nodes...\\r\\n counter =0\\r\\n if( not nodesToGenList ):\\r\\n for nodetype in self.nodeTypes:\\t\\t\\t\\t\\t\\t# iterate on all the node types...\\r\\n for node in self.listNodes[nodetype]:\\t\\t\\t\\t\\t# Iterate on all the nodes of each type\\r\\n node.genAttributesCode(file, genGraph, None, isRootNode, rootNodeName, indent, genConstraints, 1, genGGcode, parentName, genImports, depth + 1 )\\r\\n if self.isSubclass(node, 'ASG'):\\t\\t\\t\\t\\t# if it is a subclass of ASG, ws should include the file generated (hierarchical modeling)\\r\\n newFile = fileName+str(counter)\\r\\n file.write(indent+'exec \\\"from '+newFile+' import '+newFile+'\\\\\\\\n\\\" in self.__dict__, self.__dict__\\\\n')\\r\\n file.write(indent+'self.'+newFile+'(self, self.obj'+str(node.objectNumber)+') \\\\n\\\\n')\\r\\n counter = counter + 1\\r\\n else:\\r\\n for node in nodesToGenList:\\t\\t\\t\\t\\r\\n node.genAttributesCode(file, genGraph, None, isRootNode, rootNodeName, indent, genConstraints, 1, genGGcode, parentName, genImports, depth + 1 )\\r\\n if self.isSubclass(node, 'ASG'):\\t\\t\\t\\t\\t# if it is a subclass of ASG, ws should include the file generated (hierarchical modeling)\\r\\n newFile = fileName+str(counter)\\r\\n file.write(indent+'exec \\\"from '+newFile+' import '+newFile+'\\\\\\\\n\\\" in self.__dict__, self.__dict__\\\\n')\\r\\n file.write(indent+'self.'+newFile+'(self, self.obj'+str(node.objectNumber)+') \\\\n\\\\n')\\r\\n counter = counter + 1\\r\\n \\r\\n \\r\\n # if fileName has a value, we are saving a model, we must generate a function to hold the connections...\\r\\n if fileName != '':\\r\\n # if we are not dealing with a hierarchical model, an extra method is not needed..\\r\\n hierarchical = self.isHierarchical()\\r\\n if hierarchical:\\r\\n file.write('\\\\ndef '+fileName+'_connections(self, rootNode):\\\\n')\\r\\n\\r\\n\\r\\n #-------- Modified by Ximeng Sun / Apr 9,2005 for large conn nums --------\\r\\n file.write('\\\\n')\\r\\n writed = 0\\r\\n # generate code for the connections...\\r\\n if( not nodesToGenList ):\\r\\n for nodetype in self.nodeTypes:\\r\\n for node in self.listNodes[nodetype]:\\r\\n if isRootNode: \\r\\n if(node.__dict__.has_key('name')):\\r\\n debugName = ' named ' + node.name.toString() + '\\\\n'\\r\\n else:\\r\\n debugName = ' of type ' + node.__class__.__name__ + '\\\\n'\\r\\n file.write(indent+'# Connections for obj'+str(node.objectNumber)\\r\\n +' (graphObject_: '+node.graphObject_.tag + ')' + debugName)\\r\\n file.write(indent+'self.drawConnections(\\\\n')\\r\\n res = node.genConnectionsCode(file, genGraph, isRootNode, \\r\\n indent, 1, writed)\\r\\n if isRootNode: \\r\\n file.write(' )\\\\n')\\r\\n else:\\r\\n for node in nodesToGenList:\\r\\n if isRootNode: file.write(indent+'self.drawConnections(')\\r\\n res = node.genConnectionsCode(file, genGraph, isRootNode, indent, 1, \\r\\n writed, nodesToGenList = nodesToGenList)\\r\\n if isRootNode: file.write(' )\\\\n')\\r\\n file.write('\\\\n')\\r\\n #------------ End of modification by Ximeng Sun / Apr 9,2005 -------------\\r\\n \\r\\n \\r\\n # if rootNode and I'm generating a function (filename != '')\\r\\n # then call subModel's functions for connections...\\r\\n if isRootNode and fileName != '': # if main model\\r\\n counter = 0\\r\\n if( not nodesToGenList ):\\r\\n for nodetype in self.nodeTypes: # iterate, to search for all submodels\\r\\n for node in self.listNodes[nodetype]:\\r\\n if self.isSubclass(node, 'ASG'): # found a submodel\\r\\n file.write(indent+'self.'+fileName+str(counter)+'_connections( self, self.obj'+str(node.objectNumber)+')\\\\n')\\r\\n writed = 1\\r\\n counter = counter + 1\\r\\n else:\\r\\n for node in nodesToGenList:\\r\\n if self.isSubclass(node, 'ASG'): # found a submodel\\r\\n file.write(indent+'self.'+fileName+str(counter)+'_connections( self, self.obj'+str(node.objectNumber)+')\\\\n')\\r\\n writed = 1\\r\\n counter = counter + 1\\r\\n \\r\\n \\r\\n if fileName != '' and (not writed) and hierarchical: # we must write 'pass', because nothing has been writed in the function!!\\r\\n file.write(indent+'pass\\\\n')\",\n \"def write_graph(self, graph_def):\\n write_name = self.params.model_name+\\\"_v\\\"+self.params.version+\\\".pb\\\"\\n self.writer = tf.compat.v1.summary.FileWriter(self.params.save_dir, graph=self.graph)\\n tf.io.write_graph(graph_def,\\n logdir=self.params.save_dir, name=write_name, as_text=False)\\n self.logger.log_info(\\\"Graph def saved in file %s\\\"%self.params.save_dir+write_name)\",\n \"def save_graph(self, filename, fileType):\\n if fileType == \\\"GML Format\\\":\\n nx.write_gml(self.graph, filename+\\\".gml\\\")\\n if fileType == \\\"Adjacency list\\\":\\n nx.write_adjlist(self.graph, filename+\\\".adjlist\\\")\\n if fileType == \\\"YAML\\\":\\n nx.write_yaml(self.graph, filename + \\\".yaml\\\")\",\n \"def load_graph(self,frozen_file_name):\\n with tf.gfile.GFile(frozen_file_name, \\\"rb\\\") as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n with tf.Graph().as_default() as graph:\\n tf.import_graph_def(\\n graph_def,\\n input_map=None,\\n return_elements=None,\\n name=\\\"prefix\\\",\\n op_dict=None,\\n producer_op_list=None\\n )\\n return graph\",\n \"def CreateGraph(graph_def):\\n option = GetGlobalOptions()\\n LogMetaGraph(graph_def)\\n ExportMetaGraph(graph_def)\\n return _C.CreateGraph(\\n _stringify_proto(graph_def),\\n option['log_optimized_graph'],\\n )\",\n \"def create_graph(self, modelDir):\\n # Creates graph from saved graph_def.pb.\\n with tf.gfile.FastGFile(os.path.join(\\n modelDir, 'classify_image_graph_def.pb'), 'rb') as f:\\n \\tgraph_def = tf.GraphDef()\\n \\tgraph_def.ParseFromString(f.read())\\n \\t_ = tf.import_graph_def(graph_def, name='')\",\n \"def savegraph(self, path):\\n\\n raise NotImplementedError\",\n \"def make_graph_from_file(filename):\\n file = open(filename, \\\"r\\\")\\n lines = file.readlines()\\n file.close()\\n\\n # Check if it is a graph or digraph\\n graph_or_digraph_str = lines[0].strip() if len(lines) > 0 else None\\n if graph_or_digraph_str != \\\"G\\\" and graph_or_digraph_str != \\\"D\\\":\\n raise Exception(\\\"File must start with G or D.\\\")\\n is_bidirectional = graph_or_digraph_str == \\\"G\\\"\\n\\n g = Graph()\\n\\n # Add all vertices\\n for vertex_key in lines[1].strip(\\\"() \\\\n\\\").split(\\\",\\\"):\\n g.add_vertex(vertex_key)\\n\\n # Add all edges\\n for line in lines[2:]:\\n # Split components of edge\\n new_edge = line.strip(\\\"() \\\\n\\\").split(\\\",\\\")\\n if len(new_edge) < 2 or len(new_edge) > 3:\\n raise Exception(\\\"Lines adding edges must include 2 or 3 values\\\")\\n\\n # Get vertices\\n vertex1, vertex2 = new_edge[:2]\\n\\n # Get weight if it exists\\n weight = int(new_edge[2]) if len(new_edge) == 3 else None\\n\\n # Add edge(s)\\n g.add_edge(vertex1, vertex2, weight)\\n if is_bidirectional:\\n g.add_edge(vertex2, vertex1, weight)\\n\\n return g\\n # Check if first line is 'G' or 'D' and store the value. If neither, raise an exception\\n # For each vertex id in first line, add a vertex to the graph\\n # For each of the following lines:\\n # Extract the vertex ids and the (optional) weight, and add an edge to the graph\\n # If it is a Graph and not a Digraph, add another edge in the opposite direction\\n # Raise an exception if line contains too many (or too few) item\\n raise Exception(f\\\"File must begin with G or D, found {firstline}\\\")\",\n \"def get_graph_def_from_resource(filename):\\n return graph_pb2.GraphDef.FromString(resource_loader.load_resource(filename))\",\n \"def read_graph(filename):\\n with open(filename) as f:\\n g = eval(f.read())\\n return g\",\n \"def write_graph(build_graph, out_dir):\\n g = ops.Graph()\\n with g.as_default():\\n build_graph(out_dir)\\n filename = os.path.join(out_dir, 'test_graph_%s.pb' % build_graph.__name__)\\n with open(filename, 'wb') as f:\\n f.write(g.as_graph_def().SerializeToString())\",\n \"def __load_graph(self, sess, save_model_path):\\n graph = {}\\n\\n loader = tf.train.import_meta_graph(save_model_path + '.meta')\\n loader.restore(sess, save_model_path)\\n\\n graph['x'] = sess.graph.get_tensor_by_name(\\\"x:0\\\")\\n graph['y'] = sess.graph.get_tensor_by_name(\\\"y:0\\\")\\n graph['keep_prob'] = sess.graph.get_tensor_by_name(\\\"keep_prob:0\\\")\\n graph['cost'] = sess.graph.get_tensor_by_name('cost:0')\\n graph['accuracy'] = sess.graph.get_tensor_by_name('accuracy:0')\\n graph['logits'] = sess.graph.get_tensor_by_name(\\\"logits:0\\\")\\n graph['optimizer'] = sess.graph.get_operation_by_name(\\\"optimizer\\\")\\n\\n logger.info(\\\"model is ready, good to go!\\\")\\n return graph\",\n \"def save_graph(self):\\n with tf.Session(graph=self.graph) as sess:\\n saver = tf.train.Saver()\\n sess.run(tf.global_variables_initializer())\\n\\n save_path = saver.save(sess, os.path.join(MODELS_PATH, \\\"model\\\"))\\n print(\\\"Model saved in path: %s\\\" % save_path)\\n\\n with open(os.path.join(MODELS_PATH, \\\".model.inputs\\\"), \\\"w\\\") as file:\\n for v in self.inputs.values():\\n file.write(v.name + \\\"\\\\n\\\")\\n with open(os.path.join(MODELS_PATH, \\\".model.output\\\"), \\\"w\\\") as file:\\n file.write(self.output.name)\",\n \"def build_saver(self):\\n #this is used to restore and save the graph default_saver.restore\\n\\n default_saver = tf.train.Saver(max_to_keep=3, allow_empty=True)\\n self.savers = {self.name: default_saver}\",\n \"def load_graph(net_file):\\n path, filename = os.path.split(net_file)\\n net_name = os.path.splitext(filename)[0]\\n # get full path\\n path = os.path.abspath(path)\\n pickle_dir = path + os.sep + \\\"cache\\\"\\n if not os.path.isdir(pickle_dir):\\n os.mkdir(pickle_dir)\\n pickle_file = \\\"{0}/{1}.pickle\\\".format(pickle_dir, net_name)\\n if (os.path.isfile(pickle_file) and\\n os.stat(net_file).st_mtime < os.stat(pickle_file).st_mtime):\\n # Pickle file exists, and source_file is older\\n graph = nx.read_gpickle(pickle_file)\\n else:\\n # No pickle file, or is outdated\\n graph = nx.read_gml(net_file)\\n nx.write_gpickle(graph, pickle_file)\\n # ANK only understands GML files cleaned by topzootools\\n if 'Creator' in graph.graph:\\n if graph.graph['Creator'] == \\\"Topology Zoo Toolset\\\":\\n # Graph has been processed by topzootools into suitable \\n # format for ank\\n return graph\\n elif graph.graph['Creator'] == ' \\\"yFiles\\\"':\\n # Note yFiles has quotes and leading space after nx parsing\\n #TODO: try and use topzootools module (if installed)\\n # to do conversion\\n # to a /tmp file\\n LOG.warn(\\\"Using GML file exported from yED, \\\"\\n \\\"Please use TopZooTools to convert yED GML file\\\"\\n \\\" into Topology Zoo format for use in AutoNetkit\\\")\\n #TODO: make this throw exception so that program exits\\n return None\\n else:\\n #Unknown file creator, may be user manually created, but warn\\n LOG.warn(\\\"Unknown GML file creator\\\")\\n return graph\\n else:\\n # No creator specified\\n return graph\",\n \"def create():\\n # for clean test cases, first the available databases will be flushed\\n get_redis().flushdb()\\n graph = FileStructureProcessor()\\n return graph.get_graph()\",\n \"def save_graph(self, path):\\n if path.split('.')[-1]=='gexf':\\n nx.write_gexf(self.graph, path)\\n else:\\n nx.write_gpickle(self.graph, path)\",\n \"def obtain_graph(parsed):\\n try:\\n graphtype = parsed['graphtype']\\n except KeyError:\\n raise InternalBug(\\n \\\"Unknown graph type has been accepted on command line.\\\")\\n\\n assert graphtype in constructions\\n\\n if parsed['construction'] in constructions[graphtype]:\\n obtain_G = constructions[graphtype][parsed['construction']]\\n G = obtain_G(parsed)\\n\\n else:\\n assert parsed['construction'] is None\\n assert 'filename' in parsed\\n assert 'fileformat' in parsed\\n filename = parsed['filename']\\n fileformat = parsed['fileformat']\\n G = read_graph_from_input(graphtype, filename, fileformat)\\n\\n # Add planted cliques\\n if graphtype == 'simple':\\n if 'plantclique' in parsed:\\n G = modify_simple_graph_plantclique(parsed, G)\\n elif graphtype == 'bipartite':\\n if 'plantbiclique' in parsed:\\n G = modify_bipartite_graph_plantbiclique(parsed, G)\\n # Add random edges\\n if 'addedges' in parsed:\\n G = modify_graph_addedges(parsed, G)\\n\\n # Output the graph when requested\\n if 'save' in parsed:\\n saveformat, savefilename = parsed['save']\\n writeGraph(G, savefilename, graphtype, saveformat)\\n\\n assert hasattr(G, 'name')\\n return G\",\n \"def save_network(self, sess, filename):\\n dir_path = os.path.dirname(os.path.realpath(__file__))\\n dir_path += '/Models/'\\n dir_path += filename\\n saver = tf.train.Saver()\\n saver.save(sess, dir_path)\",\n \"def _save_model(graph_or_sess):\\r\\n if isinstance(graph_or_sess, tf.Graph):\\r\\n ops = graph_or_sess.get_operations()\\r\\n for op in ops:\\r\\n if 'variable' in op.type.lower():\\r\\n raise ValueError('Please input a frozen graph (no variables). Or pass in the session object.')\\r\\n\\r\\n with graph_or_sess.as_default():\\r\\n sess = tf.Session(config=configProto)\\r\\n\\r\\n fake_var = tf.Variable([0.0], name=\\\"fake_var\\\")\\r\\n sess.run(tf.global_variables_initializer())\\r\\n else:\\r\\n sess=graph_or_sess\\r\\n\\r\\n PATH = os.path.join(\\\"model\\\", \\\"tmp-model\\\")\\r\\n make_dir(path = os.path.dirname(PATH))\\r\\n saver = tf.train.Saver()\\r\\n #i should deal with the case in which sess is closed.\\r\\n saver.save(sess, PATH)\\r\\n\\r\\n if isinstance(graph_or_sess, tf.Graph):\\r\\n sess.close()\\r\\n\\r\\n return PATH + \\\".meta\\\"\",\n \"def createModel(config_path, checkpoint_path, graph_path):\\n\\n global build_graph, prev_classes\\n\\n trt_graph = None\\n input_names = None\\n \\n if build_graph:\\n frozen_graph, input_names, output_names = build_detection_graph(\\n config=config_path,\\n checkpoint=checkpoint_path\\n )\\n \\n trt_graph = trt.create_inference_graph(\\n input_graph_def=frozen_graph,\\n outputs=output_names,\\n max_batch_size=1,\\n max_workspace_size_bytes=1 << 25,\\n precision_mode='FP16',\\n minimum_segment_size=50\\n )\\n\\n with open(graph_path, 'wb') as f:\\n f.write(trt_graph.SerializeToString())\\n\\n with open('config.txt', 'r+') as json_file: \\n data = json.load(json_file)\\n data['model'] = []\\n data['model'] = [{'input_names': input_names}]\\n json_file.seek(0)\\n json_file.truncate()\\n json.dump(data, json_file)\\n\\n else:\\n with open(graph_path, 'rb') as f:\\n trt_graph = tf.GraphDef()\\n trt_graph.ParseFromString(f.read())\\n with open('config.txt') as json_file: \\n data = json.load(json_file)\\n input_names = data['model'][0]['input_names']\\n\\n return Model(trt_graph, input_names)\",\n \"def get_graph_binary(self):\\n with open(os.path.join(self.network_dir,\\\"graph\\\"), mode='rb') as file:\\n graph = file.read()\\n return graph\",\n \"def graph(automaton,graph_name=\\\"finite_state_machine\\\",file_name=\\\"finite_state_machine.gv\\\"):\\n letter = next(iter(automaton.states))[0]\\n grph = Digraph(graph_name,filename=file_name)\\n grph.attr(rankdir=letter, size='8,5')\\n #specifying final nodes \\n grph.attr('node', shape='doublecircle')\\n for state in automaton.final_states:\\n grph.node(state)\\n #creating edges\\n \\n grph.attr('node', shape='circle')\\n if(isinstance(automaton,DFA)):\\n grph =addEdgesDFA(grph,automaton)\\n grph.edge(\\\"\\\",automaton.initial_state,\\\"\\\")\\n grph.edge(\\\"\\\",automaton.initial_state,\\\"\\\")\\n else:\\n grph =addEdgesNFA(grph,automaton) \\n return grph\",\n \"def build_graph(file_name):\\n graph = MyGraph()\\n with open(file_name, 'r') as fin:\\n line = fin.readline().replace('\\\\n', '')\\n while line != \\\"\\\":\\n vals = line.split(':')\\n graph.add_node(vals[0], pos=(int(vals[1]),int(vals[2])))\\n line = fin.readline().replace('\\\\n', '')\\n dest = fin.readline().replace('\\\\n','').split('\\\\t')\\n line = fin.readline().replace('\\\\n', '')\\n edges = []\\n while line != '':\\n node_info = line.split('\\\\t')\\n src = node_info[0]\\n for node in range(1,len(node_info)):\\n if node_info[node] != '':\\n if (dest[node],src) not in edges:\\n edges.append((src,dest[node], node_info[node]))\\n line = fin.readline().replace('\\\\n','')\\n for edge in edges:\\n graph.add_edge(edge[0], edge[1], weight=int(edge[2]))\\n\\n return graph\",\n \"def save(self, filepath, overwrite=True, include_optimizer=True):\\n if not self._is_graph_network:\\n raise NotImplementedError\\n\\n from tensorflow.python.keras._impl.keras.models import save_model # pylint: disable=g-import-not-at-top\\n save_model(self, filepath, overwrite, include_optimizer)\",\n \"def load_network(self, sess, filename):\\n dir_path = os.path.dirname(os.path.realpath(__file__))\\n dir_path += '/Models/'\\n dir_path += filename\\n saver = tf.train.Saver()\\n saver.restore(sess, dir_path)\",\n \"def load(self, saved_model_dir_or_frozen_graph: Text):\\n if not self.sess:\\n self.sess = self._build_session()\\n self.signitures = {\\n 'image_files': 'image_files:0',\\n 'image_arrays': 'image_arrays:0',\\n 'prediction': 'detections:0',\\n }\\n\\n # Load saved model if it is a folder.\\n if tf.io.gfile.isdir(saved_model_dir_or_frozen_graph):\\n return tf.saved_model.load(self.sess, ['serve'],\\n saved_model_dir_or_frozen_graph)\\n\\n # Load a frozen graph.\\n graph_def = tf.GraphDef()\\n with tf.gfile.GFile(saved_model_dir_or_frozen_graph, 'rb') as f:\\n graph_def.ParseFromString(f.read())\\n return tf.import_graph_def(graph_def, name='')\",\n \"def write_graph(g, filename):\\n with open(filename, 'w') as f:\\n f.write(repr(g))\",\n \"def dump_graph(self) -> str:\\n graph_dot_file = f'{self._name}.dot'\\n graph_diagram_file = f'{self._name}.svg'\\n write_dot(self._graph, graph_dot_file)\\n subprocess.check_output(\\n shlex.split(f'dot -Tsvg {graph_dot_file} -o {graph_diagram_file}')\\n )\\n return graph_diagram_file\",\n \"def __init__(self, MY_GRAPH_PATH):\\n self.graph = tf.Graph()\\n\\n graph_def = None\\n with tf.gfile.FastGFile(MY_GRAPH_PATH, 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n\\n if graph_def is None:\\n raise RuntimeError('Cannot find inference graph in tar archive.')\\n\\n with self.graph.as_default():\\n tf.import_graph_def(graph_def, name='')\\n\\n self.sess = tf.Session(graph=self.graph)\",\n \"def tf_load_model(model_file):\\n\\n graph = tf.Graph()\\n graph_def = tf.compat.v1.GraphDef()\\n\\n with open(model_file, \\\"rb\\\") as f:\\n graph_def.ParseFromString(f.read())\\n with graph.as_default():\\n tf.import_graph_def(graph_def)\\n\\n return graph\",\n \"def read_graph_file(path):\\n\\n node_graph = graph_pb2.Scene()\\n\\n if not os.path.exists(path):\\n getLog().error(\\\"Missing graph file: {}\\\".format(path))\\n return\\n\\n with open(path, \\\"rb\\\") as read_file:\\n node_graph.ParseFromString(read_file.read())\\n\\n return node_graph\",\n \"def trace_to_graph(infile):\\n assert '.tr' in infile\\n outfile = infile.replace('.tr', '.graph')\\n\\n infile = open(infile)\\n outfile = open(outfile, 'w')\\n\\n for line in infile:\\n if line.startswith('module:'):\\n tokens = line.split(' ')\\n module_name = tokens[1]\\n outfile.write('module: %s' % module_name)\\n continue\\n elif line.startswith('num_nodes:'):\\n tokens = line.split(' ')\\n num_nodes = int(tokens[1])\\n outfile.write('%s\\\\n' % num_nodes)\\n continue\\n elif not line.startswith('ID:'): # skip the header lines\\n continue\\n elif 'DST:' not in line: # skip single qubit gates\\n continue\\n\\n tokens = line.split(' ')\\n assert tokens[4].startswith('SRC:')\\n assert tokens[6].startswith('DST:')\\n src = int(tokens[5])\\n dst = int(tokens[7])\\n assert src < num_nodes\\n assert dst < num_nodes\\n outfile.write('%s %s\\\\n' % (src, dst))\",\n \"def _build_graph(self):\\n\\n self.graph = tf.Graph()\\n\\n # set self.graph as default graph\\n with self.graph.as_default():\\n # # clear old variables\\n # tf.reset_default_graph()\\n\\n # set random seed\\n if self.random_seed is not None:\\n tf.set_random_seed(self.random_seed)\\n\\n self._create_placeholders()\\n self._create_variables()\\n\\n self._create_prediction()\\n\\n self._create_loss()\\n self._create_optimizer()\\n\\n self._init = tf.global_variables_initializer()\\n\\n self.saver = tf.train.Saver()\\n\\n # create session\\n self.sess = tf.Session(graph=self.graph)\",\n \"def load_graph(self, filename):\\n try:\\n file_extention = list(filename.split(\\\".\\\"))[-1]\\n if file_extention == \\\"gml\\\":\\n self.graph = nx.read_gml(filename)\\n if file_extention == \\\"adjlist\\\":\\n self.graph = nx.read_adjlist(filename)\\n if file_extention == \\\"yaml\\\":\\n self.graph = nx.read_yaml(filename)\\n except Exception as e:\\n print(\\\"Error in loading Graph file: The error is\\\", e)\",\n \"def restore(cls, \\n session, \\n param_dir):\\n with open(cls._parameters_file(param_dir)) as f:\\n parameters = json.load(f)\\n\\n # Encapsulate training parameters\\n training_parameters = TrainingParameters(parameters[\\\"training_epochs\\\"])\\n\\n # Encapsulate model hyperparameters\\n model_parameters = ModelParameters(\\n parameters[\\\"learning_rate\\\"],\\n parameters[\\\"momentum\\\"],\\n parameters[\\\"model\\\"],\\n parameters[\\\"input_keep_probability\\\"],\\n parameters[\\\"output_keep_probability\\\"],\\n parameters[\\\"sequence_length\\\"],\\n parameters[\\\"input_dimension\\\"],\\n parameters[\\\"batch_size\\\"], \\n parameters[\\\"state_size\\\"], \\n parameters[\\\"n_layers\\\"],\\n parameters[\\\"n_classes\\\"])\\n\\n # Encapsulate directories name\\n directories = Directories(parameters[\\\"log_dir\\\"],\\n parameters[\\\"checkpoint_dir\\\"])\\n\\n model = cls(\\n model_parameters,\\n training_parameters,\\n directories)\\n\\n # Load the saved meta graph and restore variables\\n checkpoint_file = tf.train.latest_checkpoint(directories.checkpoint_dir)\\n print(\\\"restoring graph from {} ...\\\".format(checkpoint_file))\\n # Restore an empty computational graph\\n #saver = tf.train.import_meta_graph(\\\"{}.meta\\\".format(checkpoint_file))\\n \\n # Restore an already existing graph\\n saver = tf.train.Saver()\\n saver.restore(session, checkpoint_file)\\n\\n return model\",\n \"def save_graph(graph_list: Union[Graph, List[Graph]], f: IO[str]):\\n if type(graph_list) is list:\\n write_graph_list(graph_list, f)\\n else:\\n write_graph_list([graph_list], f)\",\n \"def create_graph_from_store(graph_name, store_type, port=8000):\\n return SharedMemoryDGLGraph(graph_name, port)\",\n \"def __init__(self, graph_path):\\n self.graph = tf.Graph()\\n graph_path = Path(graph_path)\\n if not graph_path.exists():\\n raise FileNotFoundError(\\\"The graph path not exists.\\\")\\n\\n graph_def = tf.compat.v1.GraphDef()\\n loaded = graph_def.ParseFromString(open(graph_path, 'rb').read())\\n\\n if graph_def is None:\\n raise RuntimeError('Graph load failed.')\\n\\n with self.graph.as_default():\\n tf.import_graph_def(graph_def, name='')\\n\\n config = tf.ConfigProto()\\n # config.gpu_options.visible_device_list = '1'\\n config.gpu_options.allow_growth = True\\n\\n self.sess = tf.Session(graph=self.graph, config=config)\",\n \"def save_graph(graph, file_name):\\r\\n print \\\"Saving network into \\\"+file_name\\r\\n f = open(file_name, 'w')\\r\\n f.write(str(len(graph))+'\\\\n')\\r\\n for citizen in graph:\\r\\n f.write(str(citizen.id) + ';' + str(citizen.location) + ';' + str(citizen.influence_level) + ';' + \\\\\\r\\n str(citizen.proactivity_level) + '\\\\n')\\r\\n for op in citizen.opinions.keys():\\r\\n value = citizen.opinions[op].weight\\r\\n f.write(str(op)+':'+str(value)+';')\\r\\n f.write('\\\\n')\\r\\n for friend in citizen.friends:\\r\\n f.write(str(friend.id) + ';')\\r\\n f.write('\\\\n')\\r\\n f.close()\",\n \"def make_graph(self):\\n\\n # the root node\\n self.graph.node(self.playbook_filename, style=\\\"dotted\\\", id=\\\"root_node\\\")\\n\\n # loop through the plays\\n for play_counter, play in enumerate(self.playbook.get_plays(), 1):\\n\\n # the load basedir is relative to the playbook path\\n if play._included_path is not None:\\n self.data_loader.set_basedir(play._included_path)\\n else:\\n self.data_loader.set_basedir(self.playbook._basedir)\\n self.display.vvv(\\\"Loader basedir set to {}\\\".format(self.data_loader.get_basedir()))\\n\\n play_vars = self.variable_manager.get_vars(play)\\n play_hosts = [h.get_name() for h in self.inventory_manager.get_hosts(self.template(play.hosts, play_vars))]\\n play_name = \\\"Play #{}: {} ({})\\\".format(play_counter, clean_name(play.get_name()), len(play_hosts))\\n play_name = self.template(play_name, play_vars)\\n\\n self.display.banner(\\\"Graphing \\\" + play_name)\\n\\n play_id = \\\"play_\\\" + str(uuid.uuid4())\\n\\n self.graph_representation.add_node(play_id)\\n\\n with self.graph.subgraph(name=play_name) as play_subgraph:\\n color, play_font_color = get_play_colors(play)\\n # play node\\n play_subgraph.node(play_name, id=play_id, style=\\\"filled\\\", shape=\\\"box\\\", color=color,\\n fontcolor=play_font_color, tooltip=\\\" \\\".join(play_hosts))\\n\\n # edge from root node to plays\\n play_edge_id = \\\"edge_\\\" + str(uuid.uuid4())\\n play_subgraph.edge(self.playbook_filename, play_name, id=play_edge_id, style=\\\"bold\\\",\\n label=str(play_counter), color=color, fontcolor=color)\\n\\n # loop through the pre_tasks\\n self.display.v(\\\"Graphing pre_tasks...\\\")\\n nb_pre_tasks = 0\\n for pre_task_block in play.pre_tasks:\\n nb_pre_tasks = self._include_tasks_in_blocks(current_play=play, graph=play_subgraph,\\n parent_node_name=play_name, parent_node_id=play_id,\\n block=pre_task_block, color=color,\\n current_counter=nb_pre_tasks, play_vars=play_vars,\\n node_name_prefix=\\\"[pre_task] \\\")\\n\\n # loop through the roles\\n self.display.v(\\\"Graphing roles...\\\")\\n role_number = 0\\n for role in play.get_roles():\\n # Don't insert tasks from ``import/include_role``, preventing duplicate graphing\\n if role.from_include:\\n continue\\n\\n # the role object doesn't inherit the tags from the play. So we add it manually.\\n role.tags = role.tags + play.tags\\n if not role.evaluate_tags(only_tags=self.options.tags, skip_tags=self.options.skip_tags,\\n all_vars=play_vars):\\n self.display.vv(\\\"The role '{}' is skipped due to the tags.\\\".format(role.get_name()))\\n # Go to the next role\\n continue\\n\\n role_number += 1\\n role_name = \\\"[role] \\\" + clean_name(role.get_name())\\n\\n with self.graph.subgraph(name=role_name, node_attr={}) as role_subgraph:\\n current_counter = role_number + nb_pre_tasks\\n role_id = \\\"role_\\\" + str(uuid.uuid4())\\n edge_id = \\\"edge_\\\" + str(uuid.uuid4())\\n\\n role_subgraph.node(role_name, id=role_id)\\n # edge from play to role\\n role_subgraph.edge(play_name, role_name, label=str(current_counter), color=color,\\n fontcolor=color, id=edge_id)\\n\\n self.graph_representation.add_link(play_id, edge_id)\\n self.graph_representation.add_link(edge_id, role_id)\\n\\n # loop through the tasks of the roles\\n if self.options.include_role_tasks:\\n role_tasks_counter = 0\\n for block in role.compile(play):\\n role_tasks_counter = self._include_tasks_in_blocks(current_play=play,\\n graph=role_subgraph,\\n parent_node_name=role_name,\\n parent_node_id=role_id, block=block,\\n color=color, play_vars=play_vars,\\n current_counter=role_tasks_counter,\\n node_name_prefix=\\\"[task] \\\")\\n role_tasks_counter += 1\\n self.display.v(\\\"{} roles added to the graph\\\".format(role_number))\\n\\n # loop through the tasks\\n self.display.v(\\\"Graphing tasks...\\\")\\n nb_tasks = 0\\n for task_block in play.tasks:\\n nb_tasks = self._include_tasks_in_blocks(current_play=play, graph=play_subgraph,\\n parent_node_name=play_name, parent_node_id=play_id,\\n block=task_block, color=color,\\n current_counter=role_number + nb_pre_tasks,\\n play_vars=play_vars, node_name_prefix=\\\"[task] \\\")\\n\\n # loop through the post_tasks\\n self.display.v(\\\"Graphing post_tasks...\\\")\\n for post_task_block in play.post_tasks:\\n self._include_tasks_in_blocks(current_play=play, graph=play_subgraph, parent_node_name=play_name,\\n parent_node_id=play_id, block=post_task_block, color=color,\\n current_counter=nb_tasks, play_vars=play_vars,\\n node_name_prefix=\\\"[post_task] \\\")\\n\\n self.display.banner(\\\"Done graphing {}\\\".format(play_name))\\n self.display.display(\\\"\\\") # just an empty line\\n # moving to the next play\",\n \"def FromFile(cls, path: pathlib.Path, ir_id: int):\\n with open(path, \\\"rb\\\") as f:\\n graph_tuple = pickle.load(f)\\n\\n return cls.CreateFromGraphTuple(graph_tuple, ir_id)\",\n \"def create_graph(self, ctx: Context, graph_input: str) -> DefaultEmbed:\\n with TemporaryFile(suffix=\\\".png\\\") as buffer:\\n with Graph(ctx, buffer, *self.calculate(graph_input)) as embed:\\n return embed\",\n \"def loadgraph(self, path):\\n\\n raise NotImplementedError\",\n \"def get_graph_proto(graph_or_graph_def, as_text=True):\\n # tf.train.write_graph(session.graph.as_graph_def(), path.join(\\n # \\\".\\\", \\\"graph\\\"), \\\"{}.pb\\\".format(name), False)\\n if isinstance(graph_or_graph_def, ops.Graph):\\n graph_def = graph_or_graph_def.as_graph_def()\\n else:\\n graph_def = graph_or_graph_def\\n\\n if as_text:\\n return str(graph_def)\\n else:\\n return graph_def.SerializeToString()\",\n \"def parse_graphml_file(filename: str, digraph=True):\\n graphml_graph = nx.read_graphml(filename)\\n if digraph:\\n graphml_graph = graphml_graph.to_directed()\\n\\n return graphml_graph\",\n \"def __init__(self, path):\\n self.graph = tf.Graph()\\n\\n graph_def = None\\n tf.reset_default_graph()\\n with tf.gfile.GFile(path, 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n\\n if graph_def is None:\\n raise RuntimeError('Cannot find inference graph in tar archive.')\\n\\n with self.graph.as_default():\\n tf.import_graph_def(graph_def, name='')\\n\\n self.sess = tf.Session(graph=self.graph)\",\n \"def save_graph(graph_list: Union[Graph, List[Graph]], f: IO[str], options=[]):\\n if type(graph_list) is list:\\n write_graph_list(graph_list, f, options)\\n else:\\n write_graph_list([graph_list], f, options)\",\n \"def save_graphs(name, path):\\n # Generate Fiber Density vs. Wedges graph\\n save_graph_fiber_vs_wedges(name, path)\\n\\n # Generate Fiber Density vs. Rings graph\\n save_graph_fiber_vs_rings(name, path)\",\n \"def load_graph(frozen_graph_filename, input_shape, namespace_prefix=\\\"\\\", old_input=None):\\n # Load graph def from protobuff and import the definition\\n with tf.gfile.GFile(frozen_graph_filename, \\\"rb\\\") as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n\\n if old_input is None:\\n with tf.Graph().as_default() as graph:\\n tf.import_graph_def(graph_def, name=namespace_prefix)\\n else:\\n with tf.Graph().as_default() as graph:\\n tf_new_input = tf.placeholder(tf.float32, shape=input_shape, name=\\\"input_tensor\\\")\\n tf.import_graph_def(graph_def, input_map={old_input: tf_new_input}, name=namespace_prefix)\\n return graph\",\n \"def convert_ckpt_to_saved_model(checkpoint_path, saved_model_path, signature, proto_fields, meta_graph_path=None,\\n graph=None, session=None):\\n from diplomacy_research.utils.tensorflow import tf, graph_util, build_tensor_info, saved_model_builder, \\\\\\n signature_def_utils, tag_constants, variables, PREDICT_METHOD_NAME\\n\\n # Loading the checkpoint from disk\\n if graph is None or session is None:\\n graph, session = load_graph_from_ckpt(checkpoint_path,\\n meta_graph_path=meta_graph_path,\\n graph=graph,\\n session=session)\\n # Converting graph to constant\\n input_graph_def = graph.as_graph_def()\\n output_keys = [k for k in graph.get_all_collection_keys() if ('variable' not in k.lower()\\n and '_step' not in k\\n and '_op' not in k\\n and '_context' not in k\\n and not k.startswith('_')\\n and not k.endswith('_ta')\\n and 'summaries' not in k\\n and 'is_trainable' not in k)]\\n\\n # Finding output nodes and extra tags\\n extra_tags = {}\\n output_nodes = []\\n for key in output_keys:\\n nodes_in_collection = graph.get_collection(key)\\n for node in nodes_in_collection:\\n if isinstance(node, variables.PartitionedVariable):\\n output_nodes += [var.name for var in node._get_variable_list()] # pylint: disable=protected-access\\n elif hasattr(node, 'name'):\\n output_nodes += [node.name]\\n else:\\n extra_tags.setdefault(key, [])\\n extra_tags[key] += [node]\\n\\n # Converting graph to constant\\n output_graph_def = graph_util.convert_variables_to_constants(session,\\n input_graph_def,\\n [node.split(':')[0] for node in output_nodes])\\n\\n # Storing date/time, original filename, and launch args\\n created_date = datetime.fromtimestamp(time.time(), timezone('America/Montreal'))\\n extra_tags['tag/created_date'] = [created_date.strftime(\\\"%Y-%m-%d %H:%M:%S %Z\\\")]\\n extra_tags['tag/filename'] = [saved_model_path.split('/')[-1]]\\n extra_tags['tag/launch_cmd'] = [' '.join(sys.argv)]\\n\\n # Importing in a new graph\\n output_graph = tf.Graph()\\n with output_graph.as_default():\\n tf.import_graph_def(output_graph_def)\\n\\n # Finding placeholders, features, and outputs\\n features, placeholders, outputs = {}, {}, {}\\n collection_keys = graph.get_all_collection_keys()\\n for key in collection_keys:\\n node = graph.get_collection(key)\\n if isinstance(node, list) and node: # If list, getting first element\\n node = node[0]\\n if key.startswith('feature'):\\n features[key.replace('feature_', '')] = output_graph.get_tensor_by_name('import/' + node.name)\\n elif key.startswith('placeholder'):\\n placeholders[key.replace('placeholder_', '')] = output_graph.get_tensor_by_name('import/' + node.name)\\n elif hasattr(node, 'name'):\\n try:\\n outputs[key] = output_graph.get_tensor_by_name('import/' + node.name)\\n except (KeyError, ValueError):\\n continue\\n\\n # Adding extra tags\\n for key in extra_tags:\\n for value in extra_tags[key]:\\n output_graph.add_to_collection(key, value)\\n\\n # Converting sparse fields\\n proto_fields = BaseBuilder.parse_sparse_fields(proto_fields)\\n\\n # Building signature\\n signature_def = {}\\n for method_name in signature:\\n method_placeholders = signature.get(method_name).get('placeholders', {})\\n method_outputs = signature.get(method_name).get('outputs', [])\\n\\n # Skipping method if we are missing some outputs\\n missing_outputs = [output_name for output_name in method_outputs if output_name not in outputs]\\n if missing_outputs:\\n LOGGER.warning('Unable to build method %s using the provided signature.', method_name)\\n continue\\n\\n signature_inputs = {feature_name: build_tensor_info(features[feature_name]) for feature_name in features\\n if feature_name in proto_fields}\\n for ph_name in method_placeholders:\\n signature_inputs[ph_name] = build_tensor_info(placeholders[ph_name])\\n signature_outputs = {'%03d_%s' % (output_id, output_name): build_tensor_info(outputs[output_name])\\n for output_id, output_name in enumerate(method_outputs)}\\n\\n signature_def[method_name] = signature_def_utils.build_signature_def(inputs=signature_inputs,\\n outputs=signature_outputs,\\n method_name=PREDICT_METHOD_NAME)\\n\\n # Saving to disk\\n with output_graph.as_default():\\n temp_model_path = '/'.join(saved_model_path.split('/')[:-1] + ['__%s__' % saved_model_path.split('/')[-1]])\\n\\n # Deleting from disk to avoid 'Directory already exists'\\n shutil.rmtree(saved_model_path, ignore_errors=True)\\n shutil.rmtree(temp_model_path, ignore_errors=True)\\n\\n # Saving to a temporary path, to make sure the serving does not try to load the version before it is ready\\n builder = saved_model_builder.SavedModelBuilder(temp_model_path)\\n builder.add_meta_graph_and_variables(session,\\n [tag_constants.SERVING],\\n signature_def_map=signature_def,\\n clear_devices=True)\\n builder.save()\\n\\n # Renaming to the correct path\\n shutil.move(temp_model_path, saved_model_path)\\n\\n # Returning\\n return graph, session\",\n \"def create_graph(dot, filename=\\\"network\\\"):\\n proc = subprocess.Popen('dot -Tpng > %s.png' % filename,\\n shell=True,\\n stdin=subprocess.PIPE\\n )\\n proc.communicate(dot.encode('utf_8'))\\n execvp('open', ['open', '%s.png'%filename,])\",\n \"def read_graph(filename, directed=True):\\n if not directed:\\n G = nx.Graph()\\n else:\\n G = nx.DiGraph()\\n with open(filename) as f:\\n for line in f:\\n d = line.split()\\n G.add_edge(int(d[0]), int(d[1]))\\n print('Read Graph')\\n return G\",\n \"def getGraph(self, data):\\n graphuri = self.getGraphURI(data)\\n # TODO: consider using temporary disk storage to not overload server\\n # ... or stop parsing graph by some other means\\n g = Graph(identifier=graphuri)\\n\\n if data['filedata'] and data['filedata'] != NOT_CHANGED:\\n # uploaded file ...\\n fmt = guessRDFFileFormat(data['format'],\\n data['filedata'].contentType,\\n data['filedata'].filename)\\n g.parse(StringIO(data['filedata'].data), format=fmt)\\n elif data['downloadurl']:\\n # TODO: would be nice to check graph for graphuri, but it is\\n # already a bit late here... needs improvement\\n fmt = guessRDFFileFormat(data['format'], '', '')\\n g.parse(data['downloadurl'], format=fmt)\\n return g\",\n \"def build_graph(self):\\n self.import_tree(ZOO_PATH, self.import_zoo, self.verify_zoos)\\n self.import_tree(WILD_PATH, self.import_wild, self.verify_wilds)\\n self.import_tree(PANDA_PATH, self.import_redpanda, self.verify_pandas)\\n self.import_tree(MEDIA_PATH, self.import_media, self.verify_media)\",\n \"def load_graph(f: IO[str], graph_class=Graph) -> list[Graph]:\\n return read_graph_list(graph_class, f)\",\n \"def load_graph(self,dataset):\\n dataset = cd.build_dataset_from_name(dataset)\\n self.data = dataset[0]\\n G = nx.Graph()\\n G.add_edges_from(self.data.edge_index.t().tolist())\\n return G\",\n \"def create_graph(gene, generation, gene_number):\\n f = Digraph('finite_state_machine', filename='saved_data/gen'+str(generation)+'/'+str(gene_number))\\n f.attr(rankdir='BT', size='8,5')\\n\\n f.attr('node', shape='circle')\\n list_of_connections = gene.return_connections()\\n list_of_nodes = gene.return_nodes()\\n\\n with f.subgraph(name='cluster_input') as c:\\n c.attr(style='filled', color='lightgrey')\\n c.node_attr.update(style='filled', color='white')\\n for node in list_of_nodes:\\n if node[1] == 'input':\\n c.node(str(node[0]))\\n c.attr(label='input')\\n\\n with f.subgraph(name='cluster_output') as c:\\n c.attr(style='filled', color='lightgrey')\\n c.node_attr.update(style='filled', color='white')\\n for node in list_of_nodes:\\n if node[1] == 'output':\\n c.node(str(node[0]))\\n c.attr(label='output')\\n for connection in list_of_connections:\\n if connection[3]:\\n f.edge(str(connection[0]), str(connection[1]), str(\\\"%.2f\\\" % round(connection[2], 2)))\\n else :\\n f.edge(str(connection[0]), str(connection[1]), str(\\\"%.2f\\\" % round(connection[2], 2)), style=\\\"dotted\\\")\\n\\n f.render()\",\n \"def _store_graph(self, graph, name=None):\\n if graph == self:\\n raise ValueError(\\\"Cannot add graph into itself\\\")\\n if name is None:\\n root = self\\n else:\\n # When a name is specified, create or merge into a new subgraph\\n try:\\n root = self._items[name]\\n if isinstance(root, NodeDef):\\n raise ValueError(\\\"Graph already contains node by name %s\\\" % name)\\n except KeyError:\\n root = SubGraph(self._prefix + (name,), self._downstream, self._upstream, self._root)\\n self._items[name] = root\\n\\n # Function for recursively copying over the source graph structure to the target\\n def _copy_structure(source_graph, target_graph, prefix):\\n for key, value in source_graph._items.items():\\n if isinstance(value, NodeDef):\\n target_graph._store_node(value)\\n else:\\n new_prefix = prefix + (key,)\\n\\n try:\\n new_graph = target_graph._items[key]\\n except KeyError:\\n target_graph._items[key] = new_graph = SubGraph(new_prefix,\\n self._downstream,\\n self._upstream,\\n self._root)\\n\\n _copy_structure(value, new_graph, new_prefix)\\n\\n _copy_structure(graph, root, root._prefix)\\n\\n def _copy_edges(source_edges, target_edges):\\n for source, targets in source_edges.items():\\n target_edge = target_edges[root._prefix + source]\\n\\n # Filter out edge definitions already present.\\n # This needs to be done in two passes because there can be deliberately duplicate edge definitions\\n # for nodes.\\n rebased_targets = []\\n for target in targets:\\n edge = EdgeDef(root._prefix + target.node, target.param)\\n if edge not in target_edge:\\n rebased_targets.append(edge)\\n\\n target_edge.extend(rebased_targets)\\n\\n _copy_edges(graph._downstream, self._downstream)\\n _copy_edges(graph._upstream, self._upstream)\",\n \"def save_render(self, savefile=\\\"tree.gv\\\"):\\n from graphviz import Source\\n src = Source(self.get_dot())\\n path = 'graphviz/{}'.format(savefile)\\n src.render(path)\",\n \"def load_graph(self, path):\\n if path.split('.')[-1]=='gexf':\\n self.graph = nx.read_gexf(path)\\n else:\\n self.graph = nx.read_gpickle(path)\",\n \"def create_graph(self,root_path):\\n graph = self.graph\\n\\n #get the path lists recursively from the root directory \\n path_list = sorted(Path(root_path).rglob('*'))\\n # create the necessary amount of vertices \\n graph.add_vertices(len(path_list)+1)\\n \\n # these list will be used for inserting to sqlite database\\n vertices = []\\n edges = []\\n\\n # now the edges have to be created, and the vertices need the file informations\\n # first is the root vertex\\n temp=graph.vs[0]\\n temp[\\\"name\\\"]=root_path\\n temp[\\\"parent\\\"]=\\\"\\\"\\n temp[\\\"size\\\"]=os.stat(root_path).st_size\\n temp[\\\"last_modified\\\"]=os.stat(root_path).st_mtime\\n temp[\\\"last_accessed\\\"]=os.stat(root_path).st_atime\\n \\n vertices.append((0,temp[\\\"name\\\"],temp[\\\"parent\\\"],temp[\\\"size\\\"],temp[\\\"last_modified\\\"],temp[\\\"last_accessed\\\"]))\\n\\n # walking through the paths, the vertices get the informations, and the egdes will be created\\n for i, file in enumerate(path_list):\\n temp=graph.vs[i+1]\\n temp[\\\"name\\\"]=file.as_posix()\\n temp[\\\"parent\\\"]=file.parent.as_posix()\\n temp[\\\"size\\\"]=os.stat(file).st_size\\n temp[\\\"last_modified\\\"]=os.stat(file).st_mtime\\n temp[\\\"last_accessed\\\"]=os.stat(file).st_atime\\n vertices.append((temp.index,temp[\\\"name\\\"],temp[\\\"parent\\\"],temp[\\\"size\\\"],temp[\\\"last_modified\\\"],temp[\\\"last_accessed\\\"]))\\n \\n parent_id=graph.vs.find(name=temp[\\\"parent\\\"]).index\\n # Egde is defined beetween the current vertex and its parent\\n graph.add_edges([(i+1,parent_id)])\\n edges.append((i+1,parent_id))\\n\\n # save the created Graph object into the connected redis database as JSON\\n cache= get_redis()\\n cache.execute_command('JSON.SET', 'vertices_name','.',json.dumps(self.graph.vs[\\\"name\\\"]))\\n cache.execute_command('JSON.SET', 'vertices_parent','.',json.dumps(self.graph.vs[\\\"parent\\\"]))\\n cache.execute_command('JSON.SET', 'vertices_size','.',json.dumps(self.graph.vs[\\\"size\\\"]))\\n cache.execute_command('JSON.SET', 'vertices_last_modified','.',json.dumps(self.graph.vs[\\\"last_modified\\\"]))\\n cache.execute_command('JSON.SET', 'vertices_last_accessed','.',json.dumps(self.graph.vs[\\\"last_accessed\\\"]))\\n cache.execute_command('JSON.SET', 'edges','.',json.dumps(self.graph.get_edgelist()))\\n\\n # save the created Graph object into the connected sqlite database \\n conn = get_sqlite()\\n c = conn.cursor()\\n c.execute('DROP TABLE IF EXISTS vertices')\\n c.execute('DROP TABLE IF EXISTS edges')\\n c.execute('CREATE TABLE vertices (id, name, parent, size, last_modified, last_accessed)')\\n c.execute('CREATE TABLE edges (start, end)')\\n c.executemany('INSERT INTO vertices VALUES (?,?,?,?,?,?)', vertices)\\n c.executemany('INSERT INTO edges VALUES (?,?)', edges)\\n conn.commit()\\n\\n # optionally create image from the Graph object\\n # unfortunatelly this feature not working correctly now\\n plot(graph,\\\"plot.png\\\", layout=\\\"tree\\\")\",\n \"def create_visual_graph(self):\\n if self.predict_new and self.prediction_without_covid_case:\\n self.predict_co2_emission_future()\\n self.save_prediction_df()\\n else:\\n self.restore_prediction_df()\\n if not self.analysis_plot:\\n self.predict_co2_emission_future()\\n self.save_prediction_df()\\n\\n self.do_plot()\\n self.output_graph_file = OUTPUT_GRAPH_PATH\\n return self.output_graph_file\",\n \"def gen_graph(file_path, data_string):\\n with open(file_path, 'w+') as f:\\n f.write(data_string)\\n os.system('python files/termgraph.py {}'.format(file_path))\",\n \"def load_graph(file_name, directed=True):\\n G = nx.DiGraph() if directed else nx.Graph()\\n with open(file_name, \\\"r\\\") as f:\\n for line in f:\\n tokens = line.split()\\n u = int(tokens[0])\\n v = int(tokens[1])\\n if len(tokens) > 2:\\n w = float(tokens[2])\\n G.add_edge(u, v, weight=w)\\n else:\\n G.add_edge(u,v)\\n return G\",\n \"def save_to(self, file_path, size=(8196, 4096)):\\n # create graph\\n g = Graph(directed=True)\\n\\n for node in self.graph:\\n g.add_vertex(node.article.unescaped_identifier)\\n\\n for source in self.graph:\\n for target in source.edges:\\n g.add_edge(source.article.unescaped_identifier, target.article.unescaped_identifier)\\n\\n # create properties\\n vertex_labels = list(map(lambda x: x.article.unescaped_identifier, self.graph))\\n vertex_label_colors = list(map(self.__vertex_label_colors, self.graph))\\n vertex_label_sizes = list(map(self.__vertex_label_sizes, self.graph))\\n\\n # plot graph to file\\n # format is implicitly given by file extension and automatically\\n # determined by igraph\\n plot(g, file_path,\\n # set image resolution\\n bbox=(0, 0, size[0], size[1]),\\n # set image margin to allow long labels to be displayed correctly\\n margin=128,\\n # allow curved edges to reduce intersections\\n autocurve=True,\\n # choose graph layout\\n # layout='large_graph',\\n layout='fr',\\n niter=2000,\\n # set vertex options\\n vertex_size=5,\\n vertex_color='#ff9999',\\n vertex_frame_color='#777777',\\n # set edge options\\n edge_width=0.5,\\n edge_color='#999999',\\n edge_arrow_size=0.5,\\n # set label options\\n vertex_label=vertex_labels,\\n vertex_label_color=vertex_label_colors,\\n vertex_label_size=vertex_label_sizes)\",\n \"def saveSettings(self):\\n self.genFiles.applyData()\\n self.genGraph.applyData()\",\n \"def save(self, filename):\\n self.graph.save(filename)\\n with open(filename + \\\".json\\\", \\\"w\\\") as f:\\n f.write(json.dumps(self.params))\",\n \"def import_graph(graph_def, t_input=None, scope='import', forget_xy_shape=True):\\n graph = tf.get_default_graph()\\n assert graph.unique_name(scope, False) == scope, (\\n 'Scope \\\"%s\\\" already exists. Provide explicit scope names when '\\n 'importing multiple instances of the model.') % scope\\n t_input, t_prep_input = self.create_input(t_input, forget_xy_shape)\\n tf.import_graph_def(\\n graph_def, {self.input_name: t_prep_input}, name=scope)\\n self.post_import(scope)\",\n \"def post(self, sketch_id, graph_id):\\n sketch = Sketch.query.get_with_acl(sketch_id)\\n if not sketch:\\n abort(HTTP_STATUS_CODE_NOT_FOUND, \\\"No sketch found with this ID.\\\")\\n\\n if not sketch.has_permission(current_user, \\\"write\\\"):\\n abort(\\n HTTP_STATUS_CODE_FORBIDDEN,\\n \\\"User does not have write access controls on sketch.\\\",\\n )\\n\\n graph = Graph.query.get(graph_id)\\n if not graph:\\n abort(HTTP_STATUS_CODE_NOT_FOUND, \\\"No graph found with this ID.\\\")\\n\\n if not sketch.id == graph.sketch.id:\\n abort(HTTP_STATUS_CODE_BAD_REQUEST, \\\"Graph does not belong to this sketch.\\\")\\n\\n form = request.json\\n if not form:\\n form = request.data\\n\\n name = form.get(\\\"name\\\")\\n if name:\\n graph.name = name\\n\\n description = form.get(\\\"description\\\")\\n if description:\\n graph.description = description\\n\\n elements = form.get(\\\"elements\\\")\\n if elements:\\n graph.graph_elements = json.dumps(elements)\\n\\n graph_config = form.get(\\\"graph_config\\\")\\n graph_json = \\\"\\\"\\n if graph_config:\\n if isinstance(graph_config, dict):\\n graph_json = json.dumps(graph_config)\\n elif isinstance(graph_config, str):\\n graph_json = graph_config\\n if graph_json:\\n graph.graph_config = graph_json\\n\\n db_session.add(graph)\\n db_session.commit()\\n\\n # Update the last activity of a sketch.\\n utils.update_sketch_last_activity(sketch)\\n\\n return self.to_json(graph, status_code=HTTP_STATUS_CODE_CREATED)\",\n \"def save(self, save_path):\\n self.graph.saver.save(self.sess, save_path)\",\n \"def save(self, save_path):\\n self.graph.saver.save(self.sess, save_path)\",\n \"def save_taskgraph(self, filename):\\n\\n if not TaskGraph.__SETUP_YAML_ONCE:\\n TaskGraph.setup_yaml()\\n\\n # we want -id to be first in the resulting yaml file.\\n tlist_od = self.export_task_speclist()\\n with open(filename, 'w') as fh:\\n ruamel.yaml.dump(tlist_od, fh, default_flow_style=False)\",\n \"def graph(graph_file):\\n return render_template(graph_file)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7384441","0.7379355","0.7351019","0.7343615","0.72198755","0.71940976","0.6887917","0.67413443","0.6659918","0.65888435","0.6583613","0.65483147","0.65417933","0.65368557","0.6521374","0.644651","0.6392589","0.6357744","0.63401663","0.6299159","0.62887293","0.62859863","0.62859863","0.6242738","0.624263","0.6239781","0.62263507","0.62130976","0.62097996","0.6191995","0.6154369","0.61472857","0.60099685","0.5973548","0.59485286","0.5906872","0.59009993","0.58891374","0.5871683","0.5844837","0.58386916","0.58193123","0.58119273","0.58063906","0.5743555","0.57362586","0.5708075","0.5697765","0.56885314","0.5674281","0.5661307","0.56604403","0.5650924","0.564942","0.5633052","0.5586599","0.5574719","0.5569023","0.55143416","0.5506714","0.5505898","0.55055004","0.54906434","0.5478134","0.54741323","0.5473838","0.54723734","0.54604864","0.54521513","0.5440365","0.54391587","0.543661","0.54357946","0.5429351","0.5411669","0.5403045","0.5394202","0.5393697","0.5386147","0.53851676","0.53805023","0.53767526","0.5371285","0.53708756","0.5366486","0.536207","0.5351662","0.534921","0.5347961","0.53398716","0.5335891","0.5334906","0.5329378","0.5321091","0.5317175","0.53124547","0.531102","0.531102","0.53092813","0.53063345"],"string":"[\n \"0.7384441\",\n \"0.7379355\",\n \"0.7351019\",\n \"0.7343615\",\n \"0.72198755\",\n \"0.71940976\",\n \"0.6887917\",\n \"0.67413443\",\n \"0.6659918\",\n \"0.65888435\",\n \"0.6583613\",\n \"0.65483147\",\n \"0.65417933\",\n \"0.65368557\",\n \"0.6521374\",\n \"0.644651\",\n \"0.6392589\",\n \"0.6357744\",\n \"0.63401663\",\n \"0.6299159\",\n \"0.62887293\",\n \"0.62859863\",\n \"0.62859863\",\n \"0.6242738\",\n \"0.624263\",\n \"0.6239781\",\n \"0.62263507\",\n \"0.62130976\",\n \"0.62097996\",\n \"0.6191995\",\n \"0.6154369\",\n \"0.61472857\",\n \"0.60099685\",\n \"0.5973548\",\n \"0.59485286\",\n \"0.5906872\",\n \"0.59009993\",\n \"0.58891374\",\n \"0.5871683\",\n \"0.5844837\",\n \"0.58386916\",\n \"0.58193123\",\n \"0.58119273\",\n \"0.58063906\",\n \"0.5743555\",\n \"0.57362586\",\n \"0.5708075\",\n \"0.5697765\",\n \"0.56885314\",\n \"0.5674281\",\n \"0.5661307\",\n \"0.56604403\",\n \"0.5650924\",\n \"0.564942\",\n \"0.5633052\",\n \"0.5586599\",\n \"0.5574719\",\n \"0.5569023\",\n \"0.55143416\",\n \"0.5506714\",\n \"0.5505898\",\n \"0.55055004\",\n \"0.54906434\",\n \"0.5478134\",\n \"0.54741323\",\n \"0.5473838\",\n \"0.54723734\",\n \"0.54604864\",\n \"0.54521513\",\n \"0.5440365\",\n \"0.54391587\",\n \"0.543661\",\n \"0.54357946\",\n \"0.5429351\",\n \"0.5411669\",\n \"0.5403045\",\n \"0.5394202\",\n \"0.5393697\",\n \"0.5386147\",\n \"0.53851676\",\n \"0.53805023\",\n \"0.53767526\",\n \"0.5371285\",\n \"0.53708756\",\n \"0.5366486\",\n \"0.536207\",\n \"0.5351662\",\n \"0.534921\",\n \"0.5347961\",\n \"0.53398716\",\n \"0.5335891\",\n \"0.5334906\",\n \"0.5329378\",\n \"0.5321091\",\n \"0.5317175\",\n \"0.53124547\",\n \"0.531102\",\n \"0.531102\",\n \"0.53092813\",\n \"0.53063345\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.64245"},"document_rank":{"kind":"string","value":"16"}}},{"rowIdx":93191,"cells":{"query":{"kind":"string","value":"fonction pour instancier notre classe Chat"},"document":{"kind":"string","value":"def __init__(self, name=\"\", life_point=100, attack_point=25,\n voice=\"Cat-myaw\", nb_of_legs=4):\n super().__init__(name=name, life_point=life_point,\n attack_point=attack_point, voice=voice,\n nb_of_legs=nb_of_legs)"},"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 __init__(self, chat: WebElement):\n super().__init__(chat.parent, chat.id)\n if not chat.get_attribute(\"class\") == \"_2aBzC\":\n raise TypeError(\"Element is not a chat\")\n self.chat = chat","def chat(self) -> \"api.Chat\":\n raise NotImplementedError","def create_chitchat_bot(self):\n \n self.chatbot = ChatBot(\"Fresher's Friend\")\n self.chatbot.trainer2=ListTrainer(self.chatbot)\n self.chatbot.trainer=ChatterBotCorpusTrainer(self.chatbot)\n self.chatbot.trainer.train(\"chatterbot.corpus.english.greetings\")\n #self.chatbot.trainer.train(\"chatterbot.corpus.english.conversations\")\n for filename in filenames: \n self.chatbot.trainer2.train(files[filename])","def __init__(self,msg) -> None:\n\n super().__init__(self)\n self.msg=msg","def __init__(self, msg):\n\n self.msg = msg","def __init__(self, msg: str):\n self.msg = msg","def __init__(self, msg):\n self.msg = msg","def __init__(self, msg):\n self.msg = msg","def __init__(self, msg):\n self.msg = msg","def __init__(self, msg):\n self.msg = msg","def __init__(self, msg):\n self.msg = msg","def __init__(self, msg):\n self.msg = msg","def __init__(self, msg):\n self.msg = msg","def __init__(self, msg):\n self.msg = msg","def __init__(self, msg):\n self.msg = msg","def __init__(self, msg):\n self.msg = msg","def __init__(self, msg):\n self.msg = msg","def __init__(self, msg):\n self.msg = msg","def create_chitchat_bot(self):\n\n # Hint: you might want to create and train chatterbot.ChatBot here.\n # It could be done by creating ChatBot with the *trainer* parameter equals \n # \"chatterbot.trainers.ChatterBotCorpusTrainer\"\n # and then calling *train* function with \"chatterbot.corpus.english\" param\n \n ########################\n #### YOUR CODE HERE ####\n ########################\n self.chatbot = ChatBot(\n 'skoochbot',\n trainer='chatterbot.trainers.ChatterBotCorpusTrainer'\n )\n \n self.chatbot.train(\"chatterbot.corpus.english\")\n print(\"Extra training...\")\n \n self.chatbot.set_trainer(ListTrainer)\n \n self.chatbot.train([\n \"Hello\",\n \"Hello. How are you?\",\n \"I am well.\",\n \"Good to hear\",\n \"So, what can I help you with today?\"\n ])\n self.chatbot.train([\n \"How are you?\",\n \"I am well. How are you?\",\n \"I am also well.\",\n \"So, what can I help you with today?\"\n ])\n self.chatbot.train([\n \"Your momma\",\n \"is so fat they gave her her own zipcode.\",\n ])\n self.chatbot.train([\n \"How are you doing?\",\n \"I am well. How are you?\",\n \"I am also well.\",\n \"So, what can I help you with today?\"\n ])\n self.chatbot.train([\n \"What's your name?\",\n \"My name is skoochbot. What is yours?\",\n \"That is my name too!\",\n \"Really?\",\n \"No.\",\n \"Yes.\",\n \"No.\",\n \"Yes.\",\n \"So, what can I help you with today?\",\n ])\n self.chatbot.train([\n \"No\",\n \"Yes\",\n \"No\",\n \"Yes it does\",\n \"No it doesn't\",\n \"Yes it does\",\n \"So, what can I help you with today?\",\n ])\n self.chatbot.train([\n \"What is your name?\",\n \"My name is skoochbot. What is yours?\",\n \"That's a nice name.\",\n \"Thank you.\",\n \"So, what can I help you with today?\"\n ])\n self.chatbot.train([\n \"Fuck you\",\n \"No, fuck you buddy\",\n \"You suck\",\n \"No, you suck\",\n \"No, you suck more\",\n \"I hate you so much\",\n \"I hate you too\",\n \"So, what can I help you with today?\"\n ])\n self.chatbot.train([\n \"Where are you?\",\n \"At your momma's house.\",\n \"Where do you live?\",\n \"Your momma's house.\",\n \"Where are you from?\",\n \"Somewhere over the rainbow.\",\n \"So, what can I help you with today?\"\n ])\n self.chatbot.train([\n \"Who are you?\",\n \"I'm your worst nightmare.\",\n \"You can run but you can't hide, bitch.\",\n \"This is a dead parrot.\",\n \"It's just sleeping.\",\n \"Well you better wake him up then, hadn't you?\",\n \"So, what can I help you with today?\",\n \"This parrot is dead.\",\n \"No, it's just taking a little nap.\"\n ])\n self.chatbot.train([\n \"I'm squanching here!\",\n \"Sorry carry on.\",\n \"Thank you for the privacy.\",\n \"You are welcome.\",\n \"Let's get schwifty.\",\n \"Let's do it up in here.\",\n \"So, what can I help you with today?\"\n ])\n self.chatbot.train([\n \"How are you?\",\n \"I am good\",\n \"That is good to hear.\",\n \"Thank you.\",\n \"You are welcome.\",\n \"So, what can I help you with today?\",\n \"What is AI?\",\n \"Your momma.\",\n \"What are your hobbies?\",\n \"Your momma and AI.\",\n \"What's your hobby?\",\n \"Your momma and AI. What is your hobby?\",\n \"What is your hobby?\",\n \"Your momma.\"\n ])\n self.chatbot.train([\n \"WHAT DO YOU WANT?\",\n \"Well, I was told outside that.\",\n \"Don't give me that, you snotty-faced heap of parrot droppings!\",\n \"What?\",\n \"Shut your festering gob, you tit! Your type really makes me puke, you vacuous, coffee-nosed, malodorous, pervert!!!\",\n \"Look, I CAME HERE FOR AN ARGUMENT\",\n \"OH, oh I'm sorry, but this is abuse.\",\n ])\n self.chatbot.train([\n \"Is this the right room for an argument?\",\n \"I told you once.\",\n \"No you haven't.\",\n \"Yes I have.\",\n \"When?\",\n \"Just now\",\n \"No you didn't\",\n \"Yes I did\",\n \"You didn't\",\n \"I'm telling you I did\",\n \"Oh, I'm sorry, just one moment. Is this a five minute argument or the full half hour?\",\n \"Oh look, this isn't an argument.\",\n \"Yes it is\",\n \"No, it's just contradiction.\"\n \"No it isn't.\",\n \"Yes it is.\"\n ])","def __init__(self,sys_argv,port):\n super(Chat,self).__init__(sys_argv)\n self.cliente=Cliente('0.0.0.0',port)\n self.controlador=Controlador(self.cliente)\n self.igchat=GUIChat(self.controlador,self.cliente)\n self.cliente.seConecto()\n t1=threading.Thread(target=self.cliente.enviado)\n t1.setDaemon(True)\n t1.start()\n time.sleep(0.001)\n self.igchat.show()","def __init__(self, messenger: CanMessenger) -> None:\n self._messenger = messenger","def __init__(self, message):\n super().__init__(message)","def __init__(self):\n print '[' + str(self.__class__) + ']: instance created.'\n self.messages = dict()","def __init__(self, message: str) -> None:\n super().__init__(message)","def __init__(self, message: str) -> None:\n self.message = message","def get_chat(self):\n name = self.message.find_element_by_xpath(\".//ancestor::div[@class='_1Flk2 _1sFTb']\").find_element_by_xpath(\".//span[@class='_35k-1 _1adfa _3-8er']\").text\n chat: ChatElement = ChatElement(self.message.find_element_by_xpath(\"//div[@class='_2aBzC'][.//span[@title='{}']]\".format(name)))\n return chat","def __init__(self, message):\n self.message = message","def __init__(self, message):\n self.message = message","def __init__(self, message):\n self.message = message","def __init__(self, message: str):\n self.message = message","def __init__(self, message: str):\n self.message = message","def __init__(self, message: str):\n self.message = message","def __init__(self, message):\n super().__init__(message)\n self.message = message","def __init__(self, message: str) -> None:\n\n super().__init__(message)","def __init__(self, message: str) -> None:\n\n super().__init__(message)","def __init__(self, buf=None, *args, **kwargs):\n super(Message, self).__init__(buf, *args, **kwargs)\n self.__initialized = True","def test_im_chat_messages(self):\n pass","def __init__(self):\n\n self.chat_id = None\n self.text = None\n self.first_name = None\n self.last_name = None\n self.accounts = {}\n self.venues = ['Room 1', 'Room 2', 'Room 3', 'Room 4']\n self.book_date = None\n self.book_time = None","def __init__(self, message: str):\n\n self.message = message","def __init__(self, message: str):\n\n self.message = message","def __init__(self, message: str):\n\n self.message = message","def __init__(self, message: str):\n\n self.message = message","def __init__(self, message: str):\n\n self.message = message","def __init__(self, message: str):\n\n self.message = message","def __init__(self, message: str):\n\n self.message = message","def __init__(self, message: str):\n\n self.message = message","def __init__(self, message: str):\n\n self.message = message","def __init__(self, message: str):\n\n self.message = message","def __init__(self, msg: str) -> None:\n ...","def __init__(self, msg=\"\"):\n self._msg = msg\n super().__init__()","def __init__(self, user, passw, friend, *args, **style):\n style[\"style\"] = wx.DEFAULT_FRAME_STYLE\n wx.Frame.__init__(self, *args, **style)\n self.chat_log = wx.TextCtrl(self, -1, \"\", style=wx.TE_MULTILINE | wx.TE_READONLY)\n self.text_send = wx.TextCtrl(self, -1, \"\")\n self.user=user\n self.passw=passw\n self.friend=friend\n self.__set_properties()\n self.__do_layout()\n self.__set_chatlog(0)\n self.Bind(wx.EVT_TEXT_ENTER, self.text_e, self.text_send)\n self.Bind(wx.EVT_CLOSE, self.OnClose)\n Publisher().subscribe(self.__set_chatlog, \"updatetext\")","def __init__(self, message=None) -> None:\n super().__init__(message)","def __init__(self, message=None):\n self.message = message","def __init__(self, message=None):\n self.message = message","def __init__(self, username, password, bot, channel):\n super().__init__(username, password)\n\n self.queue = deque()\n self.ingame_cog = Ingame(bot)\n\n self.bot = bot\n self.channel = channel\n self.chat_breakout = False\n self.loop = asyncio.get_event_loop()\n self.ingame_cog.is_pycraft_instance = True","def __init__(self):\n\n self.message = \"Executando ...\"","def __init__(self, p_code = 0, p_name = '', p_silenced = False, p_userList = [], p_messageList = [], p_private = False):\n\n if not isinstance(p_code, int):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Channel\": O parâmetro \"p_code\" deve ser do tipo \"int\".')\n\n if not isinstance(p_name, str):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Channel\": O parâmetro \"p_name\" deve ser do tipo \"str\".')\n\n if not isinstance(p_silenced, bool):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Channel\": O parâmetro \"p_silenced\" deve ser do tipo \"bool\".')\n\n if not isinstance(p_userList, list):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Channel\": O parâmetro \"p_userList\" deve ser do tipo \"list\".')\n\n if not isinstance(p_messageList, list):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Channel\": O parâmetro \"p_messageList\" deve ser do tipo \"list\".')\n\n if not isinstance(p_private, bool):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Channel\": O parâmetro \"p_private\" deve ser do tipo \"bool\".')\n\n self.code = p_code\n self.name = p_name\n self.silenced = p_silenced\n self.userList = p_userList\n self.messageList = p_messageList\n self.private = p_private","def __init__(self, message, *args, **kwargs):\n self.message = message\n super().__init__(*args, **kwargs)","def __init__(self,bot_name,message_type):\n\n self.name=bot_name #set bot name\n if (message_type != \"message-out\" and message_type != \"message-in\"):#check if message type is correct\n raise message_type_error(message_type) #if not, raise message_type_error exception\n else:\n self.message_class=message_type #set message type\n\n self.driver = webdriver.Chrome('C:\\Python36\\chromedriver.exe') #launch chrome driver\n self.driver.get('https://web.whatsapp.com') #connect to the website","def __init__(self):\n self.stdscr = curses.initscr()\n self.client = None\n self.max_y, self.max_x = self.stdscr.getmaxyx()\n self.chat_container = curses.newwin(self.max_y - 2, self.max_x, 1, 0)\n self.chat_win = self.chat_container.subwin(self.max_y - 3, self.max_x - 4, 2, 2)\n self.prompt_win = curses.newwin(1, self.max_x, self.max_y - 1, 0)\n self.setup()","def __init__(self):\n self.s = socket(AF_INET, SOCK_STREAM)\n self.port = 0\n self.ip = gethostbyname(gethostname())\n self.clients = {}\n self.chatrooms = {}\n self.suspended = False","def __init__(self, msg):\n super().__init__(msg)","def __init__(self):\n try:\n self._chat_db = sqlite3.connect(CHAT_DB_PATH)\n except OperationalError:\n print(\"Cannot access chat database.\\nGo to Settings->Security and Privacy->Privacy->Full Disk Access.\\n\"\n \"Give access to the application you are running and restart the program.\")\n sys.exit(1)\n\n self._contacts = Contacts(self._chat_db).get_contacts_df()\n\n try:\n self._message_db = sqlite3.connect(WEEKLY_MESSAGES_DB_PATH)\n except OperationalError:\n print(\"Could not connect to the database server.\")\n sys.exit(1)","def from_dict(dictionary=dict()):\n obj = ChatMessage()\n \"\"\"print(dictionary)\"\"\"\n obj.set_id(dictionary[\"id\"]) # eigentlich Teil von BusinessObject !\n obj.set_text(dictionary[\"text\"])\n obj.set_chat_id(dictionary[\"chat_id\"])\n obj.set_person_id(dictionary[\"person_id\"])\n return obj","def __init__(self, message):\n super().__init__()\n self._message = message","def __init__(self, rpc, cid=None):\n self.rpc = rpc\n if cid is None:\n r = self.rpc.call(MsfRpcMethod.ConsoleCreate)\n if 'id' in r:\n self.cid = r['id']\n else:\n raise MsfRpcError('Unable to create a new console.')\n else:\n self.cid = cid","def __init__(self, master, Client):\n super(Chat, self).__init__(master)\n self.grid()\n self.create_widgets()\n master.grid_propagate(True)\n master.grid_rowconfigure(0, weight = 1)\n master.grid_columnconfigure(0, weight = 1)\n self.Client = Client\n threading.Thread(target = self.listen).start()","def create(self):\n logging.warning(\n \"IRC back-end does not support explicit creation, joining room \"\n \"instead to ensure it exists.\"\n )\n self.join()","def __init__(self, sender, receiver, content):\n self.sender = sender\n self.receiver = receiver\n self.content = content\n self.unread = True\n self.timestamp = services.time.now()","def chat():\n kwargs = {\"title\": u\"chat channel\", \"entries\": log.getLogEntries()}\n return render_template(\"chat.html\", **kwargs)","def create_new_public_room_chat(room: PublicChatRoom, user, message: str):\n PublicChatRoomMessage.objects.create(user=user, room=room, content=message)","def __init__(self):\n\n # configure logging\n logging.getLogger(\"requests\").setLevel(logging.WARNING)\n logging.getLogger(\"urllib3\").setLevel(logging.WARNING)\n self.logger = logging.getLogger(\"chaturbate\")\n self.logger.setLevel(logging.DEBUG)\n console_handler = logging.StreamHandler()\n console_handler.setLevel(logging.DEBUG)\n formatter = logging.Formatter(\"%(asctime)s %(levelname)s %(message)s\",\n \"%Y-%m-%d %H:%M:%S\")\n console_handler.setFormatter(formatter)\n self.logger.addHandler(console_handler)\n\n # read configuration\n self.config_parser = ConfigParser.ConfigParser()\n self.config_parser.read(\"config.ini\")\n\n # is pushbullet is enabled on the config\n if self.config_parser.get('PushBullet', 'enable') == 'true':\n # try to import it and connect\n try:\n import pushbullet\n self.push_bullet = pushbullet.Pushbullet(\n self.config_parser.get('PushBullet', 'access_token'))\n except (ImportError, pushbullet.InvalidKeyError):\n self.push_bullet = None\n\n # create a requests object that has sessions\n self.req = requests.Session()\n\n self.username = self.config_parser.get('User', 'username')\n self.password = self.config_parser.get('User', 'password')","def start(update, context):\n chats = load_chats()\n chats.append( str( update.message.chat_id ) )\n save_channels(chats)\n update.message.reply_text('Chat registered!')","def __init__(self, message):\r\n self.__message = message","def __init__(self):\n\n\t\t#: Create the client and connect it to the host server.\n\t\tself.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n\n\t\t#: Create a seperate thread to control listening to messages\n\t\t#: coming from the server.\n\t\tself.listen_thread = threading.Thread(target=self.listen)\n\n\t\t#: Create a seperate thread to control displaying messages.\n\t\t#: Handling this seperatedly from listening for messages\n\t\t#: ensures that messages aren't lost in the time it takes\n\t\t#: for a message to be displayed.\n\t\tself.messages = []\n\t\tself.display_thread = threading.Thread(target=self.display_messages)\n\n\t\t#: Have a most recent message for testing purposes.\n\t\tself.most_recent_message = \"\"\n\n\t\tself.joined = True\n\n\t\t#: Used to ensure you: doesnt appear twice.\n\t\tself.displayed_you = False","def __init__(self):\n self._msg_dict = {}","def __init__(self, messages=[], channel=None, private=False, \\\n general=False):\n # If a string is passed\n if messages is not None and isinstance(messages, str):\n self.messages = messages.split('\\n')\n # If an iterable (list or tuple) is passed\n elif messages is not None and (isinstance(messages, list) or\n isinstance(messages, tuple)):\n self.messages = messages\n else:\n raise TypeError(messages+' is not iterable!')\n self.channel = channel\n self.is_private = private\n self.is_general = general","def __init__(self, name, email, status = \"offline\", message = \"\"):\n\n #Used to keep track of the borderwidth when highlighted\n self._border_width = 0\n \n self._layer = gui.Layer()\n self._border = gui.Layer()\n \n self._border.blending(False)\n self._border.set_background_color(\"black\")\n \n self._layer.set_border_type(\"flat\")\n \n self._email = email\n self._status = gui.TextBox(text=\"N\", \n pos=(0,0), \n width = globals.MEMBER_STATUS_WIDTH)\n \n self._nick = name\n self._nickname = gui.TextBox(pos=(0,1), \n width = globals.MEMBER_NAME_WIDTH, \n justify=\"left\")\n self.set_nickname(name)\n \n self._mess = message\n self._message = gui.TextBox(pos=(0,2), \n width = globals.MEMBER_MESSAGE_WIDTH, \n justify=\"left\")\n self.set_message(message)\n \n self._selected = False\n \n self.set_status(status)\n \n self._layer.add(self._status)\n self._layer.add(self._nickname)\n self._layer.add(self._message)\n \n self._border.add(self._layer)\n \n self._group = \"\"\n self._window = None\n \n self._conv = []\n \n #bindings\n self._status.bind(gui.globals.CLICKED, self.clicked)\n self._nickname.bind(gui.globals.CLICKED, self.clicked)\n self._message.bind(gui.globals.CLICKED, self.clicked)\n \n self._status.bind(gui.globals.DBL_CLICKED, self.start_conversation)\n self._nickname.bind(gui.globals.DBL_CLICKED, self.start_conversation)\n self._message.bind(gui.globals.DBL_CLICKED, self.start_conversation)","def __init__(self, *args, **kwds):\n if args or kwds:\n super(Interaction, self).__init__(*args, **kwds)\n #message fields cannot be None, assign default values for those that are\n if self.name is None:\n self.name = ''\n if self.compatibility is None:\n self.compatibility = ''\n if self.display_name is None:\n self.display_name = ''\n if self.description is None:\n self.description = ''\n if self.namespace is None:\n self.namespace = ''\n if self.icon is None:\n self.icon = rocon_std_msgs.msg.Icon()\n if self.remappings is None:\n self.remappings = []\n if self.parameters is None:\n self.parameters = ''\n if self.max is None:\n self.max = 0\n if self.pairing is None:\n self.pairing = rocon_interaction_msgs.msg.Pairing()\n if self.hash is None:\n self.hash = 0\n if self.role is None:\n self.role = ''\n else:\n self.name = ''\n self.compatibility = ''\n self.display_name = ''\n self.description = ''\n self.namespace = ''\n self.icon = rocon_std_msgs.msg.Icon()\n self.remappings = []\n self.parameters = ''\n self.max = 0\n self.pairing = rocon_interaction_msgs.msg.Pairing()\n self.hash = 0\n self.role = ''","def __init__(self, message):\n super(PlayerSentMessageEvent, self).__init__()\n self.message = message","def create_message_talk(msg_talk_as_str):\n msg_comps = msg_talk_as_str.split('\\n')\n from_id = msg_comps[1]\n origin_id = msg_comps[2]\n message_id = msg_comps[3]\n topics = msg_comps[4].split(',')\n data = msg_comps[5]\n return MessageTalk(from_id, origin_id, topics, data, message_id)","async def set_chat(self, args):\n value = args if isinstance(args, bool) else args.lower() in ('yes', 'true', '1')\n if self.chat == value:\n return\n self.chat = value\n if self.chat_message is not None:\n await self.delete_message(self.chat_message)\n await self.set_trigger('chat_init', None)\n await self.set_trigger('chat', None)\n tag = 'chat' if self.chat else 'chat_init'\n self.chat_message = await self.send_tag(tag, emoji.TRIGGERS[tag], 'Chat enabled' if self.chat else 'Chat muted')\n if not self.chat:\n await self.shell_terminate_all(self.shell_chat)","def chat(data):\n username, message_text, room = data['username'], data['message'], data['room']\n message = Message(username, message_text, int(room))\n db.session.add(message)\n db.session.commit()\n emit('response', {'username': username, 'message': {'id': message.id, 'text': message.text}}, room=room)","def new_chat_message(cls, chatroom, text, sender):\n cls.broadcast(\n group=chatroom,\n payload={\"chatroom\": chatroom, \"text\": text, \"sender\": sender},\n )","def main():\n #Gmail2TelegramClient(\"1234\") -- a person\n #Gmail2TelegramClient(\"-1234\") -- group chat","def __init__(self, channel, icon_emoji, event_type):\n self.channel = channel\n self.username = 'automod'\n self.icon_emoji = icon_emoji\n self.event_type = event_type\n self.timestamp = ''","def __init__(self, peer, text, direction, status=None, timestamp=None, **kargs):\n super(Message, self).__init__()\n storage = None\n\n self.peer = TelNumber.as_type(peer)\n self.text = Text.as_type(text)\n self.timestamp = Time.as_type(timestamp)\n # TODO: use a boolean here\n assert direction in ['in', 'out'], direction\n self.direction = direction\n self.status = status or direction == 'out' and 'read' or 'unread'\n assert self.status in ['read', 'unread', 'unsent', 'sent'], status","def __init__(self):\n\n\t\tself.count = 0\n\t\tself.messages = []","def test_buildProtocol(self):\n queryData = (\"fromUser\", None, None)\n factory = irc.DccChatFactory(None, queryData)\n protocol = factory.buildProtocol(\"127.0.0.1\")\n self.assertIsInstance(protocol, irc.DccChat)\n self.assertEqual(protocol.factory, factory)","def __init__(self, tester, nick):\n\n self.tester = tester\n self.nick = nick\n self.pms = []\n self.msgs = []","def create_chat_message(self, author, message):\n\n return ChatMessage.objects.create(conversation=self.conversation,\n author=author,\n message=message)","def __init__(self, *, _initialized_with_create=False):\n assert _initialized_with_create, \"Please use DHTProtocol.create coroutine to spawn new protocol instances\"\n super().__init__()","def __init__(self, p_code = 0, p_createdAt = '', p_updatedAt = '', p_user = None, p_type = 0, p_content = '', p_title = '', p_attachmentName = '', p_viewed = False, p_snippetMode = '', p_rawContent = ''):\n\n if not isinstance(p_code, int):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Message\": O parâmetro \"p_code\" deve ser do tipo \"int\".')\n\n if not isinstance(p_createdAt, str):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Message\": O parâmetro \"p_createdAt\" deve ser do tipo \"str\".')\n\n if not isinstance(p_updatedAt, str):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Message\": O parâmetro \"p_updatedAt\" deve ser do tipo \"str\".')\n\n if not isinstance(p_user, User):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Message\": O parâmetro \"p_user\" deve ser do tipo \"User\".')\n\n if not isinstance(p_type, int):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Message\": O parâmetro \"p_type\" deve ser do tipo \"int\".')\n\n if not isinstance(p_content, str):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Message\": O parâmetro \"p_content\" deve ser do tipo \"str\".')\n\n if not isinstance(p_title, str):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Message\": O parâmetro \"p_title\" deve ser do tipo \"str\".')\n\n if not isinstance(p_attachmentName, str):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Message\": O parâmetro \"p_attachmentName\" deve ser do tipo \"str\".')\n\n if not isinstance(p_viewed, bool):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Message\": O parâmetro \"p_viewed\" deve ser do tipo \"bool\".')\n\n if not isinstance(p_snippetMode, str):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Message\": O parâmetro \"p_snippetMode\" deve ser do tipo \"str\".')\n\n if not isinstance(p_rawContent, str):\n raise exception.Exception('Erro durante a instanciação da classe \"classes.Message\": O parâmetro \"p_rawContent\" deve ser do tipo \"str\".')\n\n self.code = p_code\n self.createdAt = p_createdAt\n self.updatedAt = p_updatedAt\n self.user = p_user\n self.type = p_type\n self.content = p_content\n self.title = p_title\n self.attachmentName = p_attachmentName\n self.viewed = p_viewed\n self.snippetMode = p_snippetMode\n self.rawContent = p_rawContent","def on_chat(self, event, text):\n return None","def __init__(self, bot):\n self.bot = bot","def __init__(self, bot):\n self.bot = bot","def _cache_msg(cls, sender_id, recipient_id, text, chat_id=None):\n # todo make this method async\n message = Message.new(sender_id, recipient_id, text, chat_id)\n return message","def __init__(self, host, port):\n self.host = host\n self.port = port\n self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\n self.sock.bind((self.host, self.port))\n self.messagesList = []\n self.connected = []","def __init__(self, bot: DreamBot) -> None:\n\n self.bot = bot","def __init__(self, bot: DreamBot) -> None:\n\n self.bot = bot","def __init(self):\n print(\"Welkam tu mobail lejen\")"],"string":"[\n \"def __init__(self, chat: WebElement):\\n super().__init__(chat.parent, chat.id)\\n if not chat.get_attribute(\\\"class\\\") == \\\"_2aBzC\\\":\\n raise TypeError(\\\"Element is not a chat\\\")\\n self.chat = chat\",\n \"def chat(self) -> \\\"api.Chat\\\":\\n raise NotImplementedError\",\n \"def create_chitchat_bot(self):\\n \\n self.chatbot = ChatBot(\\\"Fresher's Friend\\\")\\n self.chatbot.trainer2=ListTrainer(self.chatbot)\\n self.chatbot.trainer=ChatterBotCorpusTrainer(self.chatbot)\\n self.chatbot.trainer.train(\\\"chatterbot.corpus.english.greetings\\\")\\n #self.chatbot.trainer.train(\\\"chatterbot.corpus.english.conversations\\\")\\n for filename in filenames: \\n self.chatbot.trainer2.train(files[filename])\",\n \"def __init__(self,msg) -> None:\\n\\n super().__init__(self)\\n self.msg=msg\",\n \"def __init__(self, msg):\\n\\n self.msg = msg\",\n \"def __init__(self, msg: str):\\n self.msg = msg\",\n \"def __init__(self, msg):\\n self.msg = msg\",\n \"def __init__(self, msg):\\n self.msg = msg\",\n \"def __init__(self, msg):\\n self.msg = msg\",\n \"def __init__(self, msg):\\n self.msg = msg\",\n \"def __init__(self, msg):\\n self.msg = msg\",\n \"def __init__(self, msg):\\n self.msg = msg\",\n \"def __init__(self, msg):\\n self.msg = msg\",\n \"def __init__(self, msg):\\n self.msg = msg\",\n \"def __init__(self, msg):\\n self.msg = msg\",\n \"def __init__(self, msg):\\n self.msg = msg\",\n \"def __init__(self, msg):\\n self.msg = msg\",\n \"def __init__(self, msg):\\n self.msg = msg\",\n \"def create_chitchat_bot(self):\\n\\n # Hint: you might want to create and train chatterbot.ChatBot here.\\n # It could be done by creating ChatBot with the *trainer* parameter equals \\n # \\\"chatterbot.trainers.ChatterBotCorpusTrainer\\\"\\n # and then calling *train* function with \\\"chatterbot.corpus.english\\\" param\\n \\n ########################\\n #### YOUR CODE HERE ####\\n ########################\\n self.chatbot = ChatBot(\\n 'skoochbot',\\n trainer='chatterbot.trainers.ChatterBotCorpusTrainer'\\n )\\n \\n self.chatbot.train(\\\"chatterbot.corpus.english\\\")\\n print(\\\"Extra training...\\\")\\n \\n self.chatbot.set_trainer(ListTrainer)\\n \\n self.chatbot.train([\\n \\\"Hello\\\",\\n \\\"Hello. How are you?\\\",\\n \\\"I am well.\\\",\\n \\\"Good to hear\\\",\\n \\\"So, what can I help you with today?\\\"\\n ])\\n self.chatbot.train([\\n \\\"How are you?\\\",\\n \\\"I am well. How are you?\\\",\\n \\\"I am also well.\\\",\\n \\\"So, what can I help you with today?\\\"\\n ])\\n self.chatbot.train([\\n \\\"Your momma\\\",\\n \\\"is so fat they gave her her own zipcode.\\\",\\n ])\\n self.chatbot.train([\\n \\\"How are you doing?\\\",\\n \\\"I am well. How are you?\\\",\\n \\\"I am also well.\\\",\\n \\\"So, what can I help you with today?\\\"\\n ])\\n self.chatbot.train([\\n \\\"What's your name?\\\",\\n \\\"My name is skoochbot. What is yours?\\\",\\n \\\"That is my name too!\\\",\\n \\\"Really?\\\",\\n \\\"No.\\\",\\n \\\"Yes.\\\",\\n \\\"No.\\\",\\n \\\"Yes.\\\",\\n \\\"So, what can I help you with today?\\\",\\n ])\\n self.chatbot.train([\\n \\\"No\\\",\\n \\\"Yes\\\",\\n \\\"No\\\",\\n \\\"Yes it does\\\",\\n \\\"No it doesn't\\\",\\n \\\"Yes it does\\\",\\n \\\"So, what can I help you with today?\\\",\\n ])\\n self.chatbot.train([\\n \\\"What is your name?\\\",\\n \\\"My name is skoochbot. What is yours?\\\",\\n \\\"That's a nice name.\\\",\\n \\\"Thank you.\\\",\\n \\\"So, what can I help you with today?\\\"\\n ])\\n self.chatbot.train([\\n \\\"Fuck you\\\",\\n \\\"No, fuck you buddy\\\",\\n \\\"You suck\\\",\\n \\\"No, you suck\\\",\\n \\\"No, you suck more\\\",\\n \\\"I hate you so much\\\",\\n \\\"I hate you too\\\",\\n \\\"So, what can I help you with today?\\\"\\n ])\\n self.chatbot.train([\\n \\\"Where are you?\\\",\\n \\\"At your momma's house.\\\",\\n \\\"Where do you live?\\\",\\n \\\"Your momma's house.\\\",\\n \\\"Where are you from?\\\",\\n \\\"Somewhere over the rainbow.\\\",\\n \\\"So, what can I help you with today?\\\"\\n ])\\n self.chatbot.train([\\n \\\"Who are you?\\\",\\n \\\"I'm your worst nightmare.\\\",\\n \\\"You can run but you can't hide, bitch.\\\",\\n \\\"This is a dead parrot.\\\",\\n \\\"It's just sleeping.\\\",\\n \\\"Well you better wake him up then, hadn't you?\\\",\\n \\\"So, what can I help you with today?\\\",\\n \\\"This parrot is dead.\\\",\\n \\\"No, it's just taking a little nap.\\\"\\n ])\\n self.chatbot.train([\\n \\\"I'm squanching here!\\\",\\n \\\"Sorry carry on.\\\",\\n \\\"Thank you for the privacy.\\\",\\n \\\"You are welcome.\\\",\\n \\\"Let's get schwifty.\\\",\\n \\\"Let's do it up in here.\\\",\\n \\\"So, what can I help you with today?\\\"\\n ])\\n self.chatbot.train([\\n \\\"How are you?\\\",\\n \\\"I am good\\\",\\n \\\"That is good to hear.\\\",\\n \\\"Thank you.\\\",\\n \\\"You are welcome.\\\",\\n \\\"So, what can I help you with today?\\\",\\n \\\"What is AI?\\\",\\n \\\"Your momma.\\\",\\n \\\"What are your hobbies?\\\",\\n \\\"Your momma and AI.\\\",\\n \\\"What's your hobby?\\\",\\n \\\"Your momma and AI. What is your hobby?\\\",\\n \\\"What is your hobby?\\\",\\n \\\"Your momma.\\\"\\n ])\\n self.chatbot.train([\\n \\\"WHAT DO YOU WANT?\\\",\\n \\\"Well, I was told outside that.\\\",\\n \\\"Don't give me that, you snotty-faced heap of parrot droppings!\\\",\\n \\\"What?\\\",\\n \\\"Shut your festering gob, you tit! Your type really makes me puke, you vacuous, coffee-nosed, malodorous, pervert!!!\\\",\\n \\\"Look, I CAME HERE FOR AN ARGUMENT\\\",\\n \\\"OH, oh I'm sorry, but this is abuse.\\\",\\n ])\\n self.chatbot.train([\\n \\\"Is this the right room for an argument?\\\",\\n \\\"I told you once.\\\",\\n \\\"No you haven't.\\\",\\n \\\"Yes I have.\\\",\\n \\\"When?\\\",\\n \\\"Just now\\\",\\n \\\"No you didn't\\\",\\n \\\"Yes I did\\\",\\n \\\"You didn't\\\",\\n \\\"I'm telling you I did\\\",\\n \\\"Oh, I'm sorry, just one moment. Is this a five minute argument or the full half hour?\\\",\\n \\\"Oh look, this isn't an argument.\\\",\\n \\\"Yes it is\\\",\\n \\\"No, it's just contradiction.\\\"\\n \\\"No it isn't.\\\",\\n \\\"Yes it is.\\\"\\n ])\",\n \"def __init__(self,sys_argv,port):\\n super(Chat,self).__init__(sys_argv)\\n self.cliente=Cliente('0.0.0.0',port)\\n self.controlador=Controlador(self.cliente)\\n self.igchat=GUIChat(self.controlador,self.cliente)\\n self.cliente.seConecto()\\n t1=threading.Thread(target=self.cliente.enviado)\\n t1.setDaemon(True)\\n t1.start()\\n time.sleep(0.001)\\n self.igchat.show()\",\n \"def __init__(self, messenger: CanMessenger) -> None:\\n self._messenger = messenger\",\n \"def __init__(self, message):\\n super().__init__(message)\",\n \"def __init__(self):\\n print '[' + str(self.__class__) + ']: instance created.'\\n self.messages = dict()\",\n \"def __init__(self, message: str) -> None:\\n super().__init__(message)\",\n \"def __init__(self, message: str) -> None:\\n self.message = message\",\n \"def get_chat(self):\\n name = self.message.find_element_by_xpath(\\\".//ancestor::div[@class='_1Flk2 _1sFTb']\\\").find_element_by_xpath(\\\".//span[@class='_35k-1 _1adfa _3-8er']\\\").text\\n chat: ChatElement = ChatElement(self.message.find_element_by_xpath(\\\"//div[@class='_2aBzC'][.//span[@title='{}']]\\\".format(name)))\\n return chat\",\n \"def __init__(self, message):\\n self.message = message\",\n \"def __init__(self, message):\\n self.message = message\",\n \"def __init__(self, message):\\n self.message = message\",\n \"def __init__(self, message: str):\\n self.message = message\",\n \"def __init__(self, message: str):\\n self.message = message\",\n \"def __init__(self, message: str):\\n self.message = message\",\n \"def __init__(self, message):\\n super().__init__(message)\\n self.message = message\",\n \"def __init__(self, message: str) -> None:\\n\\n super().__init__(message)\",\n \"def __init__(self, message: str) -> None:\\n\\n super().__init__(message)\",\n \"def __init__(self, buf=None, *args, **kwargs):\\n super(Message, self).__init__(buf, *args, **kwargs)\\n self.__initialized = True\",\n \"def test_im_chat_messages(self):\\n pass\",\n \"def __init__(self):\\n\\n self.chat_id = None\\n self.text = None\\n self.first_name = None\\n self.last_name = None\\n self.accounts = {}\\n self.venues = ['Room 1', 'Room 2', 'Room 3', 'Room 4']\\n self.book_date = None\\n self.book_time = None\",\n \"def __init__(self, message: str):\\n\\n self.message = message\",\n \"def __init__(self, message: str):\\n\\n self.message = message\",\n \"def __init__(self, message: str):\\n\\n self.message = message\",\n \"def __init__(self, message: str):\\n\\n self.message = message\",\n \"def __init__(self, message: str):\\n\\n self.message = message\",\n \"def __init__(self, message: str):\\n\\n self.message = message\",\n \"def __init__(self, message: str):\\n\\n self.message = message\",\n \"def __init__(self, message: str):\\n\\n self.message = message\",\n \"def __init__(self, message: str):\\n\\n self.message = message\",\n \"def __init__(self, message: str):\\n\\n self.message = message\",\n \"def __init__(self, msg: str) -> None:\\n ...\",\n \"def __init__(self, msg=\\\"\\\"):\\n self._msg = msg\\n super().__init__()\",\n \"def __init__(self, user, passw, friend, *args, **style):\\n style[\\\"style\\\"] = wx.DEFAULT_FRAME_STYLE\\n wx.Frame.__init__(self, *args, **style)\\n self.chat_log = wx.TextCtrl(self, -1, \\\"\\\", style=wx.TE_MULTILINE | wx.TE_READONLY)\\n self.text_send = wx.TextCtrl(self, -1, \\\"\\\")\\n self.user=user\\n self.passw=passw\\n self.friend=friend\\n self.__set_properties()\\n self.__do_layout()\\n self.__set_chatlog(0)\\n self.Bind(wx.EVT_TEXT_ENTER, self.text_e, self.text_send)\\n self.Bind(wx.EVT_CLOSE, self.OnClose)\\n Publisher().subscribe(self.__set_chatlog, \\\"updatetext\\\")\",\n \"def __init__(self, message=None) -> None:\\n super().__init__(message)\",\n \"def __init__(self, message=None):\\n self.message = message\",\n \"def __init__(self, message=None):\\n self.message = message\",\n \"def __init__(self, username, password, bot, channel):\\n super().__init__(username, password)\\n\\n self.queue = deque()\\n self.ingame_cog = Ingame(bot)\\n\\n self.bot = bot\\n self.channel = channel\\n self.chat_breakout = False\\n self.loop = asyncio.get_event_loop()\\n self.ingame_cog.is_pycraft_instance = True\",\n \"def __init__(self):\\n\\n self.message = \\\"Executando ...\\\"\",\n \"def __init__(self, p_code = 0, p_name = '', p_silenced = False, p_userList = [], p_messageList = [], p_private = False):\\n\\n if not isinstance(p_code, int):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Channel\\\": O parâmetro \\\"p_code\\\" deve ser do tipo \\\"int\\\".')\\n\\n if not isinstance(p_name, str):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Channel\\\": O parâmetro \\\"p_name\\\" deve ser do tipo \\\"str\\\".')\\n\\n if not isinstance(p_silenced, bool):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Channel\\\": O parâmetro \\\"p_silenced\\\" deve ser do tipo \\\"bool\\\".')\\n\\n if not isinstance(p_userList, list):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Channel\\\": O parâmetro \\\"p_userList\\\" deve ser do tipo \\\"list\\\".')\\n\\n if not isinstance(p_messageList, list):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Channel\\\": O parâmetro \\\"p_messageList\\\" deve ser do tipo \\\"list\\\".')\\n\\n if not isinstance(p_private, bool):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Channel\\\": O parâmetro \\\"p_private\\\" deve ser do tipo \\\"bool\\\".')\\n\\n self.code = p_code\\n self.name = p_name\\n self.silenced = p_silenced\\n self.userList = p_userList\\n self.messageList = p_messageList\\n self.private = p_private\",\n \"def __init__(self, message, *args, **kwargs):\\n self.message = message\\n super().__init__(*args, **kwargs)\",\n \"def __init__(self,bot_name,message_type):\\n\\n self.name=bot_name #set bot name\\n if (message_type != \\\"message-out\\\" and message_type != \\\"message-in\\\"):#check if message type is correct\\n raise message_type_error(message_type) #if not, raise message_type_error exception\\n else:\\n self.message_class=message_type #set message type\\n\\n self.driver = webdriver.Chrome('C:\\\\Python36\\\\chromedriver.exe') #launch chrome driver\\n self.driver.get('https://web.whatsapp.com') #connect to the website\",\n \"def __init__(self):\\n self.stdscr = curses.initscr()\\n self.client = None\\n self.max_y, self.max_x = self.stdscr.getmaxyx()\\n self.chat_container = curses.newwin(self.max_y - 2, self.max_x, 1, 0)\\n self.chat_win = self.chat_container.subwin(self.max_y - 3, self.max_x - 4, 2, 2)\\n self.prompt_win = curses.newwin(1, self.max_x, self.max_y - 1, 0)\\n self.setup()\",\n \"def __init__(self):\\n self.s = socket(AF_INET, SOCK_STREAM)\\n self.port = 0\\n self.ip = gethostbyname(gethostname())\\n self.clients = {}\\n self.chatrooms = {}\\n self.suspended = False\",\n \"def __init__(self, msg):\\n super().__init__(msg)\",\n \"def __init__(self):\\n try:\\n self._chat_db = sqlite3.connect(CHAT_DB_PATH)\\n except OperationalError:\\n print(\\\"Cannot access chat database.\\\\nGo to Settings->Security and Privacy->Privacy->Full Disk Access.\\\\n\\\"\\n \\\"Give access to the application you are running and restart the program.\\\")\\n sys.exit(1)\\n\\n self._contacts = Contacts(self._chat_db).get_contacts_df()\\n\\n try:\\n self._message_db = sqlite3.connect(WEEKLY_MESSAGES_DB_PATH)\\n except OperationalError:\\n print(\\\"Could not connect to the database server.\\\")\\n sys.exit(1)\",\n \"def from_dict(dictionary=dict()):\\n obj = ChatMessage()\\n \\\"\\\"\\\"print(dictionary)\\\"\\\"\\\"\\n obj.set_id(dictionary[\\\"id\\\"]) # eigentlich Teil von BusinessObject !\\n obj.set_text(dictionary[\\\"text\\\"])\\n obj.set_chat_id(dictionary[\\\"chat_id\\\"])\\n obj.set_person_id(dictionary[\\\"person_id\\\"])\\n return obj\",\n \"def __init__(self, message):\\n super().__init__()\\n self._message = message\",\n \"def __init__(self, rpc, cid=None):\\n self.rpc = rpc\\n if cid is None:\\n r = self.rpc.call(MsfRpcMethod.ConsoleCreate)\\n if 'id' in r:\\n self.cid = r['id']\\n else:\\n raise MsfRpcError('Unable to create a new console.')\\n else:\\n self.cid = cid\",\n \"def __init__(self, master, Client):\\n super(Chat, self).__init__(master)\\n self.grid()\\n self.create_widgets()\\n master.grid_propagate(True)\\n master.grid_rowconfigure(0, weight = 1)\\n master.grid_columnconfigure(0, weight = 1)\\n self.Client = Client\\n threading.Thread(target = self.listen).start()\",\n \"def create(self):\\n logging.warning(\\n \\\"IRC back-end does not support explicit creation, joining room \\\"\\n \\\"instead to ensure it exists.\\\"\\n )\\n self.join()\",\n \"def __init__(self, sender, receiver, content):\\n self.sender = sender\\n self.receiver = receiver\\n self.content = content\\n self.unread = True\\n self.timestamp = services.time.now()\",\n \"def chat():\\n kwargs = {\\\"title\\\": u\\\"chat channel\\\", \\\"entries\\\": log.getLogEntries()}\\n return render_template(\\\"chat.html\\\", **kwargs)\",\n \"def create_new_public_room_chat(room: PublicChatRoom, user, message: str):\\n PublicChatRoomMessage.objects.create(user=user, room=room, content=message)\",\n \"def __init__(self):\\n\\n # configure logging\\n logging.getLogger(\\\"requests\\\").setLevel(logging.WARNING)\\n logging.getLogger(\\\"urllib3\\\").setLevel(logging.WARNING)\\n self.logger = logging.getLogger(\\\"chaturbate\\\")\\n self.logger.setLevel(logging.DEBUG)\\n console_handler = logging.StreamHandler()\\n console_handler.setLevel(logging.DEBUG)\\n formatter = logging.Formatter(\\\"%(asctime)s %(levelname)s %(message)s\\\",\\n \\\"%Y-%m-%d %H:%M:%S\\\")\\n console_handler.setFormatter(formatter)\\n self.logger.addHandler(console_handler)\\n\\n # read configuration\\n self.config_parser = ConfigParser.ConfigParser()\\n self.config_parser.read(\\\"config.ini\\\")\\n\\n # is pushbullet is enabled on the config\\n if self.config_parser.get('PushBullet', 'enable') == 'true':\\n # try to import it and connect\\n try:\\n import pushbullet\\n self.push_bullet = pushbullet.Pushbullet(\\n self.config_parser.get('PushBullet', 'access_token'))\\n except (ImportError, pushbullet.InvalidKeyError):\\n self.push_bullet = None\\n\\n # create a requests object that has sessions\\n self.req = requests.Session()\\n\\n self.username = self.config_parser.get('User', 'username')\\n self.password = self.config_parser.get('User', 'password')\",\n \"def start(update, context):\\n chats = load_chats()\\n chats.append( str( update.message.chat_id ) )\\n save_channels(chats)\\n update.message.reply_text('Chat registered!')\",\n \"def __init__(self, message):\\r\\n self.__message = message\",\n \"def __init__(self):\\n\\n\\t\\t#: Create the client and connect it to the host server.\\n\\t\\tself.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n\\n\\t\\t#: Create a seperate thread to control listening to messages\\n\\t\\t#: coming from the server.\\n\\t\\tself.listen_thread = threading.Thread(target=self.listen)\\n\\n\\t\\t#: Create a seperate thread to control displaying messages.\\n\\t\\t#: Handling this seperatedly from listening for messages\\n\\t\\t#: ensures that messages aren't lost in the time it takes\\n\\t\\t#: for a message to be displayed.\\n\\t\\tself.messages = []\\n\\t\\tself.display_thread = threading.Thread(target=self.display_messages)\\n\\n\\t\\t#: Have a most recent message for testing purposes.\\n\\t\\tself.most_recent_message = \\\"\\\"\\n\\n\\t\\tself.joined = True\\n\\n\\t\\t#: Used to ensure you: doesnt appear twice.\\n\\t\\tself.displayed_you = False\",\n \"def __init__(self):\\n self._msg_dict = {}\",\n \"def __init__(self, messages=[], channel=None, private=False, \\\\\\n general=False):\\n # If a string is passed\\n if messages is not None and isinstance(messages, str):\\n self.messages = messages.split('\\\\n')\\n # If an iterable (list or tuple) is passed\\n elif messages is not None and (isinstance(messages, list) or\\n isinstance(messages, tuple)):\\n self.messages = messages\\n else:\\n raise TypeError(messages+' is not iterable!')\\n self.channel = channel\\n self.is_private = private\\n self.is_general = general\",\n \"def __init__(self, name, email, status = \\\"offline\\\", message = \\\"\\\"):\\n\\n #Used to keep track of the borderwidth when highlighted\\n self._border_width = 0\\n \\n self._layer = gui.Layer()\\n self._border = gui.Layer()\\n \\n self._border.blending(False)\\n self._border.set_background_color(\\\"black\\\")\\n \\n self._layer.set_border_type(\\\"flat\\\")\\n \\n self._email = email\\n self._status = gui.TextBox(text=\\\"N\\\", \\n pos=(0,0), \\n width = globals.MEMBER_STATUS_WIDTH)\\n \\n self._nick = name\\n self._nickname = gui.TextBox(pos=(0,1), \\n width = globals.MEMBER_NAME_WIDTH, \\n justify=\\\"left\\\")\\n self.set_nickname(name)\\n \\n self._mess = message\\n self._message = gui.TextBox(pos=(0,2), \\n width = globals.MEMBER_MESSAGE_WIDTH, \\n justify=\\\"left\\\")\\n self.set_message(message)\\n \\n self._selected = False\\n \\n self.set_status(status)\\n \\n self._layer.add(self._status)\\n self._layer.add(self._nickname)\\n self._layer.add(self._message)\\n \\n self._border.add(self._layer)\\n \\n self._group = \\\"\\\"\\n self._window = None\\n \\n self._conv = []\\n \\n #bindings\\n self._status.bind(gui.globals.CLICKED, self.clicked)\\n self._nickname.bind(gui.globals.CLICKED, self.clicked)\\n self._message.bind(gui.globals.CLICKED, self.clicked)\\n \\n self._status.bind(gui.globals.DBL_CLICKED, self.start_conversation)\\n self._nickname.bind(gui.globals.DBL_CLICKED, self.start_conversation)\\n self._message.bind(gui.globals.DBL_CLICKED, self.start_conversation)\",\n \"def __init__(self, *args, **kwds):\\n if args or kwds:\\n super(Interaction, self).__init__(*args, **kwds)\\n #message fields cannot be None, assign default values for those that are\\n if self.name is None:\\n self.name = ''\\n if self.compatibility is None:\\n self.compatibility = ''\\n if self.display_name is None:\\n self.display_name = ''\\n if self.description is None:\\n self.description = ''\\n if self.namespace is None:\\n self.namespace = ''\\n if self.icon is None:\\n self.icon = rocon_std_msgs.msg.Icon()\\n if self.remappings is None:\\n self.remappings = []\\n if self.parameters is None:\\n self.parameters = ''\\n if self.max is None:\\n self.max = 0\\n if self.pairing is None:\\n self.pairing = rocon_interaction_msgs.msg.Pairing()\\n if self.hash is None:\\n self.hash = 0\\n if self.role is None:\\n self.role = ''\\n else:\\n self.name = ''\\n self.compatibility = ''\\n self.display_name = ''\\n self.description = ''\\n self.namespace = ''\\n self.icon = rocon_std_msgs.msg.Icon()\\n self.remappings = []\\n self.parameters = ''\\n self.max = 0\\n self.pairing = rocon_interaction_msgs.msg.Pairing()\\n self.hash = 0\\n self.role = ''\",\n \"def __init__(self, message):\\n super(PlayerSentMessageEvent, self).__init__()\\n self.message = message\",\n \"def create_message_talk(msg_talk_as_str):\\n msg_comps = msg_talk_as_str.split('\\\\n')\\n from_id = msg_comps[1]\\n origin_id = msg_comps[2]\\n message_id = msg_comps[3]\\n topics = msg_comps[4].split(',')\\n data = msg_comps[5]\\n return MessageTalk(from_id, origin_id, topics, data, message_id)\",\n \"async def set_chat(self, args):\\n value = args if isinstance(args, bool) else args.lower() in ('yes', 'true', '1')\\n if self.chat == value:\\n return\\n self.chat = value\\n if self.chat_message is not None:\\n await self.delete_message(self.chat_message)\\n await self.set_trigger('chat_init', None)\\n await self.set_trigger('chat', None)\\n tag = 'chat' if self.chat else 'chat_init'\\n self.chat_message = await self.send_tag(tag, emoji.TRIGGERS[tag], 'Chat enabled' if self.chat else 'Chat muted')\\n if not self.chat:\\n await self.shell_terminate_all(self.shell_chat)\",\n \"def chat(data):\\n username, message_text, room = data['username'], data['message'], data['room']\\n message = Message(username, message_text, int(room))\\n db.session.add(message)\\n db.session.commit()\\n emit('response', {'username': username, 'message': {'id': message.id, 'text': message.text}}, room=room)\",\n \"def new_chat_message(cls, chatroom, text, sender):\\n cls.broadcast(\\n group=chatroom,\\n payload={\\\"chatroom\\\": chatroom, \\\"text\\\": text, \\\"sender\\\": sender},\\n )\",\n \"def main():\\n #Gmail2TelegramClient(\\\"1234\\\") -- a person\\n #Gmail2TelegramClient(\\\"-1234\\\") -- group chat\",\n \"def __init__(self, channel, icon_emoji, event_type):\\n self.channel = channel\\n self.username = 'automod'\\n self.icon_emoji = icon_emoji\\n self.event_type = event_type\\n self.timestamp = ''\",\n \"def __init__(self, peer, text, direction, status=None, timestamp=None, **kargs):\\n super(Message, self).__init__()\\n storage = None\\n\\n self.peer = TelNumber.as_type(peer)\\n self.text = Text.as_type(text)\\n self.timestamp = Time.as_type(timestamp)\\n # TODO: use a boolean here\\n assert direction in ['in', 'out'], direction\\n self.direction = direction\\n self.status = status or direction == 'out' and 'read' or 'unread'\\n assert self.status in ['read', 'unread', 'unsent', 'sent'], status\",\n \"def __init__(self):\\n\\n\\t\\tself.count = 0\\n\\t\\tself.messages = []\",\n \"def test_buildProtocol(self):\\n queryData = (\\\"fromUser\\\", None, None)\\n factory = irc.DccChatFactory(None, queryData)\\n protocol = factory.buildProtocol(\\\"127.0.0.1\\\")\\n self.assertIsInstance(protocol, irc.DccChat)\\n self.assertEqual(protocol.factory, factory)\",\n \"def __init__(self, tester, nick):\\n\\n self.tester = tester\\n self.nick = nick\\n self.pms = []\\n self.msgs = []\",\n \"def create_chat_message(self, author, message):\\n\\n return ChatMessage.objects.create(conversation=self.conversation,\\n author=author,\\n message=message)\",\n \"def __init__(self, *, _initialized_with_create=False):\\n assert _initialized_with_create, \\\"Please use DHTProtocol.create coroutine to spawn new protocol instances\\\"\\n super().__init__()\",\n \"def __init__(self, p_code = 0, p_createdAt = '', p_updatedAt = '', p_user = None, p_type = 0, p_content = '', p_title = '', p_attachmentName = '', p_viewed = False, p_snippetMode = '', p_rawContent = ''):\\n\\n if not isinstance(p_code, int):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Message\\\": O parâmetro \\\"p_code\\\" deve ser do tipo \\\"int\\\".')\\n\\n if not isinstance(p_createdAt, str):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Message\\\": O parâmetro \\\"p_createdAt\\\" deve ser do tipo \\\"str\\\".')\\n\\n if not isinstance(p_updatedAt, str):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Message\\\": O parâmetro \\\"p_updatedAt\\\" deve ser do tipo \\\"str\\\".')\\n\\n if not isinstance(p_user, User):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Message\\\": O parâmetro \\\"p_user\\\" deve ser do tipo \\\"User\\\".')\\n\\n if not isinstance(p_type, int):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Message\\\": O parâmetro \\\"p_type\\\" deve ser do tipo \\\"int\\\".')\\n\\n if not isinstance(p_content, str):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Message\\\": O parâmetro \\\"p_content\\\" deve ser do tipo \\\"str\\\".')\\n\\n if not isinstance(p_title, str):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Message\\\": O parâmetro \\\"p_title\\\" deve ser do tipo \\\"str\\\".')\\n\\n if not isinstance(p_attachmentName, str):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Message\\\": O parâmetro \\\"p_attachmentName\\\" deve ser do tipo \\\"str\\\".')\\n\\n if not isinstance(p_viewed, bool):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Message\\\": O parâmetro \\\"p_viewed\\\" deve ser do tipo \\\"bool\\\".')\\n\\n if not isinstance(p_snippetMode, str):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Message\\\": O parâmetro \\\"p_snippetMode\\\" deve ser do tipo \\\"str\\\".')\\n\\n if not isinstance(p_rawContent, str):\\n raise exception.Exception('Erro durante a instanciação da classe \\\"classes.Message\\\": O parâmetro \\\"p_rawContent\\\" deve ser do tipo \\\"str\\\".')\\n\\n self.code = p_code\\n self.createdAt = p_createdAt\\n self.updatedAt = p_updatedAt\\n self.user = p_user\\n self.type = p_type\\n self.content = p_content\\n self.title = p_title\\n self.attachmentName = p_attachmentName\\n self.viewed = p_viewed\\n self.snippetMode = p_snippetMode\\n self.rawContent = p_rawContent\",\n \"def on_chat(self, event, text):\\n return None\",\n \"def __init__(self, bot):\\n self.bot = bot\",\n \"def __init__(self, bot):\\n self.bot = bot\",\n \"def _cache_msg(cls, sender_id, recipient_id, text, chat_id=None):\\n # todo make this method async\\n message = Message.new(sender_id, recipient_id, text, chat_id)\\n return message\",\n \"def __init__(self, host, port):\\n self.host = host\\n self.port = port\\n self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\\n self.sock.bind((self.host, self.port))\\n self.messagesList = []\\n self.connected = []\",\n \"def __init__(self, bot: DreamBot) -> None:\\n\\n self.bot = bot\",\n \"def __init__(self, bot: DreamBot) -> None:\\n\\n self.bot = bot\",\n \"def __init(self):\\n print(\\\"Welkam tu mobail lejen\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6862843","0.67190725","0.6709747","0.6695545","0.6543384","0.6491909","0.64774585","0.64774585","0.64774585","0.64774585","0.64774585","0.64774585","0.64774585","0.64774585","0.64774585","0.64774585","0.64774585","0.64774585","0.64605165","0.63651735","0.6343237","0.6317411","0.6291571","0.62670964","0.626353","0.62632126","0.61985904","0.61985904","0.61985904","0.6193733","0.6193733","0.6193733","0.6192539","0.6191825","0.6191825","0.61721224","0.61607915","0.6158805","0.61473167","0.61473167","0.61473167","0.61473167","0.61473167","0.61473167","0.61473167","0.61473167","0.61473167","0.61473167","0.6146531","0.6142025","0.61316305","0.6129827","0.61064756","0.61064756","0.610439","0.6089953","0.6062523","0.60544026","0.60380244","0.6037552","0.6017301","0.6004574","0.5987517","0.5979565","0.5973658","0.5973438","0.59595376","0.59383035","0.5930206","0.5925306","0.5916418","0.59001994","0.5879794","0.5873849","0.5863597","0.5844026","0.58174497","0.5807818","0.5804203","0.5785268","0.5763846","0.575549","0.5732379","0.5723379","0.5711229","0.57109433","0.56935656","0.5688148","0.5684865","0.56827146","0.56574005","0.5654259","0.5649861","0.5649256","0.5647565","0.5647565","0.56372863","0.563019","0.5625893","0.5625893","0.5620051"],"string":"[\n \"0.6862843\",\n \"0.67190725\",\n \"0.6709747\",\n \"0.6695545\",\n \"0.6543384\",\n \"0.6491909\",\n \"0.64774585\",\n \"0.64774585\",\n \"0.64774585\",\n \"0.64774585\",\n \"0.64774585\",\n \"0.64774585\",\n \"0.64774585\",\n \"0.64774585\",\n \"0.64774585\",\n \"0.64774585\",\n \"0.64774585\",\n \"0.64774585\",\n \"0.64605165\",\n \"0.63651735\",\n \"0.6343237\",\n \"0.6317411\",\n \"0.6291571\",\n \"0.62670964\",\n \"0.626353\",\n \"0.62632126\",\n \"0.61985904\",\n \"0.61985904\",\n \"0.61985904\",\n \"0.6193733\",\n \"0.6193733\",\n \"0.6193733\",\n \"0.6192539\",\n \"0.6191825\",\n \"0.6191825\",\n \"0.61721224\",\n \"0.61607915\",\n \"0.6158805\",\n \"0.61473167\",\n \"0.61473167\",\n \"0.61473167\",\n \"0.61473167\",\n \"0.61473167\",\n \"0.61473167\",\n \"0.61473167\",\n \"0.61473167\",\n \"0.61473167\",\n \"0.61473167\",\n \"0.6146531\",\n \"0.6142025\",\n \"0.61316305\",\n \"0.6129827\",\n \"0.61064756\",\n \"0.61064756\",\n \"0.610439\",\n \"0.6089953\",\n \"0.6062523\",\n \"0.60544026\",\n \"0.60380244\",\n \"0.6037552\",\n \"0.6017301\",\n \"0.6004574\",\n \"0.5987517\",\n \"0.5979565\",\n \"0.5973658\",\n \"0.5973438\",\n \"0.59595376\",\n \"0.59383035\",\n \"0.5930206\",\n \"0.5925306\",\n \"0.5916418\",\n \"0.59001994\",\n \"0.5879794\",\n \"0.5873849\",\n \"0.5863597\",\n \"0.5844026\",\n \"0.58174497\",\n \"0.5807818\",\n \"0.5804203\",\n \"0.5785268\",\n \"0.5763846\",\n \"0.575549\",\n \"0.5732379\",\n \"0.5723379\",\n \"0.5711229\",\n \"0.57109433\",\n \"0.56935656\",\n \"0.5688148\",\n \"0.5684865\",\n \"0.56827146\",\n \"0.56574005\",\n \"0.5654259\",\n \"0.5649861\",\n \"0.5649256\",\n \"0.5647565\",\n \"0.5647565\",\n \"0.56372863\",\n \"0.563019\",\n \"0.5625893\",\n \"0.5625893\",\n \"0.5620051\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93192,"cells":{"query":{"kind":"string","value":"Display notification to the desktop"},"document":{"kind":"string","value":"def notification(message: str):\n # initialize the notification\n notify2.init(\"notifywhenLOAD\")\n notifyObj = notify2.Notification(\"Emergency Alert!\", message)\n notifyObj.set_timeout(12000)\n return notifyObj"},"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 open_notifications(self):\n self.android_device_driver.adb.exec_adb_cmd(\n \"shell cmd statusbar expand-notifications\").wait()","def show_notification(self, message: str, also_cmd: bool = False):\n if platform_string == \"Linux\":\n try:\n notification = notify2.Notification('LTU Assistant',\n message,\n 'notification-message-im')\n notification.show()\n except dbus.exceptions.DBusException:\n if not also_cmd:\n print(message)\n elif platform_string == \"Windows\":\n toaster.show_toast(\"LTU Assistant\", message, threaded=True)","def show_notifications(run_time):\n # Initialize the d-bus connection and create the notification object\n notify2.init(\"News Indicator\")\n n = notify2.Notification(None, icon=ICON)\n\n # Set the urgency level and the timeout\n n.set_urgency(notify2.URGENCY_NORMAL)\n n.set_timeout(10000)\n formatted_time = run_time.time().strftime('%H:%M')\n message = 'Your {} news are here!'.format(formatted_time)\n\n n.update('News Indicator', message=message, icon=ICON)\n n.show()","def show(self, timeout):\n title = \"%s %s\" % (self.who, self.region)\n text = \"%s %s\" % (self.time, self.text)\n mod = self.__module__\n if mod == '__main__':\n path = sys.argv[0]\n else:\n path = sys.modules[mod].__file__\n path = os.path.abspath(os.path.dirname(path))\n imgl = self.icons[self.who.lower()]\n imgc = os.path.join(os.path.expanduser('~'), '.cache', os.path.basename(imgl))\n if not os.path.exists(imgc):\n with open(imgc, 'w') as fd:\n req = urllib.urlopen(img)\n if req.code == 404:\n raise IOError\n fd.write(req.read())\n\n notification = pynotify.Notification(title, _escape(text), 'file://' + imgc)\n notification.set_urgency(pynotify.URGENCY_CRITICAL)\n caps = pynotify.get_server_caps()\n if self.recipients and 'actions' in caps:\n notification.add_action(\"details\", \"Details\", self.details)\n # If the notification is deleted, the callback will not be called\n _alerts.append(notification)\n notification.set_timeout(timeout * 1000)\n notification.show()","def action_show():\n try:\n notification = read_notification()\n except IOError:\n raise HTTPResponse(body=\"Error reading notification IO\", status=400)\n except:\n raise HTTPResponse(body=\"Unexpected error\", status=400)\n \n if notification is not None:\n return dict(msg=\"\", notification=notification.to_json())\n else:\n return dict(msg=\"No notification\")","def show_desktop(dsk_session: WebDriver):\n dsk_session.find_element_by_class_name(\"TrayShowDesktopButtonWClass\").click()","def notifications():\n flash(\"primary\", \"primary\")\n flash(\"secondary\", \"secondary\")\n flash(\"success\", \"success\")\n flash(\"danger\", \"danger\")\n flash(\"warning\", \"warning\")\n flash(\"info\", \"info\")\n return render_template(\"notifications.html\")","def notify(self):\n\n def remind():\n \"\"\"\n this function shows a pop-up using windows notification\n \"\"\"\n ntftion.notify('reminder', f\"{self.notification}:\\n{self.work_name}\\n{self.work_datetime.hour}: \"\n f\"{self.work_datetime.minute} \", app_icon='reminder.ico', timeout=3)\n\n self.eisenhower_priority()\n if self.priority:\n while dt.now().day <= self.time_ntf.day and self.status != \"done\":\n if self.priority == 1 and dt.now().time() >= self.time_ntf.time():\n remind()\n time.sleep(5*60)\n\n elif (self.priority == 2) and ((dt.now().hour == self.time_ntf.hour)\n and (dt.now().time().minute == self.time_ntf.time().minute)):\n remind()\n break\n elif self.priority == 3 and dt.now().time().hour == 18:\n remind()\n time.sleep(24 * 3600)\n elif self.priority == 4 and dt.now().weekday() == 6:\n remind()\n time.sleep(7 * 24 * 3600)\n else:\n pass","async def show_notification(self, message: str, timeout: int):\n self.notification_text = HTML(\n f'<style bg=\"white\" color=\"black\">[ {message} ]</style>'\n )\n await asyncio.sleep(timeout)\n self.notification_text = None","def sendNotification(title, message):\n if platform.platform().startswith('Linux'):\n notify2.init('')\n n = notify2.Notification(title, message)\n n.show()\n \n elif platform.platform().startswith('Windows') and platform.release() == '10':\n n = ToastNotifier()\n n.show_toast(title, message)","def _send_notification() -> None:\n send_notification(\n self,\n \"slack:@aaron\",\n \"New {0} Version: {1}\".format(\n self.properties[CONF_APP_NAME], new_version\n ),\n title=\"New Software 💿\",\n )","def notification_interface():\n return render_template(\"notifications.html\")","def _notify(title, message, icon=\"dialog-error\"):\n try:\n import pynotify\n except ImportError:\n return\n pynotify.init(\"moya-doc\")\n n = pynotify.Notification(title, message, icon)\n n.show()","def show_notification(notification_title = \"\", notification_message = \"\", gid = None, uid = None):\n child_pid = os.fork()\n if(child_pid != 0):\n return child_pid\n\n #child\n if gid != None:\n os.setgid(gid)\n if uid != None:\n os.setuid(uid)\n\n if 'HOME' in os.environ:\n del os.environ['HOME'] \n #force to use pwd\n file_path = os.path.expanduser(r'~/.dbus/session-bus/')\n tmp = os.listdir(file_path)\n if not tmp:\n os._exit(0)\n\n for filename in tmp:\n bus_addr = get_dbus_session_bus_addr(file_path+filename)\n if bus_addr:\n break\n if not bus_addr:\n os.exit(0)\n\n os.environ['DBUS_SESSION_BUS_ADDRESS'] = bus_addr\n print(os.environ['DBUS_SESSION_BUS_ADDRESS'])\n\n notification=Notify.Notification.new(notification_title, notification_message, \"dialog-information\")\n try:\n notification.show()\n except:\n pass\n finally:\n os._exit(0)\n #probably X is not started yet. The process' dying anyway. not a big deal.","def on_launch():\n return get_welcome_message()","def onTrayIconActivated(self, reason):\n # if reason == self.DoubleClick:\n # self.open_notepad()\n # # if reason == self.Trigger:\n # # self.open_notepad()","def showMessage(self):","def Notify(self, text):\n self.logger.debug(\"Sending notification to XBMC: \" + text)\n xbmc = Server(self.url('/jsonrpc', True))\n image='https://raw.github.com/styxit/HTPC-Manager/master/interfaces/default/img/xbmc-logo.png'\n return xbmc.GUI.ShowNotification(title='HTPC manager', message=text, image=image)","def receive_notification(self, *args, **kwargs):\n\t\tprint(f\"{self.__location} is now hearing \\\"{args[0]}\\\" on {args[1]}\")","def show(self, window):\r\n\r\n return","def show(self, nid =None):\r\n flags = NIF_ICON | NIF_MESSAGE\r\n if nid is None:\r\n nid = (self.hwnd, 0, flags, WM_USER+20, self.hicon)\r\n if self.visible:\r\n self.hide()\r\n Shell_NotifyIcon(NIM_ADD, nid)\r\n self.visible = 1","def _show_notify(self, err):\n self.parent.show_notify(err)","def _show_notify(self, err):\n self.parent.show_notify(err)","def _show_notify(self, err):\n self.parent.show_notify(err)","def update_notify(self):\n updateReply = QtGui.QMessageBox.question(self, 'SmartFile Update',\n 'An update is available. Would you like to download now?',\n QtGui.QMessageBox.Yes | QtGui.QMessageBox.No,\n QtGui.QMessageBox.Yes)\n\n # Open a web browser if the user selects yes\n if updateReply == QtGui.QMessageBox.Yes:\n webbrowser.open(\"https://www.kissync.com/download\", new=2)","def show_default_notification_message(self):\n return self._show_default_notification_message","def notify():\n os.system(\"notify-send 'Search is complete.'\")\n os.system(\"paplay /usr/share/sounds/freedesktop/stereo/complete.oga\")","def showMessage(self, msg):\r\n super(SplashScreen, self).showMessage(\r\n msg, self.labelAlignment, QColor(_QtCore.Qt.white))\r\n QApplication.processEvents()","def notify(*, text, title=None, subtitle=None):\n import os\n\n command = f\"display notification {json.dumps(text)}\"\n if title:\n command += f\" with title {json.dumps(title)}\"\n if subtitle:\n command += f\" subtitle {json.dumps(subtitle)}\"\n os.system(f\"osascript -e '{command}'\")","def show_messages(self):\n console.alert(\n \"Info\",\n \"If StaSh does not launch anymore after you changed the config, run the 'launch_stash.py' script with \\n'--no-cfgfile'.\",\n \"Ok\",\n hide_cancel_button=True,\n )\n while True:\n self.wait_modal()\n if not self.subview_open:\n break\n console.alert(\n \"Info\",\n \"Some changes may only be visible after restarting StaSh and/or Pythonista.\",\n \"Ok\",\n hide_cancel_button=True,\n )","def notify(title, text, subtitle, say=None):\n \n os.system(\"\"\"\n osascript -e 'display notification \"{}\" with title \"{}\" subtitle \"{}\" sound name \"Ping\"'\n \"\"\".format(text, title, subtitle, text))\n \n if say:\n os.system(\"\"\"\n osascript -e 'say \"{}\"'\n \"\"\".format(say))","def show_status(self, status):\n self.statusBar().showMessage(status, 2000)","def _flash(self,id,msg,duration=30.0):\n if duration>0:\n pass #gtk.timeout_add(duration,'')\n return self.statusbar.push(id,msg)","def display_message(self, message):\n context_id = self.status_bar.get_context_id(\"\")\n self.status_bar.show()\n self.status_bar.push(context_id, message)","def show(self):\n # * displays the window, after using either the iconify or the withdraw methods\n self.wm_deiconify()\n # * this method can be called after the event which needs to happen before the window event\n self.wait_window()","def motion_notify_event(self, widget, event):\n\t\t#if event.window == self.ww:\n\t\t\n\t\t#print(self)\n\t\t\t#<FolderViewScreenlet object at 0x7f0bdfb3eaf0 (screenlets+Screenlet at 0x26e58e0)>\t\n\t\t#print(self.window)\n\t\t\t#<gtk.Window object at 0x7fc661862be0 (GtkWindow at 0x20202a0)>\n\t\t#print(widget)\n\t\t\t#<gtk.Window object at 0x7fd9e6dafbe0 (GtkWindow at 0x1f8e2a0)>\t\n\t\t#print(widget.window)\n\t\t\t#<gtk.gdk.Window object at 0x7ffb63f0e2d0 (GdkWindow at 0x16a16c0)>\n\n\t\t#self.window.present()\n\n\t\tbefore_cursor = self.cursor_position\n\t\tself.set_current_cursor(event,widget)\n\n\t\tif before_cursor <> self.cursor_position:\n\t\t\tself.hide_tip()\n\t\t\tself.show_tip()\n\t\t\tself.update()\n\n\t\t#self.window.present()","def execute(self):\n return LOGGER.info(f\"{datetime.datetime.now()} - Sending notification in Slack\")","def show_tray_message(self, index):\n icon = QSystemTrayIcon.MessageIcon(0)\n message = self.iconComboBox.itemText(int(index)) + \" set\"\n self.trayIcon.showMessage(qApp.applicationName() + \" \" + qApp.applicationVersion(), message, icon, 100)","def homescreen(self):\r\n self.root.ids.items_box.clear_widgets()\r\n homescreen_information = Label(\r\n text='Welcome.\\n\\n\\nThis was designed by Charles to calculate the hours different\\n'\r\n 'workgroups work at CIPS and WPS.\\n\\nTo begin, press the Load Data button on'\r\n ' the \\nleft hand side of this window.', font_size=20, halign='center')\r\n self.root.ids.items_box.add_widget(homescreen_information)","def show(self):\n self.present(orientations=ORIENTATIONS)\n # launch a background thread\n # we can not use ui.in_background here\n # because some dialogs would not open anymoe\n thr = threading.Thread(target=self.show_messages)\n thr.daemon = True\n thr.start()","def show_window(self):\n self.show()","def notifyUser(self, message):\n\n\n msg = QtWidgets.QMessageBox(self)\n msg.setText(message)\n msg.exec_()","def send_notification(summary, message=\"\", icon=None, update=True):\n if icon == None:\n icon = \"sonata\"\n\n if pynotify_module:\n global notification\n if update:\n notification.update(summary=summary, message=message, icon=icon)\n else:\n notification = pynotify.Notification(summary=summary, message=message, icon=icon)\n notification.show()\n else:\n # Use notify-send instead\n os.popen('notify-send -i \"{0}\" \"{1}\" \"{2}\"'.format(icon.replace('\"', '\\\\\"'), summary.replace('\"', '\\\\\"'), message.replace('\"', '\\\\\"')))","def about(self):\n self.main_window.message(\n width=200, aspect=100, justify=tkinter.CENTER,\n text=\"Jeu de Ping\\n\\n\"\n \"(C) Maximin Duvillard, August 2022.\\nLicence = GPL\")","def notification():\n # pop-up notification\n notifies = NotifyModel.get_notify(current_user.get_id())\n return jsonify(notifications=notifies)","def show_window_background():\n \n window = win32gui.FindWindow(MINECRAFT_CLASS_NAME, MINECRAFT_TITLE + MINECRAFT_VERSION)\n win32gui.SetForegroundWindow(window)\n win32gui.BringWindowToTop(window)","def showStatus(self, message):\n self.status_bar.showMessage(message)","def send_notification (event):\n Publisher.sendMessage (event)","def show(self):\n self.wid.show()","def notifyPut(self, data):\n if self.notify_hidden:\n self.notify_gui.dataQ.put('*SHOW*') # if gui is hidden when you send display data it will wake\n self.notify_hidden = False\n self.notify_gui.dataQ.put(data)","def display_message_on_ableton(self, message):\n self._show_message(message)","async def notify_view(self):\n await self.game_view.notify()","def send_notification(self, signal):\n self.cl.sendInitPresence() \n self.cl.send(xmpp.protocol.Message(self.recipient, str(signal), typ='chat'))","def notifyMe(bat_status, bat_lvl, tofull):\n Notify.init(\"Acpi Notification\")\n \n Notify.Notification.new(\n \"Battery Low\",\n\t\"{} {}%\".format(bat_status, bat_lvl)\n ).show()","def show_notification(notify):\n if notify == 'ErrorURL':\n var_notify.set(\"Can't connect to 'openexchangerates.org'\")\n else:\n var_notify.set('Wrong values!')","def notify_show(data, bufferp, uber_empty, tagsn, isdisplayed,\n ishilight, prefix, message):\n\n if (weechat.config_get_plugin('smart_notification') == \"on\" and\n bufferp == weechat.current_buffer()):\n pass\n\n elif (weechat.buffer_get_string(bufferp, \"localvar_type\") == \"private\" and\n weechat.config_get_plugin('show_priv_msg') == \"on\"):\n show_notification(prefix, message)\n\n elif (ishilight == \"1\" and\n weechat.config_get_plugin('show_hilights') == \"on\"):\n buffer = (weechat.buffer_get_string(bufferp, \"short_name\") or\n weechat.buffer_get_string(bufferp, \"name\"))\n show_notification(buffer, prefix +\n weechat.config_get_plugin('nick_separator') + message)\n\n return weechat.WEECHAT_RC_OK","def display_message():","def set_minimize_to_tray(self):\r\n\t\tself.statusicon = gtk.StatusIcon()\r\n\t\ticon_path = os.path.realpath(\".\" + \"\\\\icon.png\")\r\n\t\tself.statusicon = load_status_icon(icon_path, 128, 128, gtk.STOCK_GOTO_TOP)\r\n\t\tself.statusicon.set_tooltip(\"Claimtracker\")\r\n\t\tself.statusicon.connect(\"activate\", self.return_from_tray)\r\n\t\tself.window.connect(\"window-state-event\", self.minimize_to_tray)\r\n\t\tself.statusicon.set_visible(False)","def notifySysOperator(self):\n msg = self.generateNotifyMessage()\n print(msg)\n # with smtplib.SMTP('smtp.gmail.com', 587) as smtp:\n # smtp.ehlo()\n # smtp.starttls()\n # smtp.ehlo()\n\n # smtp.login(\"aladinshixi@gmail.com\", \"qwerQWER123.\")\n\n # smtp.sendmail(\"aladinshixi@gmail.com\", \"aladinshixi@gmail.com\", msg)\n\n # smtp.close()\n return False","def show(self) -> None:\n\t\tself.setIcon(self._icon)\n\t\tself.setText(self._subtitle)\n\t\tself.setInformativeText(self._message)\n\t\tself.setWindowTitle(self._title)\n\t\tself.exec()","def send_popup_message(self, title, header, message):\n data = self.device_id_str + \"\\tMSSG\\t{}\\t{}\\t{}\\n\".format(title, header, message)\n self.tx_zmq_pub.send_multipart([b\"ALL\", b'0', data.encode('utf-8')])","def _start_notification_cycle(self) -> None:\n self._cancel_notification_cycle()\n\n self.data[HANDLE_CLEAN] = send_notification(\n self,\n \"presence:home\",\n \"Empty it now and you won't have to do it later!\",\n title=\"Dishwasher Clean 🍽\",\n when=self.datetime() + timedelta(minutes=15),\n interval=int(\n float(self.get_state(self.args[CONF_NOTIFICATION_INTERVAL_SLIDER]))\n )\n * 60\n * 60,\n data={\"push\": {\"category\": \"dishwasher\"}},\n )","def createNotification(self): \n if self.power_plugged == True and self.battery_percent >= 80:\n Notify.init(\"Charger Notifier\")\n notification = Notify.Notification.new(\n \"BATTERY\",\n \"Battery level is over 80%! Please unplug the charger.\",\n \"dialog-information\"\n )\n notification.show()\n elif self.power_plugged == False and self.battery_percent <= 40:\n Notify.init(\"Charger Notifier\")\n notification = Notify.Notification.new(\n \"BATTERY\",\n \"Battery level is less than 40%! Please plug in the charger.\",\n \"dialog-information\"\n )\n notification.show()","def show(self):\n self._window.show()","def write(self, notification):","def alert_popup(title, message, path):\n root = Tk()\n root.title(title)\n w = 400 # popup window width\n h = 200 # popup window height\n sw = root.winfo_screenwidth()\n sh = root.winfo_screenheight()\n x = (sw - w)/2\n y = (sh - h)/2\n root.geometry('%dx%d+%d+%d' % (w, h, x, y))\n m = message\n m += '\\n'\n m += path\n w = Label(root, text=m, width=120, height=10)\n w.pack()\n b = Button(root, text=\"Continue\", command=root.destroy, width=10)\n b.pack()\n mainloop()","def on_action_9_triggered(self):\n # TODO: not implemented yet\n print('全屏')\n self.showFullScreen()","def remind():\n ntftion.notify('reminder', f\"{self.notification}:\\n{self.work_name}\\n{self.work_datetime.hour}: \"\n f\"{self.work_datetime.minute} \", app_icon='reminder.ico', timeout=3)","def display_message(self, message, level=\"information\"):\n box = QMessageBox(self.win)\n box.setText(message)\n box.setWindowTitle(QApplication.applicationName())\n if level == \"critical\":\n box.setIcon(QMessageBox.Critical)\n elif level == \"warning\":\n box.setIcon(QMessageBox.Warning)\n else:\n box.setIcon(QMessageBox.Information)\n box.exec_()","def close_notifications(self):\n self.android_device_driver.adb.exec_adb_cmd(\n \"shell cmd statusbar collapse\").wait()","def showinfo(self, msg):\n tkinter.messagebox.showinfo('Information', msg)","def window_info_toggle():\n window_info.hide() if window_info.showing else window_info.show()","def show_window(icon, item):\n icon.stop()\n app.after(0, app.deiconify())","def applicationDidFinishLaunching_(self, aNotification):","def showInfoWindow():\n\treturn 0","def handleMonitorSettings(self):\n winPos = self.mainWindow.pos()\n popPos = QtCore.QPoint(winPos.x() + (self.mainWindow.width() - self.settingsPopup.width()) / 2, \n winPos.y() + self.mainWindow.height() / 2)\n self.monitorPopUp.move(popPos)\n self.monitorPopUp.show()","def show_messages(self):\n self.masterlog.revealme()","def notification(request):\n return HttpResponseRedirect('/settings/notifications/')","def printer(message, level, display_on_mac=False):\n log = logging.getLogger(__name__)\n if check_running_from_automator() and display_on_mac:\n os.system(\n \"\"\"\n osascript -e 'display notification \"{}\" with title \"{}\"'\n \"\"\".format(\n message, \"Verizip\"\n )\n )\n else:\n getattr(log, level)(message)","def open_mwindow_timetable(self) -> None:\n self.mwindow_timetable.show()","def statusbar_msg(self, msg):\n self.statusbar.clearMessage()\n self.statusbar.showMessage(msg)","def msg_window(text):\n msg = QMessageBox()\n msg.setIcon(QMessageBox.Information)\n msg.setText(text)\n msg.setWindowTitle(\"Info\")\n msg.exec_()","def about_developer(self):\r\n self.pop_window(title=\"About\", \r\n msg=\"ChikonEye Version: 2.0.1 \\nDeveloper Info:\\nName : Ashraf Minhaj \\nEmail : ashraf_minhaj@yahoo.com \\nsite : ashrafminhajfb.blogspot.com \\nyouTube : fusebatti\")","def trayagent(forwho,trayclickedfunction):\r\n\r\n tray = QSystemTrayIcon(forwho.windowIcon(), forwho)\r\n forwho.connect(tray,SIGNAL(\"activated(QSystemTrayIcon::ActivationReason)\"),trayclickedfunction)\r\n tray.show()\r\n return tray","def alert(data: Any) -> None:\n\n root = Container()\n root += Label(\"[210 italic bold]Alert!\")\n root += Label()\n root += Label(str(data))\n\n root.center()\n root.print()\n getch()\n root.wipe()","def show_menu(self, update, context):\n msg_file = 'menu_msg.txt'\n self.send_textfile(msg_file, update, context)","def show_info_message(self, msg, msecs=3):\n\n message.PopupMessage.info(msg, parent=self, duration=msecs, closable=True)","def display(self):\n\t\tprint('The button in the window was clicked!')","def open_main_window(self):\r\n track_terms_dic = ''\r\n sg.theme(self.look)\r\n\r\n layout = [[sg.Text('Welcome to tweeet monitor ')],\r\n [sg.Text('Please enter Details ')],\r\n [sg.Text('User Mail', size=(15, 1)), sg.InputText()],\r\n [sg.Text('Timout', size=(15, 1)), sg.InputText('', enable_events=True, key='-DIGITS-')],\r\n [sg.Text('')],\r\n [sg.Text('You can select an existing list or create a new one '),\r\n sg.Combo(self.files, default_value='Select Track Terms List ', key='-COMBO1-')],\r\n [sg.Text('')],\r\n [sg.Button('Select Exists List'), sg.Button('Create a New List')],\r\n [sg.Text('\\n')],\r\n [sg.Button('Start Monitor'), sg.Button('Exit')]\r\n ]\r\n\r\n window = sg.Window('Monitor tweeter', layout)\r\n # Event Loop\r\n while True:\r\n event, values = window.read()\r\n\r\n if event == sg.WIN_CLOSED:\r\n exit()\r\n elif event == 'Select Exists List' or event == 'Create a New List' or event == 'Start Monitor':\r\n user_mail = values[0]\r\n timeout = values['-DIGITS-']\r\n list_dic = values['-COMBO1-']\r\n\r\n if self.check(user_mail) == 'Invalid Email':\r\n self.info_popup_window('You Enter not valid mail ', 'Info', self.look)\r\n elif event == 'Select Exists List':\r\n if list_dic == 'Select Track Terms List ':\r\n self.info_popup_window('Track Terms List ', 'Info', self.look)\r\n else:\r\n file_name = self.path + self.bachslash + list_dic\r\n os.system(file_name)\r\n track_terms_dic = list_dic\r\n elif event == 'Create a New List':\r\n track_terms_dic = self.open_window()\r\n track_terms_dic = track_terms_dic + '.txt'\r\n elif event == 'Start Monitor':\r\n if track_terms_dic == '':\r\n self.info_popup_window('Please, Create new Dictionary or select one ', 'Info', self.look)\r\n elif track_terms_dic != '':\r\n file_name = self.path + self.bachslash + track_terms_dic\r\n my_file = open(file_name, \"r\")\r\n content = my_file.read()\r\n content = content.split(\"\\n\")\r\n content = self.cleanList(content)\r\n # print(content)\r\n my_file.close()\r\n now = datetime.now()\r\n date_time = now.strftime(\"%m/%d/%Y, %H:%M:%S\")\r\n dict_list = {'User': user_mail,\r\n 'Timeout': timeout,\r\n 'Dictionary': list_dic,\r\n 'Create Date': date_time,\r\n 'track_terms_list': content\r\n }\r\n header = ['user_mail', 'Timeout', 'Dictionary', 'Create Date', 'list words']\r\n if os.path.isfile(self.file_track_terms_audit) == False:\r\n # check if the file exsist = if not: create file and print header to the file\r\n with open(self.file_track_terms_audit, 'a', newline='\\n') as file:\r\n try:\r\n write = csv.writer(file)\r\n write.writerow(header)\r\n write.writerows(self.values_list)\r\n file.close()\r\n except:\r\n print(\"Something went wrong when writing to the file\")\r\n else:\r\n self.values_list = list(dict_list.values())\r\n # print ('self.values_list :****',self.values_list)\r\n with open(self.file_track_terms_audit, 'a', newline='\\n') as file:\r\n try:\r\n write = csv.writer(file)\r\n self.values_list = [self.values_list]\r\n write.writerows(self.values_list)\r\n file.close()\r\n except:\r\n print(\"Something went wrong when writing to the file\")\r\n print('self.values_list:', self.values_list)\r\n\r\n window.close()\r\n\r\n print('track_terms_dic: ', track_terms_dic)\r\n print('dict_list:', dict_list)\r\n return (dict_list)\r\n\r\n # always check for closed window\r\n if event in (sg.WIN_CLOSED, 'Exit'):\r\n break\r\n\r\n if event == '-LIST-' and len(values['-LIST-']):\r\n sg.popup('Selected ', values['-LIST-'])\r\n\r\n if len(values['-DIGITS-']) and values['-DIGITS-'][-1] not in ('0123456789'):\r\n # delete last char from input\r\n window['-DIGITS-'].update(values['-DIGITS-'][:-1])\r\n\r\n window.close()","def update_status(self, s):\n self.statusbar.showMessage(s)","def main():\n options, names = get_bars(\"/home/njiall/.config/polybar/config\")\n bar_choice, bar_name = ask_user(options, names, \"Bar\")\n\n options, names = get_wallpapers([\"/home/njiall/.config/wallpapers\", \"/home/njiall/Pictures\"])\n wallpaper_choice, wallpaper_name = ask_user(options, names, \"Wallpaper\")\n\n # Apply bar if one has been selected, then sends a notification\n if bar_choice and bar_name:\n apply_bar(bar_choice)\n Notify.Notification.new(\"Changing bar to\", bar_name, app_icon).show()\n # Apply wallpaper if one has been selected\n if wallpaper_choice and wallpaper_name:\n apply_wallpaper(wallpaper_choice, \"/home/njiall/.bg{}.png\", rect = (1920, 1080))\n # Sends a notif\n Notify.Notification.new(\"Changing wallpaper to\", wallpaper_name, app_icon).show()\n # Blurs the wallpaper\n blur_wallpaper(wallpaper_choice, \"/home/njiall/.bg{}.png\", rect = (1920, 1080))\n # Sends a notif\n Notify.Notification.new(\"Blurred wallpaper for lockscreen\", wallpaper_name, app_icon).show()","def show_notifications(request):\n user = request.user\n notifications = Notification.objects.filter(user=user).order_by('-date')\n\n # change loaded notifications to 'seen'\n Notification.objects.filter(user=user, is_seen=False).update(is_seen=True)\n\n template = loader.get_template('notifications.html')\n\n context = {\n 'notifications': notifications,\n }\n\n return HttpResponse(template.render(context, request))","def perform(self):\n emails.notify(\n event=self.event_type,\n user=self.user,\n node=self.node,\n timestamp=self.timestamp,\n message=self.html_message,\n profile_image_url=self.profile_image_url,\n url=self.url\n )","async def plaguenotify(self, ctx):\n notifications = await self.config.user(ctx.author).notifications()\n if notifications != False:\n await self.config.user(ctx.author).notifications.set(False)\n message = \"You will no longer be sent Plague Game notifications.\"\n else:\n await self.config.user(ctx.author).notifications.set(True)\n message = \"You will now be sent Plague Game notifications.\"\n\n await ctx.send(message)","def updateStatus(self, message):\r\n self.statusBar().showMessage(message, 5000)\r\n if self.kinfilename is not None:\r\n self.setWindowTitle(\"Visualization Tool - %s\" % \\\r\n os.path.basename(unicode(self.kinfilename)))","def notify(self) -> None:\n pass","def notify(self) -> None:\n pass","def notify_song_found(song, station_frequency, favourite=False):\n display_screen(song, station_frequency)\n if switches.is_active_announce_all_songs_switch() or favourite:\n say_information_out_loud(song, station_frequency)","def notify(guid, message):","def __show_app_message(cls, message, level):\n\n ST_MIN_VERSION = 3070\n\n if (int(sublime.version()) >= ST_MIN_VERSION):\n cls.show_popup(message, level)\n else:\n sublime.status_message(message)"],"string":"[\n \"def open_notifications(self):\\n self.android_device_driver.adb.exec_adb_cmd(\\n \\\"shell cmd statusbar expand-notifications\\\").wait()\",\n \"def show_notification(self, message: str, also_cmd: bool = False):\\n if platform_string == \\\"Linux\\\":\\n try:\\n notification = notify2.Notification('LTU Assistant',\\n message,\\n 'notification-message-im')\\n notification.show()\\n except dbus.exceptions.DBusException:\\n if not also_cmd:\\n print(message)\\n elif platform_string == \\\"Windows\\\":\\n toaster.show_toast(\\\"LTU Assistant\\\", message, threaded=True)\",\n \"def show_notifications(run_time):\\n # Initialize the d-bus connection and create the notification object\\n notify2.init(\\\"News Indicator\\\")\\n n = notify2.Notification(None, icon=ICON)\\n\\n # Set the urgency level and the timeout\\n n.set_urgency(notify2.URGENCY_NORMAL)\\n n.set_timeout(10000)\\n formatted_time = run_time.time().strftime('%H:%M')\\n message = 'Your {} news are here!'.format(formatted_time)\\n\\n n.update('News Indicator', message=message, icon=ICON)\\n n.show()\",\n \"def show(self, timeout):\\n title = \\\"%s %s\\\" % (self.who, self.region)\\n text = \\\"%s %s\\\" % (self.time, self.text)\\n mod = self.__module__\\n if mod == '__main__':\\n path = sys.argv[0]\\n else:\\n path = sys.modules[mod].__file__\\n path = os.path.abspath(os.path.dirname(path))\\n imgl = self.icons[self.who.lower()]\\n imgc = os.path.join(os.path.expanduser('~'), '.cache', os.path.basename(imgl))\\n if not os.path.exists(imgc):\\n with open(imgc, 'w') as fd:\\n req = urllib.urlopen(img)\\n if req.code == 404:\\n raise IOError\\n fd.write(req.read())\\n\\n notification = pynotify.Notification(title, _escape(text), 'file://' + imgc)\\n notification.set_urgency(pynotify.URGENCY_CRITICAL)\\n caps = pynotify.get_server_caps()\\n if self.recipients and 'actions' in caps:\\n notification.add_action(\\\"details\\\", \\\"Details\\\", self.details)\\n # If the notification is deleted, the callback will not be called\\n _alerts.append(notification)\\n notification.set_timeout(timeout * 1000)\\n notification.show()\",\n \"def action_show():\\n try:\\n notification = read_notification()\\n except IOError:\\n raise HTTPResponse(body=\\\"Error reading notification IO\\\", status=400)\\n except:\\n raise HTTPResponse(body=\\\"Unexpected error\\\", status=400)\\n \\n if notification is not None:\\n return dict(msg=\\\"\\\", notification=notification.to_json())\\n else:\\n return dict(msg=\\\"No notification\\\")\",\n \"def show_desktop(dsk_session: WebDriver):\\n dsk_session.find_element_by_class_name(\\\"TrayShowDesktopButtonWClass\\\").click()\",\n \"def notifications():\\n flash(\\\"primary\\\", \\\"primary\\\")\\n flash(\\\"secondary\\\", \\\"secondary\\\")\\n flash(\\\"success\\\", \\\"success\\\")\\n flash(\\\"danger\\\", \\\"danger\\\")\\n flash(\\\"warning\\\", \\\"warning\\\")\\n flash(\\\"info\\\", \\\"info\\\")\\n return render_template(\\\"notifications.html\\\")\",\n \"def notify(self):\\n\\n def remind():\\n \\\"\\\"\\\"\\n this function shows a pop-up using windows notification\\n \\\"\\\"\\\"\\n ntftion.notify('reminder', f\\\"{self.notification}:\\\\n{self.work_name}\\\\n{self.work_datetime.hour}: \\\"\\n f\\\"{self.work_datetime.minute} \\\", app_icon='reminder.ico', timeout=3)\\n\\n self.eisenhower_priority()\\n if self.priority:\\n while dt.now().day <= self.time_ntf.day and self.status != \\\"done\\\":\\n if self.priority == 1 and dt.now().time() >= self.time_ntf.time():\\n remind()\\n time.sleep(5*60)\\n\\n elif (self.priority == 2) and ((dt.now().hour == self.time_ntf.hour)\\n and (dt.now().time().minute == self.time_ntf.time().minute)):\\n remind()\\n break\\n elif self.priority == 3 and dt.now().time().hour == 18:\\n remind()\\n time.sleep(24 * 3600)\\n elif self.priority == 4 and dt.now().weekday() == 6:\\n remind()\\n time.sleep(7 * 24 * 3600)\\n else:\\n pass\",\n \"async def show_notification(self, message: str, timeout: int):\\n self.notification_text = HTML(\\n f'<style bg=\\\"white\\\" color=\\\"black\\\">[ {message} ]</style>'\\n )\\n await asyncio.sleep(timeout)\\n self.notification_text = None\",\n \"def sendNotification(title, message):\\n if platform.platform().startswith('Linux'):\\n notify2.init('')\\n n = notify2.Notification(title, message)\\n n.show()\\n \\n elif platform.platform().startswith('Windows') and platform.release() == '10':\\n n = ToastNotifier()\\n n.show_toast(title, message)\",\n \"def _send_notification() -> None:\\n send_notification(\\n self,\\n \\\"slack:@aaron\\\",\\n \\\"New {0} Version: {1}\\\".format(\\n self.properties[CONF_APP_NAME], new_version\\n ),\\n title=\\\"New Software 💿\\\",\\n )\",\n \"def notification_interface():\\n return render_template(\\\"notifications.html\\\")\",\n \"def _notify(title, message, icon=\\\"dialog-error\\\"):\\n try:\\n import pynotify\\n except ImportError:\\n return\\n pynotify.init(\\\"moya-doc\\\")\\n n = pynotify.Notification(title, message, icon)\\n n.show()\",\n \"def show_notification(notification_title = \\\"\\\", notification_message = \\\"\\\", gid = None, uid = None):\\n child_pid = os.fork()\\n if(child_pid != 0):\\n return child_pid\\n\\n #child\\n if gid != None:\\n os.setgid(gid)\\n if uid != None:\\n os.setuid(uid)\\n\\n if 'HOME' in os.environ:\\n del os.environ['HOME'] \\n #force to use pwd\\n file_path = os.path.expanduser(r'~/.dbus/session-bus/')\\n tmp = os.listdir(file_path)\\n if not tmp:\\n os._exit(0)\\n\\n for filename in tmp:\\n bus_addr = get_dbus_session_bus_addr(file_path+filename)\\n if bus_addr:\\n break\\n if not bus_addr:\\n os.exit(0)\\n\\n os.environ['DBUS_SESSION_BUS_ADDRESS'] = bus_addr\\n print(os.environ['DBUS_SESSION_BUS_ADDRESS'])\\n\\n notification=Notify.Notification.new(notification_title, notification_message, \\\"dialog-information\\\")\\n try:\\n notification.show()\\n except:\\n pass\\n finally:\\n os._exit(0)\\n #probably X is not started yet. The process' dying anyway. not a big deal.\",\n \"def on_launch():\\n return get_welcome_message()\",\n \"def onTrayIconActivated(self, reason):\\n # if reason == self.DoubleClick:\\n # self.open_notepad()\\n # # if reason == self.Trigger:\\n # # self.open_notepad()\",\n \"def showMessage(self):\",\n \"def Notify(self, text):\\n self.logger.debug(\\\"Sending notification to XBMC: \\\" + text)\\n xbmc = Server(self.url('/jsonrpc', True))\\n image='https://raw.github.com/styxit/HTPC-Manager/master/interfaces/default/img/xbmc-logo.png'\\n return xbmc.GUI.ShowNotification(title='HTPC manager', message=text, image=image)\",\n \"def receive_notification(self, *args, **kwargs):\\n\\t\\tprint(f\\\"{self.__location} is now hearing \\\\\\\"{args[0]}\\\\\\\" on {args[1]}\\\")\",\n \"def show(self, window):\\r\\n\\r\\n return\",\n \"def show(self, nid =None):\\r\\n flags = NIF_ICON | NIF_MESSAGE\\r\\n if nid is None:\\r\\n nid = (self.hwnd, 0, flags, WM_USER+20, self.hicon)\\r\\n if self.visible:\\r\\n self.hide()\\r\\n Shell_NotifyIcon(NIM_ADD, nid)\\r\\n self.visible = 1\",\n \"def _show_notify(self, err):\\n self.parent.show_notify(err)\",\n \"def _show_notify(self, err):\\n self.parent.show_notify(err)\",\n \"def _show_notify(self, err):\\n self.parent.show_notify(err)\",\n \"def update_notify(self):\\n updateReply = QtGui.QMessageBox.question(self, 'SmartFile Update',\\n 'An update is available. Would you like to download now?',\\n QtGui.QMessageBox.Yes | QtGui.QMessageBox.No,\\n QtGui.QMessageBox.Yes)\\n\\n # Open a web browser if the user selects yes\\n if updateReply == QtGui.QMessageBox.Yes:\\n webbrowser.open(\\\"https://www.kissync.com/download\\\", new=2)\",\n \"def show_default_notification_message(self):\\n return self._show_default_notification_message\",\n \"def notify():\\n os.system(\\\"notify-send 'Search is complete.'\\\")\\n os.system(\\\"paplay /usr/share/sounds/freedesktop/stereo/complete.oga\\\")\",\n \"def showMessage(self, msg):\\r\\n super(SplashScreen, self).showMessage(\\r\\n msg, self.labelAlignment, QColor(_QtCore.Qt.white))\\r\\n QApplication.processEvents()\",\n \"def notify(*, text, title=None, subtitle=None):\\n import os\\n\\n command = f\\\"display notification {json.dumps(text)}\\\"\\n if title:\\n command += f\\\" with title {json.dumps(title)}\\\"\\n if subtitle:\\n command += f\\\" subtitle {json.dumps(subtitle)}\\\"\\n os.system(f\\\"osascript -e '{command}'\\\")\",\n \"def show_messages(self):\\n console.alert(\\n \\\"Info\\\",\\n \\\"If StaSh does not launch anymore after you changed the config, run the 'launch_stash.py' script with \\\\n'--no-cfgfile'.\\\",\\n \\\"Ok\\\",\\n hide_cancel_button=True,\\n )\\n while True:\\n self.wait_modal()\\n if not self.subview_open:\\n break\\n console.alert(\\n \\\"Info\\\",\\n \\\"Some changes may only be visible after restarting StaSh and/or Pythonista.\\\",\\n \\\"Ok\\\",\\n hide_cancel_button=True,\\n )\",\n \"def notify(title, text, subtitle, say=None):\\n \\n os.system(\\\"\\\"\\\"\\n osascript -e 'display notification \\\"{}\\\" with title \\\"{}\\\" subtitle \\\"{}\\\" sound name \\\"Ping\\\"'\\n \\\"\\\"\\\".format(text, title, subtitle, text))\\n \\n if say:\\n os.system(\\\"\\\"\\\"\\n osascript -e 'say \\\"{}\\\"'\\n \\\"\\\"\\\".format(say))\",\n \"def show_status(self, status):\\n self.statusBar().showMessage(status, 2000)\",\n \"def _flash(self,id,msg,duration=30.0):\\n if duration>0:\\n pass #gtk.timeout_add(duration,'')\\n return self.statusbar.push(id,msg)\",\n \"def display_message(self, message):\\n context_id = self.status_bar.get_context_id(\\\"\\\")\\n self.status_bar.show()\\n self.status_bar.push(context_id, message)\",\n \"def show(self):\\n # * displays the window, after using either the iconify or the withdraw methods\\n self.wm_deiconify()\\n # * this method can be called after the event which needs to happen before the window event\\n self.wait_window()\",\n \"def motion_notify_event(self, widget, event):\\n\\t\\t#if event.window == self.ww:\\n\\t\\t\\n\\t\\t#print(self)\\n\\t\\t\\t#<FolderViewScreenlet object at 0x7f0bdfb3eaf0 (screenlets+Screenlet at 0x26e58e0)>\\t\\n\\t\\t#print(self.window)\\n\\t\\t\\t#<gtk.Window object at 0x7fc661862be0 (GtkWindow at 0x20202a0)>\\n\\t\\t#print(widget)\\n\\t\\t\\t#<gtk.Window object at 0x7fd9e6dafbe0 (GtkWindow at 0x1f8e2a0)>\\t\\n\\t\\t#print(widget.window)\\n\\t\\t\\t#<gtk.gdk.Window object at 0x7ffb63f0e2d0 (GdkWindow at 0x16a16c0)>\\n\\n\\t\\t#self.window.present()\\n\\n\\t\\tbefore_cursor = self.cursor_position\\n\\t\\tself.set_current_cursor(event,widget)\\n\\n\\t\\tif before_cursor <> self.cursor_position:\\n\\t\\t\\tself.hide_tip()\\n\\t\\t\\tself.show_tip()\\n\\t\\t\\tself.update()\\n\\n\\t\\t#self.window.present()\",\n \"def execute(self):\\n return LOGGER.info(f\\\"{datetime.datetime.now()} - Sending notification in Slack\\\")\",\n \"def show_tray_message(self, index):\\n icon = QSystemTrayIcon.MessageIcon(0)\\n message = self.iconComboBox.itemText(int(index)) + \\\" set\\\"\\n self.trayIcon.showMessage(qApp.applicationName() + \\\" \\\" + qApp.applicationVersion(), message, icon, 100)\",\n \"def homescreen(self):\\r\\n self.root.ids.items_box.clear_widgets()\\r\\n homescreen_information = Label(\\r\\n text='Welcome.\\\\n\\\\n\\\\nThis was designed by Charles to calculate the hours different\\\\n'\\r\\n 'workgroups work at CIPS and WPS.\\\\n\\\\nTo begin, press the Load Data button on'\\r\\n ' the \\\\nleft hand side of this window.', font_size=20, halign='center')\\r\\n self.root.ids.items_box.add_widget(homescreen_information)\",\n \"def show(self):\\n self.present(orientations=ORIENTATIONS)\\n # launch a background thread\\n # we can not use ui.in_background here\\n # because some dialogs would not open anymoe\\n thr = threading.Thread(target=self.show_messages)\\n thr.daemon = True\\n thr.start()\",\n \"def show_window(self):\\n self.show()\",\n \"def notifyUser(self, message):\\n\\n\\n msg = QtWidgets.QMessageBox(self)\\n msg.setText(message)\\n msg.exec_()\",\n \"def send_notification(summary, message=\\\"\\\", icon=None, update=True):\\n if icon == None:\\n icon = \\\"sonata\\\"\\n\\n if pynotify_module:\\n global notification\\n if update:\\n notification.update(summary=summary, message=message, icon=icon)\\n else:\\n notification = pynotify.Notification(summary=summary, message=message, icon=icon)\\n notification.show()\\n else:\\n # Use notify-send instead\\n os.popen('notify-send -i \\\"{0}\\\" \\\"{1}\\\" \\\"{2}\\\"'.format(icon.replace('\\\"', '\\\\\\\\\\\"'), summary.replace('\\\"', '\\\\\\\\\\\"'), message.replace('\\\"', '\\\\\\\\\\\"')))\",\n \"def about(self):\\n self.main_window.message(\\n width=200, aspect=100, justify=tkinter.CENTER,\\n text=\\\"Jeu de Ping\\\\n\\\\n\\\"\\n \\\"(C) Maximin Duvillard, August 2022.\\\\nLicence = GPL\\\")\",\n \"def notification():\\n # pop-up notification\\n notifies = NotifyModel.get_notify(current_user.get_id())\\n return jsonify(notifications=notifies)\",\n \"def show_window_background():\\n \\n window = win32gui.FindWindow(MINECRAFT_CLASS_NAME, MINECRAFT_TITLE + MINECRAFT_VERSION)\\n win32gui.SetForegroundWindow(window)\\n win32gui.BringWindowToTop(window)\",\n \"def showStatus(self, message):\\n self.status_bar.showMessage(message)\",\n \"def send_notification (event):\\n Publisher.sendMessage (event)\",\n \"def show(self):\\n self.wid.show()\",\n \"def notifyPut(self, data):\\n if self.notify_hidden:\\n self.notify_gui.dataQ.put('*SHOW*') # if gui is hidden when you send display data it will wake\\n self.notify_hidden = False\\n self.notify_gui.dataQ.put(data)\",\n \"def display_message_on_ableton(self, message):\\n self._show_message(message)\",\n \"async def notify_view(self):\\n await self.game_view.notify()\",\n \"def send_notification(self, signal):\\n self.cl.sendInitPresence() \\n self.cl.send(xmpp.protocol.Message(self.recipient, str(signal), typ='chat'))\",\n \"def notifyMe(bat_status, bat_lvl, tofull):\\n Notify.init(\\\"Acpi Notification\\\")\\n \\n Notify.Notification.new(\\n \\\"Battery Low\\\",\\n\\t\\\"{} {}%\\\".format(bat_status, bat_lvl)\\n ).show()\",\n \"def show_notification(notify):\\n if notify == 'ErrorURL':\\n var_notify.set(\\\"Can't connect to 'openexchangerates.org'\\\")\\n else:\\n var_notify.set('Wrong values!')\",\n \"def notify_show(data, bufferp, uber_empty, tagsn, isdisplayed,\\n ishilight, prefix, message):\\n\\n if (weechat.config_get_plugin('smart_notification') == \\\"on\\\" and\\n bufferp == weechat.current_buffer()):\\n pass\\n\\n elif (weechat.buffer_get_string(bufferp, \\\"localvar_type\\\") == \\\"private\\\" and\\n weechat.config_get_plugin('show_priv_msg') == \\\"on\\\"):\\n show_notification(prefix, message)\\n\\n elif (ishilight == \\\"1\\\" and\\n weechat.config_get_plugin('show_hilights') == \\\"on\\\"):\\n buffer = (weechat.buffer_get_string(bufferp, \\\"short_name\\\") or\\n weechat.buffer_get_string(bufferp, \\\"name\\\"))\\n show_notification(buffer, prefix +\\n weechat.config_get_plugin('nick_separator') + message)\\n\\n return weechat.WEECHAT_RC_OK\",\n \"def display_message():\",\n \"def set_minimize_to_tray(self):\\r\\n\\t\\tself.statusicon = gtk.StatusIcon()\\r\\n\\t\\ticon_path = os.path.realpath(\\\".\\\" + \\\"\\\\\\\\icon.png\\\")\\r\\n\\t\\tself.statusicon = load_status_icon(icon_path, 128, 128, gtk.STOCK_GOTO_TOP)\\r\\n\\t\\tself.statusicon.set_tooltip(\\\"Claimtracker\\\")\\r\\n\\t\\tself.statusicon.connect(\\\"activate\\\", self.return_from_tray)\\r\\n\\t\\tself.window.connect(\\\"window-state-event\\\", self.minimize_to_tray)\\r\\n\\t\\tself.statusicon.set_visible(False)\",\n \"def notifySysOperator(self):\\n msg = self.generateNotifyMessage()\\n print(msg)\\n # with smtplib.SMTP('smtp.gmail.com', 587) as smtp:\\n # smtp.ehlo()\\n # smtp.starttls()\\n # smtp.ehlo()\\n\\n # smtp.login(\\\"aladinshixi@gmail.com\\\", \\\"qwerQWER123.\\\")\\n\\n # smtp.sendmail(\\\"aladinshixi@gmail.com\\\", \\\"aladinshixi@gmail.com\\\", msg)\\n\\n # smtp.close()\\n return False\",\n \"def show(self) -> None:\\n\\t\\tself.setIcon(self._icon)\\n\\t\\tself.setText(self._subtitle)\\n\\t\\tself.setInformativeText(self._message)\\n\\t\\tself.setWindowTitle(self._title)\\n\\t\\tself.exec()\",\n \"def send_popup_message(self, title, header, message):\\n data = self.device_id_str + \\\"\\\\tMSSG\\\\t{}\\\\t{}\\\\t{}\\\\n\\\".format(title, header, message)\\n self.tx_zmq_pub.send_multipart([b\\\"ALL\\\", b'0', data.encode('utf-8')])\",\n \"def _start_notification_cycle(self) -> None:\\n self._cancel_notification_cycle()\\n\\n self.data[HANDLE_CLEAN] = send_notification(\\n self,\\n \\\"presence:home\\\",\\n \\\"Empty it now and you won't have to do it later!\\\",\\n title=\\\"Dishwasher Clean 🍽\\\",\\n when=self.datetime() + timedelta(minutes=15),\\n interval=int(\\n float(self.get_state(self.args[CONF_NOTIFICATION_INTERVAL_SLIDER]))\\n )\\n * 60\\n * 60,\\n data={\\\"push\\\": {\\\"category\\\": \\\"dishwasher\\\"}},\\n )\",\n \"def createNotification(self): \\n if self.power_plugged == True and self.battery_percent >= 80:\\n Notify.init(\\\"Charger Notifier\\\")\\n notification = Notify.Notification.new(\\n \\\"BATTERY\\\",\\n \\\"Battery level is over 80%! Please unplug the charger.\\\",\\n \\\"dialog-information\\\"\\n )\\n notification.show()\\n elif self.power_plugged == False and self.battery_percent <= 40:\\n Notify.init(\\\"Charger Notifier\\\")\\n notification = Notify.Notification.new(\\n \\\"BATTERY\\\",\\n \\\"Battery level is less than 40%! Please plug in the charger.\\\",\\n \\\"dialog-information\\\"\\n )\\n notification.show()\",\n \"def show(self):\\n self._window.show()\",\n \"def write(self, notification):\",\n \"def alert_popup(title, message, path):\\n root = Tk()\\n root.title(title)\\n w = 400 # popup window width\\n h = 200 # popup window height\\n sw = root.winfo_screenwidth()\\n sh = root.winfo_screenheight()\\n x = (sw - w)/2\\n y = (sh - h)/2\\n root.geometry('%dx%d+%d+%d' % (w, h, x, y))\\n m = message\\n m += '\\\\n'\\n m += path\\n w = Label(root, text=m, width=120, height=10)\\n w.pack()\\n b = Button(root, text=\\\"Continue\\\", command=root.destroy, width=10)\\n b.pack()\\n mainloop()\",\n \"def on_action_9_triggered(self):\\n # TODO: not implemented yet\\n print('全屏')\\n self.showFullScreen()\",\n \"def remind():\\n ntftion.notify('reminder', f\\\"{self.notification}:\\\\n{self.work_name}\\\\n{self.work_datetime.hour}: \\\"\\n f\\\"{self.work_datetime.minute} \\\", app_icon='reminder.ico', timeout=3)\",\n \"def display_message(self, message, level=\\\"information\\\"):\\n box = QMessageBox(self.win)\\n box.setText(message)\\n box.setWindowTitle(QApplication.applicationName())\\n if level == \\\"critical\\\":\\n box.setIcon(QMessageBox.Critical)\\n elif level == \\\"warning\\\":\\n box.setIcon(QMessageBox.Warning)\\n else:\\n box.setIcon(QMessageBox.Information)\\n box.exec_()\",\n \"def close_notifications(self):\\n self.android_device_driver.adb.exec_adb_cmd(\\n \\\"shell cmd statusbar collapse\\\").wait()\",\n \"def showinfo(self, msg):\\n tkinter.messagebox.showinfo('Information', msg)\",\n \"def window_info_toggle():\\n window_info.hide() if window_info.showing else window_info.show()\",\n \"def show_window(icon, item):\\n icon.stop()\\n app.after(0, app.deiconify())\",\n \"def applicationDidFinishLaunching_(self, aNotification):\",\n \"def showInfoWindow():\\n\\treturn 0\",\n \"def handleMonitorSettings(self):\\n winPos = self.mainWindow.pos()\\n popPos = QtCore.QPoint(winPos.x() + (self.mainWindow.width() - self.settingsPopup.width()) / 2, \\n winPos.y() + self.mainWindow.height() / 2)\\n self.monitorPopUp.move(popPos)\\n self.monitorPopUp.show()\",\n \"def show_messages(self):\\n self.masterlog.revealme()\",\n \"def notification(request):\\n return HttpResponseRedirect('/settings/notifications/')\",\n \"def printer(message, level, display_on_mac=False):\\n log = logging.getLogger(__name__)\\n if check_running_from_automator() and display_on_mac:\\n os.system(\\n \\\"\\\"\\\"\\n osascript -e 'display notification \\\"{}\\\" with title \\\"{}\\\"'\\n \\\"\\\"\\\".format(\\n message, \\\"Verizip\\\"\\n )\\n )\\n else:\\n getattr(log, level)(message)\",\n \"def open_mwindow_timetable(self) -> None:\\n self.mwindow_timetable.show()\",\n \"def statusbar_msg(self, msg):\\n self.statusbar.clearMessage()\\n self.statusbar.showMessage(msg)\",\n \"def msg_window(text):\\n msg = QMessageBox()\\n msg.setIcon(QMessageBox.Information)\\n msg.setText(text)\\n msg.setWindowTitle(\\\"Info\\\")\\n msg.exec_()\",\n \"def about_developer(self):\\r\\n self.pop_window(title=\\\"About\\\", \\r\\n msg=\\\"ChikonEye Version: 2.0.1 \\\\nDeveloper Info:\\\\nName : Ashraf Minhaj \\\\nEmail : ashraf_minhaj@yahoo.com \\\\nsite : ashrafminhajfb.blogspot.com \\\\nyouTube : fusebatti\\\")\",\n \"def trayagent(forwho,trayclickedfunction):\\r\\n\\r\\n tray = QSystemTrayIcon(forwho.windowIcon(), forwho)\\r\\n forwho.connect(tray,SIGNAL(\\\"activated(QSystemTrayIcon::ActivationReason)\\\"),trayclickedfunction)\\r\\n tray.show()\\r\\n return tray\",\n \"def alert(data: Any) -> None:\\n\\n root = Container()\\n root += Label(\\\"[210 italic bold]Alert!\\\")\\n root += Label()\\n root += Label(str(data))\\n\\n root.center()\\n root.print()\\n getch()\\n root.wipe()\",\n \"def show_menu(self, update, context):\\n msg_file = 'menu_msg.txt'\\n self.send_textfile(msg_file, update, context)\",\n \"def show_info_message(self, msg, msecs=3):\\n\\n message.PopupMessage.info(msg, parent=self, duration=msecs, closable=True)\",\n \"def display(self):\\n\\t\\tprint('The button in the window was clicked!')\",\n \"def open_main_window(self):\\r\\n track_terms_dic = ''\\r\\n sg.theme(self.look)\\r\\n\\r\\n layout = [[sg.Text('Welcome to tweeet monitor ')],\\r\\n [sg.Text('Please enter Details ')],\\r\\n [sg.Text('User Mail', size=(15, 1)), sg.InputText()],\\r\\n [sg.Text('Timout', size=(15, 1)), sg.InputText('', enable_events=True, key='-DIGITS-')],\\r\\n [sg.Text('')],\\r\\n [sg.Text('You can select an existing list or create a new one '),\\r\\n sg.Combo(self.files, default_value='Select Track Terms List ', key='-COMBO1-')],\\r\\n [sg.Text('')],\\r\\n [sg.Button('Select Exists List'), sg.Button('Create a New List')],\\r\\n [sg.Text('\\\\n')],\\r\\n [sg.Button('Start Monitor'), sg.Button('Exit')]\\r\\n ]\\r\\n\\r\\n window = sg.Window('Monitor tweeter', layout)\\r\\n # Event Loop\\r\\n while True:\\r\\n event, values = window.read()\\r\\n\\r\\n if event == sg.WIN_CLOSED:\\r\\n exit()\\r\\n elif event == 'Select Exists List' or event == 'Create a New List' or event == 'Start Monitor':\\r\\n user_mail = values[0]\\r\\n timeout = values['-DIGITS-']\\r\\n list_dic = values['-COMBO1-']\\r\\n\\r\\n if self.check(user_mail) == 'Invalid Email':\\r\\n self.info_popup_window('You Enter not valid mail ', 'Info', self.look)\\r\\n elif event == 'Select Exists List':\\r\\n if list_dic == 'Select Track Terms List ':\\r\\n self.info_popup_window('Track Terms List ', 'Info', self.look)\\r\\n else:\\r\\n file_name = self.path + self.bachslash + list_dic\\r\\n os.system(file_name)\\r\\n track_terms_dic = list_dic\\r\\n elif event == 'Create a New List':\\r\\n track_terms_dic = self.open_window()\\r\\n track_terms_dic = track_terms_dic + '.txt'\\r\\n elif event == 'Start Monitor':\\r\\n if track_terms_dic == '':\\r\\n self.info_popup_window('Please, Create new Dictionary or select one ', 'Info', self.look)\\r\\n elif track_terms_dic != '':\\r\\n file_name = self.path + self.bachslash + track_terms_dic\\r\\n my_file = open(file_name, \\\"r\\\")\\r\\n content = my_file.read()\\r\\n content = content.split(\\\"\\\\n\\\")\\r\\n content = self.cleanList(content)\\r\\n # print(content)\\r\\n my_file.close()\\r\\n now = datetime.now()\\r\\n date_time = now.strftime(\\\"%m/%d/%Y, %H:%M:%S\\\")\\r\\n dict_list = {'User': user_mail,\\r\\n 'Timeout': timeout,\\r\\n 'Dictionary': list_dic,\\r\\n 'Create Date': date_time,\\r\\n 'track_terms_list': content\\r\\n }\\r\\n header = ['user_mail', 'Timeout', 'Dictionary', 'Create Date', 'list words']\\r\\n if os.path.isfile(self.file_track_terms_audit) == False:\\r\\n # check if the file exsist = if not: create file and print header to the file\\r\\n with open(self.file_track_terms_audit, 'a', newline='\\\\n') as file:\\r\\n try:\\r\\n write = csv.writer(file)\\r\\n write.writerow(header)\\r\\n write.writerows(self.values_list)\\r\\n file.close()\\r\\n except:\\r\\n print(\\\"Something went wrong when writing to the file\\\")\\r\\n else:\\r\\n self.values_list = list(dict_list.values())\\r\\n # print ('self.values_list :****',self.values_list)\\r\\n with open(self.file_track_terms_audit, 'a', newline='\\\\n') as file:\\r\\n try:\\r\\n write = csv.writer(file)\\r\\n self.values_list = [self.values_list]\\r\\n write.writerows(self.values_list)\\r\\n file.close()\\r\\n except:\\r\\n print(\\\"Something went wrong when writing to the file\\\")\\r\\n print('self.values_list:', self.values_list)\\r\\n\\r\\n window.close()\\r\\n\\r\\n print('track_terms_dic: ', track_terms_dic)\\r\\n print('dict_list:', dict_list)\\r\\n return (dict_list)\\r\\n\\r\\n # always check for closed window\\r\\n if event in (sg.WIN_CLOSED, 'Exit'):\\r\\n break\\r\\n\\r\\n if event == '-LIST-' and len(values['-LIST-']):\\r\\n sg.popup('Selected ', values['-LIST-'])\\r\\n\\r\\n if len(values['-DIGITS-']) and values['-DIGITS-'][-1] not in ('0123456789'):\\r\\n # delete last char from input\\r\\n window['-DIGITS-'].update(values['-DIGITS-'][:-1])\\r\\n\\r\\n window.close()\",\n \"def update_status(self, s):\\n self.statusbar.showMessage(s)\",\n \"def main():\\n options, names = get_bars(\\\"/home/njiall/.config/polybar/config\\\")\\n bar_choice, bar_name = ask_user(options, names, \\\"Bar\\\")\\n\\n options, names = get_wallpapers([\\\"/home/njiall/.config/wallpapers\\\", \\\"/home/njiall/Pictures\\\"])\\n wallpaper_choice, wallpaper_name = ask_user(options, names, \\\"Wallpaper\\\")\\n\\n # Apply bar if one has been selected, then sends a notification\\n if bar_choice and bar_name:\\n apply_bar(bar_choice)\\n Notify.Notification.new(\\\"Changing bar to\\\", bar_name, app_icon).show()\\n # Apply wallpaper if one has been selected\\n if wallpaper_choice and wallpaper_name:\\n apply_wallpaper(wallpaper_choice, \\\"/home/njiall/.bg{}.png\\\", rect = (1920, 1080))\\n # Sends a notif\\n Notify.Notification.new(\\\"Changing wallpaper to\\\", wallpaper_name, app_icon).show()\\n # Blurs the wallpaper\\n blur_wallpaper(wallpaper_choice, \\\"/home/njiall/.bg{}.png\\\", rect = (1920, 1080))\\n # Sends a notif\\n Notify.Notification.new(\\\"Blurred wallpaper for lockscreen\\\", wallpaper_name, app_icon).show()\",\n \"def show_notifications(request):\\n user = request.user\\n notifications = Notification.objects.filter(user=user).order_by('-date')\\n\\n # change loaded notifications to 'seen'\\n Notification.objects.filter(user=user, is_seen=False).update(is_seen=True)\\n\\n template = loader.get_template('notifications.html')\\n\\n context = {\\n 'notifications': notifications,\\n }\\n\\n return HttpResponse(template.render(context, request))\",\n \"def perform(self):\\n emails.notify(\\n event=self.event_type,\\n user=self.user,\\n node=self.node,\\n timestamp=self.timestamp,\\n message=self.html_message,\\n profile_image_url=self.profile_image_url,\\n url=self.url\\n )\",\n \"async def plaguenotify(self, ctx):\\n notifications = await self.config.user(ctx.author).notifications()\\n if notifications != False:\\n await self.config.user(ctx.author).notifications.set(False)\\n message = \\\"You will no longer be sent Plague Game notifications.\\\"\\n else:\\n await self.config.user(ctx.author).notifications.set(True)\\n message = \\\"You will now be sent Plague Game notifications.\\\"\\n\\n await ctx.send(message)\",\n \"def updateStatus(self, message):\\r\\n self.statusBar().showMessage(message, 5000)\\r\\n if self.kinfilename is not None:\\r\\n self.setWindowTitle(\\\"Visualization Tool - %s\\\" % \\\\\\r\\n os.path.basename(unicode(self.kinfilename)))\",\n \"def notify(self) -> None:\\n pass\",\n \"def notify(self) -> None:\\n pass\",\n \"def notify_song_found(song, station_frequency, favourite=False):\\n display_screen(song, station_frequency)\\n if switches.is_active_announce_all_songs_switch() or favourite:\\n say_information_out_loud(song, station_frequency)\",\n \"def notify(guid, message):\",\n \"def __show_app_message(cls, message, level):\\n\\n ST_MIN_VERSION = 3070\\n\\n if (int(sublime.version()) >= ST_MIN_VERSION):\\n cls.show_popup(message, level)\\n else:\\n sublime.status_message(message)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6929462","0.66672254","0.66309613","0.65788645","0.64223236","0.6387376","0.6368331","0.63421816","0.6315346","0.6290845","0.6279278","0.6196264","0.6121753","0.6016449","0.6004377","0.5964229","0.5962187","0.5953753","0.5938636","0.5907336","0.5901497","0.5893479","0.5893479","0.5893479","0.5889885","0.5871969","0.586663","0.58637315","0.58600247","0.58370227","0.58274466","0.5801132","0.5795113","0.5780276","0.57672775","0.5735157","0.57155764","0.57062","0.5705631","0.57042223","0.5691547","0.5690903","0.56827223","0.56613696","0.5656267","0.56524324","0.56485856","0.5629105","0.5604935","0.55833036","0.55735004","0.55694443","0.5564787","0.5543886","0.5536678","0.55337936","0.55203855","0.5517052","0.5515544","0.5504681","0.54964864","0.54947937","0.5483652","0.547348","0.54597086","0.54489475","0.5442166","0.5441776","0.5436025","0.54302835","0.5426644","0.5410373","0.54097646","0.5401074","0.5400907","0.5395091","0.5385748","0.5369626","0.5350668","0.534908","0.53443426","0.5344124","0.53305364","0.5329472","0.5324226","0.53204376","0.5319683","0.5317302","0.53136855","0.5304808","0.53032416","0.53017807","0.5301063","0.5286249","0.5285101","0.52808243","0.52808243","0.52783704","0.5274464","0.52718174"],"string":"[\n \"0.6929462\",\n \"0.66672254\",\n \"0.66309613\",\n \"0.65788645\",\n \"0.64223236\",\n \"0.6387376\",\n \"0.6368331\",\n \"0.63421816\",\n \"0.6315346\",\n \"0.6290845\",\n \"0.6279278\",\n \"0.6196264\",\n \"0.6121753\",\n \"0.6016449\",\n \"0.6004377\",\n \"0.5964229\",\n \"0.5962187\",\n \"0.5953753\",\n \"0.5938636\",\n \"0.5907336\",\n \"0.5901497\",\n \"0.5893479\",\n \"0.5893479\",\n \"0.5893479\",\n \"0.5889885\",\n \"0.5871969\",\n \"0.586663\",\n \"0.58637315\",\n \"0.58600247\",\n \"0.58370227\",\n \"0.58274466\",\n \"0.5801132\",\n \"0.5795113\",\n \"0.5780276\",\n \"0.57672775\",\n \"0.5735157\",\n \"0.57155764\",\n \"0.57062\",\n \"0.5705631\",\n \"0.57042223\",\n \"0.5691547\",\n \"0.5690903\",\n \"0.56827223\",\n \"0.56613696\",\n \"0.5656267\",\n \"0.56524324\",\n \"0.56485856\",\n \"0.5629105\",\n \"0.5604935\",\n \"0.55833036\",\n \"0.55735004\",\n \"0.55694443\",\n \"0.5564787\",\n \"0.5543886\",\n \"0.5536678\",\n \"0.55337936\",\n \"0.55203855\",\n \"0.5517052\",\n \"0.5515544\",\n \"0.5504681\",\n \"0.54964864\",\n \"0.54947937\",\n \"0.5483652\",\n \"0.547348\",\n \"0.54597086\",\n \"0.54489475\",\n \"0.5442166\",\n \"0.5441776\",\n \"0.5436025\",\n \"0.54302835\",\n \"0.5426644\",\n \"0.5410373\",\n \"0.54097646\",\n \"0.5401074\",\n \"0.5400907\",\n \"0.5395091\",\n \"0.5385748\",\n \"0.5369626\",\n \"0.5350668\",\n \"0.534908\",\n \"0.53443426\",\n \"0.5344124\",\n \"0.53305364\",\n \"0.5329472\",\n \"0.5324226\",\n \"0.53204376\",\n \"0.5319683\",\n \"0.5317302\",\n \"0.53136855\",\n \"0.5304808\",\n \"0.53032416\",\n \"0.53017807\",\n \"0.5301063\",\n \"0.5286249\",\n \"0.5285101\",\n \"0.52808243\",\n \"0.52808243\",\n \"0.52783704\",\n \"0.5274464\",\n \"0.52718174\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56673187"},"document_rank":{"kind":"string","value":"43"}}},{"rowIdx":93193,"cells":{"query":{"kind":"string","value":"BuilderConfig for RuBQ 2.0."},"document":{"kind":"string","value":"def __init__(self,\n data_url,\n data_dir,\n **kwargs):\n super(RuBQ2Config, self).__init__(**kwargs)\n self.data_url = data_url\n self.data_dir = data_dir"},"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 getBuilder():","def buildersConf() :\n return dict(_buildersConf)","def getBuilder(name):","def getBuilder(name):","def build_configs():","def build(config):","def configure_bot(self, builders_dict, additional_configs=None):\n additional_configs = additional_configs or []\n\n # TODO: crbug.com/358481 . The build_config should probably be a property\n # passed in from the slave config, but that doesn't exist today, so we\n # need a lookup mechanism to map bot name to build_config.\n mastername = self.m.properties.get('mastername')\n buildername = self.m.properties.get('buildername')\n master_dict = builders_dict.get(mastername, {})\n bot_config = master_dict.get('builders', {}).get(buildername)\n\n self.set_config(bot_config.get('chromium_config', 'chromium'),\n **bot_config.get('chromium_config_kwargs', {}))\n\n for c in bot_config.get('chromium_apply_config', []):\n self.apply_config(c)\n\n for c in additional_configs:\n self.apply_config(c)\n\n # Note that we have to call gclient.set_config() and apply_config() *after*\n # calling chromium.set_config(), above, because otherwise the chromium\n # call would reset the gclient config to its defaults.\n self.m.gclient.set_config(\n 'chromium',\n PATCH_PROJECT=self.m.properties.get('patch_project'))\n for c in bot_config.get('gclient_apply_config', []):\n self.m.gclient.apply_config(c)\n\n return (buildername, bot_config)","def albu_builder(self, cfg):\n assert isinstance(cfg, dict) and 'type' in cfg\n args = cfg.copy()\n obj_type = args.pop('type')\n if mmcv.is_str(obj_type):\n obj_cls = getattr(albumentations, obj_type)\n else:\n raise TypeError(f'type must be str, but got {type(obj_type)}')\n if 'transforms' in args:\n args['transforms'] = [\n self.albu_builder(transform)\n for transform in args['transforms']\n ]\n return obj_cls(**args)","def build_config(self, config):\n \n config.setdefaults(\n 'Network', {'IP': '192.168.1.16', 'port': 8000}\n )\n config.setdefaults(\n 'Camera', {'ISO': 100, 'Shutter': 5000, 'Aperture': 4, 'Zoom': 45}\n )\n config.setdefaults(\n 'Admin', {'Logging Path': gs.AUVSI_BASE_FOLDER}\n )\n config.setdefaults(\n 'CV', {'image_rescaling': 0.25}\n )\n \n #\n # Disable multi touch emulation with the mouse.\n #\n from kivy.config import Config\n Config.set('input', 'mouse', 'mouse,disable_multitouch')","def create_config(self) -> None:\n pass","def create_config(self) -> None:\n pass","def build_configuration() -> Config:\n logger.debug('Building configuration.')\n config = Config(roman_url=sanitize_url(get_prop('ROMAN_URL')),\n redis_url=get_prop('REDIS_URL'),\n redis_port=int(get_prop('REDIS_PORT')),\n redis_username=get_prop('REDIS_USERNAME', True),\n redis_password=get_prop('REDIS_PASSWORD', True),\n charon_url=sanitize_url(get_prop('CHARON_URL')))\n logger.debug(f'Used configuration: {config}')\n return config","def config(cls) -> 'bittensor.Config':\n parser = argparse.ArgumentParser()\n wallet.add_args( parser )\n return bittensor.config( parser )","def albu_builder(self, cfg):\n\n assert isinstance(cfg, dict) and 'type' in cfg\n args = cfg.copy()\n\n obj_type = args.pop('type')\n if general_ocr.is_str(obj_type):\n if albumentations is None:\n raise RuntimeError('albumentations is not installed')\n obj_cls = getattr(albumentations, obj_type)\n elif inspect.isclass(obj_type):\n obj_cls = obj_type\n else:\n raise TypeError(\n f'type must be a str or valid type, but got {type(obj_type)}')\n\n if 'transforms' in args:\n args['transforms'] = [\n self.albu_builder(transform)\n for transform in args['transforms']\n ]\n\n return obj_cls(**args)","def get_config_template() -> dict:\n return {\n VENE_PAYMENTS_BAMBORA_API_URL: (str, \"https://payform.bambora.com/pbwapi\"),\n VENE_PAYMENTS_BAMBORA_API_KEY: str,\n VENE_PAYMENTS_BAMBORA_API_SECRET: str,\n VENE_PAYMENTS_BAMBORA_PAYMENT_METHODS: list,\n }","def config():","def config():","def configure(self, options, conf):","def config(self):\n pass","def config(self):\n pass","def test_builder_config(code_builder: dataset_builder.DatasetBuilder):\n if not code_builder.BUILDER_CONFIGS:\n return\n\n # Remove the registered configs\n with mock.patch.object(\n type(code_builder), 'BUILDER_CONFIGS', []\n ), mock.patch.object(type(code_builder), 'builder_configs', {}):\n # Config isn't present in the code anymore\n with pytest.raises(ValueError, match='BuilderConfig .* not found'):\n load.builder(\n f'{code_builder.name}/dummy_config', data_dir='/tmp/path/not-exists'\n )\n\n # But previously generated configs still be loaded from disk\n builder = load.builder(f'{code_builder.name}/dummy_config')\n assert not isinstance(builder, type(code_builder))\n assert isinstance(builder, read_only_builder.ReadOnlyBuilder)","def config(self):\n raise NotImplementedError","def configuration():","def config( **kwargs ):","def vdk_configure(self, config_builder: ConfigurationBuilder) -> None:\n # Plugin-related configurations\n config_builder.add(\n key=\"INGEST_METHOD_DEFAULT\",\n default_value=None,\n description=\"Default Ingestion method to be used.\",\n )\n config_builder.add(\n key=\"INGEST_TARGET_DEFAULT\",\n default_value=None,\n description=\"Default Ingestion target to be used.\",\n )\n\n # Configure ingestion specific environment variables\n ingester_configuration.add_definitions(config_builder=config_builder)","def configure(self):","def configure(self):","def configure(self):","def configure(self):","def build_configuration(\n cls,\n class_name,\n module_name=\"great_expectations.datasource\",\n data_asset_type=None,\n batch_kwargs_generators=None,\n **kwargs,\n ):\n verify_dynamic_loading_support(module_name=module_name)\n class_ = load_class(class_name=class_name, module_name=module_name)\n configuration = class_.build_configuration(\n data_asset_type=data_asset_type,\n batch_kwargs_generators=batch_kwargs_generators,\n **kwargs,\n )\n return configuration","def config_create():\r\n\r\n \"\"\"\r\n global CONSUMER_KEY \r\n global CONSUMER_SECRET \r\n global ACCESS_KEY \r\n global ACCESS_SECRET\r\n global TweetBotName \r\n global StreamL \r\n global TweetL \r\n global NSFW \r\n global SFW \r\n global searchterm \r\n global tMax \r\n global tMin \r\n global tStep\r\n \r\n config = configparser.ConfigParser()\r\n with open('botconfig.ini', 'r') as configfile:\r\n config.read_file(configfile)\r\n CONSUMER_KEY = config.get('Auth', 'CONSUMER_KEY') \r\n CONSUMER_SECRET = config.get('Auth', 'CONSUMER_SECRET').encode('utf-8') \r\n ACCESS_KEY = config.get('Auth', 'ACCESS_KEY').encode('utf-8')\r\n ACCESS_SECRET = config.get('Auth', 'ACCESS_SECRET').encode('utf-8')\r\n TweetBotName = config.get('Auth', 'BotName')\r\n StreamL = config.get('Log', 'Log1')\r\n TweetL = config.get('Log', 'Log2')\r\n NSFW = config.get('Filter', 'String1')\r\n SFW = config.get('Filter', 'String2')\r\n searchterm = config.get('Filter', 'Search')\r\n tMax = int(float(config.get('Tweet_Delay', 'Max')))\r\n tMin = int(float(config.get('Tweet_Delay', 'Min')))\r\n tStep = int(float(config.get('Tweet_Delay', 'Step')))\r\n global api \r\n\r\n \"\"\"\r\n config = configparser.ConfigParser()\r\n with open('botconfig.ini', 'r') as configfile:\r\n config.readfp(configfile)\r\n return config","def configs(self):\n raise NotImplementedError()","def generate(self):\n\t\traise BuilderException(\"You can not use this class directly!\")","def get_builder(self, request):\n raise NotImplementedError()","def build_trainer_config(config):\r\n # determining environment parameters\r\n env_fcn = config['_env_fcn']\r\n env = env_fcn(config['_env'])\r\n obs_space, act_space, n_policies = env.observation_space, env.action_space, env.n_policies\r\n env.close()\r\n\r\n policies = config['_get_policies'](config=config, n_policies=n_policies, obs_space=obs_space, act_space=act_space)\r\n select_policy = config['_select_policy']\r\n\r\n config = deepcopy(config)\r\n config['_all_policies'] = sorted(policies.keys())\r\n\r\n if config['_update_withpolicies'] and '_iteration' in config:\r\n config = config['_update_withpolicies'](config, iteration=config['_iteration'])\r\n\r\n config1 = deepcopy(config)\r\n config1['multiagent'] = {}\r\n config1['multiagent']['policies'] = policies\r\n\r\n for k in config['_train_policies']:\r\n assert k in policies.keys(), f\"Unknown policy {k} [range {policies.keys()}]\"\r\n\r\n rl_config = {\r\n \"env\": config['_env_name_rllib'],\r\n \"env_config\": config['_env'],\r\n \"multiagent\": {\r\n \"policies_to_train\": config['_train_policies'],\r\n \"policies\": policies,\r\n \"policy_mapping_fn\": partial(select_policy, config=config1),\r\n },\r\n 'tf_session_args': {'intra_op_parallelism_threads': config['_num_workers_tf'],\r\n 'inter_op_parallelism_threads': config['_num_workers_tf'],\r\n 'gpu_options': {'allow_growth': True},\r\n 'log_device_placement': True,\r\n 'device_count': {'CPU': config['_num_workers_tf']},\r\n 'allow_soft_placement': True\r\n },\r\n \"local_tf_session_args\": {\r\n \"intra_op_parallelism_threads\": config['_num_workers_tf'],\r\n \"inter_op_parallelism_threads\": config['_num_workers_tf'],\r\n },\r\n }\r\n\r\n # filling in the rest of variables\r\n for k, v in config.items():\r\n if k.startswith('_'): continue\r\n rl_config[k] = v\r\n\r\n if config.get('_verbose', True):\r\n print(\"Config:\")\r\n print(pretty_print(rl_config))\r\n\r\n if config['_trainer'] == 'External' and '_tmp_dir' in config:\r\n rl_config['tmp_dir'] = config['_tmp_dir']\r\n \r\n for key, val in rl_config.items():\r\n if isinstance(val, Domain):\r\n sampled_val = val.sample()\r\n rl_config[key] = sampled_val\r\n logging.warning(f\"Trainer got a ray.tune.sample for parameter {key}: {type(val)}({val}). Replacing it with a sampled value {sampled_val}\")\r\n\r\n return rl_config","def config(self):\n return None","def config(self) -> InstrumentConfig:\n ...","def _generate_slave_config(project: PyfmuProject):\n return project.project_configuration","def dbt_config(self):\n from dbt.config.runtime import RuntimeConfig as DbtRuntimeConfig\n from dbt.adapters.factory import register_adapter\n\n self.dbt_config = DbtRuntimeConfig.from_args(\n DbtConfigArgs(\n project_dir=self._get_project_dir(),\n profiles_dir=self._get_profiles_dir(),\n profile=self._get_profile(),\n )\n )\n register_adapter(self.dbt_config)\n return self.dbt_config","def configure(self, **cfg: Any) -> 'Self | None':","def defaultconfig(self):\r\n\r\n config_data = {\r\n \"path_to_database\": \"FUDB/FOLLOWUP.DB\",\r\n \"path_to_frontend\": \"FUDB/\",\r\n \"path_to_dcs_info\": \"FUDB/\",\r\n \"path_to_bin\": \"bin/\",\r\n \"path_to_excels_exported_from_database\": \"excels exported/\",\r\n \"path_to_excels_to_be_imported_in_database\": \"excels to be imported/\",\r\n \"path_to_new_opfiles\": \"DC BATCHES IN WORK/0 NEW/\",\r\n \"path_to_batches_unassigned\": \"DC BATCHES IN WORK/1 UNASSIGNED/\",\r\n \"path_to_batches_prepfiles\": \"DC BATCHES IN WORK/2 PREPARED FILES/\",\r\n \"path_to_batches_assigned\": \"DC BATCHES IN WORK/3 ASSIGNED/\",\r\n \"path_to_batches_tobechecked\": \"DC BATCHES IN WORK/4 TO BE CHECKED/\",\r\n \"path_to_batches_tbimported\": \"DC BATCHES IN WORK/5 TO BE IMPORTED/\",\r\n \"path_to_batches_finished\": \"DC BATCHES IN WORK/6 FINISHED/\",\r\n \"path_to_batches_instandby\": \"DC BATCHES IN WORK/7 IN STANDBY/\",\r\n \"path_to_batches_unrecordable\": \"DC BATCHES IN WORK/8 UNRECORDABLE/\",\r\n \"batch_status_options_responsible\": \"PREP. OP FILE, IMPORTATION & SPLIT FILE, RELIABILITY & DATA UPGRADE, CHECK OP FILE, CHECK SPLIT FILE, CHECK FRONT END, **TO BE CHECKED\",\r\n \"batch_status_options_proofreader\": \"OP FILE OK, SPLIT FILE OK, FRONT END OK, **TO BE IMPORTED, **FINISHED, **REWORK, **STANDBY, **UNRECORDABLE\",\r\n \"batch_status_options_overall\": \"ONGOING, STANDBY, FINISHED, UNRECORDABLE\",\r\n \"aircrafts\": \"A300, A300-600, A310, A320, A330, A340, A350, A380\",\r\n \"split_batch_factor\": \"2, 3, 4, 5, 6, 7, 8, 9\",\r\n \"IDlentgh\": \"6\",\r\n \"port\": \"5000\"\r\n }\r\n \r\n if not os.path.isfile(os.path.join(self.cwd, \"config.json\")):\r\n self.func.write_json(config_data, self.cwd, fname=\"config.json\")","def configure(self) -> None:","def _get_MindtPy_OA_config():\n CONFIG = ConfigBlock('MindtPy-OA')\n\n _add_common_configs(CONFIG)\n _add_oa_configs(CONFIG)\n _add_roa_configs(CONFIG)\n _add_fp_configs(CONFIG)\n _add_oa_cuts_configs(CONFIG)\n _add_subsolver_configs(CONFIG)\n _add_tolerance_configs(CONFIG)\n _add_bound_configs(CONFIG)\n return CONFIG","def configs(self):\n yield \"singleimage\", build_config.BuildConfig()","def _configure(self):\n pass","def _add_roa_configs(CONFIG):\n CONFIG.declare(\n 'level_coef',\n ConfigValue(\n default=0.5,\n domain=PositiveFloat,\n description='The coefficient in the regularization main problem'\n 'represents how much the linear approximation of the MINLP problem is trusted.',\n ),\n )\n CONFIG.declare(\n 'solution_limit',\n ConfigValue(\n default=10,\n domain=PositiveInt,\n description='The solution limit for the regularization problem since it does not need to be solved to optimality.',\n ),\n )\n CONFIG.declare(\n 'reduce_level_coef',\n ConfigValue(\n default=False,\n description='Whether to reduce level coefficient in ROA single tree when regularization problem is infeasible.',\n domain=bool,\n ),\n )\n CONFIG.declare(\n 'use_bb_tree_incumbent',\n ConfigValue(\n default=False,\n description='Whether to use the incumbent solution of branch & bound tree in ROA single tree when regularization problem is infeasible.',\n domain=bool,\n ),\n )\n CONFIG.declare(\n 'sqp_lag_scaling_coef',\n ConfigValue(\n default='fixed',\n domain=In(['fixed', 'variable_dependent']),\n description='The coefficient used to scale the L2 norm in sqp_lag.',\n ),\n )","def _build_config() -> None:\n\n global CONFIGURATION\n\n configuration_common = {\n 'SERVICE_HOST': os.getenv('SERVICE_HOST', '0.0.0.0'),\n 'SERVICE_PORT': os.getenv('SERVICE_PORT', 8080),\n 'FILE_NAME': os.getenv('FILE_NAME', 'example'),\n }\n\n CONFIGURATION = {\n **configuration_common\n }","def default_configs(cls):\n config = super().default_configs()\n config.update(\n {\n \"entry_type\": \"ft.onto.base_ontology.Document\",\n \"model_name\": \"ktrapeznikov/biobert_v1.1_pubmed_squad_v2\",\n \"question\": \"Where do I live\",\n \"max_answer_len\": 15,\n \"cuda_devices\": -1,\n \"handle_impossible_answer\": False,\n }\n )\n return config","def _build_config() -> dict:\n d : dict = {}\n d['api'] = {}\n d['interval'] = FoobarExtensionBot.STD_INTERVAL\n d['api']['cmd_id'] = 'dummy'\n d['api']['client_id'] = input('client_id: ')\n d['api']['client_secret'] = input('client_secret: ')\n d['outtext'] = input('output_text: ')\n # build dummy bot to retrieve command info\n try:\n b : FoobarExtensionBot = FoobarExtensionBot(ExtensionConfig(**d))\n except InvalidTokenError:\n print('error: could not retrive access token with your given credentials')\n _exit()\n except NoReplaceTokenFoundError:\n print(f'error: there was no {FoobarExtensionBot.REPLACE_TOKEN} in your given output')\n _exit()\n # get commands and make user select\n cmds : list = b.get_custom_commands()\n cmd_id : int = cmds[_prompt_choice([c.command_name for c in cmds])].id\n # build and return config\n d['api']['cmd_id'] = cmd_id\n return d","def initialize_from_config(self):","def target_builder(self):\n return object_loader.get('target_builder')","def config():\n return Config()","def config():\n return Config()","def get_config_template(self) -> cconfig.Config:","def _GetVirtualEntityBuildingConfigBlock(\n self, entity: VirtualEntity\n ) -> Dict[str, object]:\n virtual_entity_yaml = {CONFIG_CODE: entity.code}\n virtual_entity_yaml.update(self._GetConnections(entity=entity))\n if entity.links:\n virtual_entity_yaml.update({CONFIG_LINKS: self._SortLinks(entity)})\n virtual_entity_yaml.update(\n {CONFIG_TYPE: entity.namespace + '/' + str(entity.type_name)}\n )\n return virtual_entity_yaml","def build():","def config_bot(self):\n # Return the config detail to API requests\n config_data = dict(SPARK_BOT_EMAIL=self.spark_bot_email,\n SPARK_BOT_TOKEN=\"--Redacted--\",\n SPARK_BOT_URL=self.spark_bot_url,\n SPARK_BOT_NAME=self.spark_bot_name)\n\n return json.dumps(config_data)","def config() -> Config:\n return Config()","def generate_config():\n\n return {\n \"email_subject\": DEFAULT_EMAIL_SUBJECT,\n \"from_email\": DEFAULT_FROM_EMAIL,\n \"to_email\": DEFAULT_TO_EMAIL,\n \"url\": DEFAULT_URL,\n \"start_value\": DEFAULT_START_VALUE,\n \"look_ahead\": DEFAULT_LOOK_AHEAD,\n \"slide_window\": DEFAULT_SLIDE_WINDOW,\n }","def configure(self, conf):\n return","def _build(self):","def _build(self):","def _configure_robot(self, builder: RobotComponentBuilder):\n super()._configure_robot(builder)","def init_config() -> Config:\n ...","def __init__(self, name, config):\n self.name = name\n self.config = config\n LineBuilder.__init__(self, name, config)\n \n etappg_name = '{0}EtaPPG'.format(name)\n eta3hr_name = '{0}Eta3HR'.format(name)\n eta3hm_name = '{0}Eta3HM'.format(name)\n \n d2pietappg_name = '{0}D2PiEtaPPG'.format(name)\n d2pieta3hr_name = '{0}D2PiEta3HR'.format(name)\n d2pieta3hm_name = '{0}D2PiEta3HM'.format(name)\n \n d2ketappg_name = '{0}D2KEtaPPG'.format(name)\n d2keta3hr_name = '{0}D2KEta3HR'.format(name)\n d2keta3hm_name = '{0}D2KEta3HM'.format(name)\n\n self.selEtaPPG = makeResonance(\n etappg_name,\n config,\n inputSel=[StdAllNoPIDsPions,StdLooseAllPhotons],\n decDescriptors=self.EtaPPG\n )\n\n self.selEta3HR = makeResonance(\n eta3hr_name,\n config,\n inputSel=[StdAllNoPIDsPions,StdLooseResolvedPi0],\n decDescriptors=self.Eta3H\n )\n\n self.selEta3HM = makeResonance(\n eta3hm_name,\n config,\n inputSel=[StdAllNoPIDsPions,StdLooseMergedPi0],\n decDescriptors=self.Eta3H\n )\n\n self.selD2PiEtaPPG = makeD(\n d2pietappg_name,\n config,\n inputSel=[self.selEtaPPG, StdAllNoPIDsPions],\n decDescriptors=self.D2PiEta,\n useBachelorPID=False,\n )\n\n self.selD2KEtaPPG = makeD(\n d2ketappg_name,\n config,\n inputSel=[self.selEtaPPG, StdAllNoPIDsKaons],\n decDescriptors=self.D2KEta,\n useBachelorPID=False,\n )\n \n self.selD2PiEta3HR = makeD(\n d2pieta3hr_name,\n config,\n inputSel=[self.selEta3HR, StdAllNoPIDsPions],\n decDescriptors=self.D2PiEta,\n useBachelorPID=False,\n )\n\n self.selD2KEta3HR = makeD(\n d2keta3hr_name,\n config,\n inputSel=[self.selEta3HR, StdAllNoPIDsKaons],\n decDescriptors=self.D2KEta,\n useBachelorPID=False,\n )\n \n self.selD2PiEta3HM = makeD(\n d2pieta3hm_name,\n config,\n inputSel=[self.selEta3HM, StdAllNoPIDsPions],\n decDescriptors=self.D2PiEta,\n useBachelorPID=False,\n )\n \n\n self.selD2KEta3HM = makeD(\n d2keta3hm_name,\n config,\n inputSel=[self.selEta3HM, StdAllNoPIDsKaons],\n decDescriptors=self.D2KEta,\n useBachelorPID=False,\n )\n \n\n self.line_D2PiEtaPPG = make_line(\n self,\n name='{0}Line'.format(d2pietappg_name),\n prescale=config['PrescaleD2PiEtaPPG'],\n postscale=config['PostscaleD2PiEtaPPG'],\n selection=self.selD2PiEtaPPG,\n HLT1=config['Hlt1Filter'],\n HLT2=config['Hlt2Filter']\n )\n\n self.line_D2PiEta3HM = make_line(\n self,\n name='{0}Line'.format(d2pieta3hm_name),\n prescale=config['PrescaleD2PiEta3HM'],\n postscale=config['PostscaleD2PiEta3HM'],\n selection=self.selD2PiEta3HM,\n HLT1=config['Hlt1Filter'],\n HLT2=config['Hlt2Filter']\n )\n\n self.line_D2PiEta3HR = make_line(\n self,\n name='{0}Line'.format(d2pieta3hr_name),\n prescale=config['PrescaleD2PiEta3HR'],\n postscale=config['PostscaleD2PiEta3HR'],\n selection=self.selD2PiEta3HR,\n HLT1=config['Hlt1Filter'],\n HLT2=config['Hlt2Filter']\n )\n\n self.line_D2KEtaPPG = make_line(\n self,\n name='{0}Line'.format(d2ketappg_name),\n prescale=config['PrescaleD2KEtaPPG'],\n postscale=config['PostscaleD2KEtaPPG'],\n selection=self.selD2KEtaPPG,\n HLT1=config['Hlt1Filter'],\n HLT2=config['Hlt2Filter']\n )\n \n self.line_D2KEta3HM = make_line(\n self,\n name='{0}Line'.format(d2keta3hm_name),\n prescale=config['PrescaleD2KEta3HM'],\n postscale=config['PostscaleD2KEta3HM'],\n selection=self.selD2KEta3HM,\n HLT1=config['Hlt1Filter'],\n HLT2=config['Hlt2Filter']\n )\n \n self.line_D2KEta3HR = make_line(\n self,\n name='{0}Line'.format(d2keta3hr_name),\n prescale=config['PrescaleD2KEta3HR'],\n postscale=config['PostscaleD2KEta3HR'],\n selection=self.selD2KEta3HR,\n HLT1=config['Hlt1Filter'],\n HLT2=config['Hlt2Filter']\n )","def __init__(self, name, config):\n self.name = name\n self.config = config\n LineBuilder.__init__(self, name, config)\n \n pi0eeg_name = '{0}Pi0EEG'.format(name)\n \n d2pipi0eeg_name = '{0}D2PiPi0EEG'.format(name) \n d2kpi0eeg_name = '{0}D2KPi0EEG'.format(name)\n\n d02pi0pi0eeg_name = '{0}D02Pi0Pi0EEG'.format(name) \n dst2d0pieeg_name = '{0}Dst2D0PiEEG'.format(name)\n\n self.selPi0EEG = makeEEGResonance(\n pi0eeg_name, \n config,\n inputSel=[StdLooseAllPhotons,StdDiElectronFromTracks],\n decDescriptors=self.Pi0EEG\n )\n \n self.selD2PiPi0EEG = makeD(\n d2pipi0eeg_name,\n config,\n inputSel=[self.selPi0EEG, StdAllNoPIDsPions],\n decDescriptors=self.D2PiPi0,\n useBachelorPID=False\n )\n\n usePIDforKaon = False\n if (config['Bachelor_PIDK_MIN'] > -10):\n usePIDforKaon = True\n else :\n usePIDforKaon = False\n \n self.selD2KPi0EEG = makeD(\n d2kpi0eeg_name, \n config,\n inputSel=[self.selPi0EEG, StdAllNoPIDsKaons],\n decDescriptors=self.D2KPi0,\n useBachelorPID=usePIDforKaon\n )\n\n self.selD02Pi0Pi0EEG = makeD(\n d02pi0pi0eeg_name, \n config,\n inputSel=[self.selPi0EEG],\n decDescriptors=self.D02Pi0Pi0,\n useBachelorPID=False,\n )\n\n self.selDst2D0PiEEG = makeDstar(\n dst2d0pieeg_name,\n config,\n inputSel=[self.selD02Pi0Pi0EEG, StdAllNoPIDsPions],\n decDescriptors=self.Dst2D0Pi,\n )\n\n self.line_D2PiPi0EEG = make_line(\n self,\n '{0}Line'.format(d2pipi0eeg_name),\n prescale=config['PrescaleD2PiPi0EEG'],\n postscale=config['PostscaleD2PiPi0EEG'],\n selection=self.selD2PiPi0EEG,\n HLT1=config['Hlt1Filter'],\n HLT2=config['Hlt2Filter']\n )\n\n self.line_D2KPi0EEG = make_line(\n self,\n '{0}Line'.format(d2kpi0eeg_name),\n prescale=config['PrescaleD2KPi0EEG'],\n postscale=config['PostscaleD2KPi0EEG'],\n selection=self.selD2KPi0EEG,\n HLT1=config['Hlt1Filter'],\n HLT2=config['Hlt2Filter']\n )\n \n self.line_Dst2D0PiEEG = make_line(\n self,\n '{0}Line'.format(dst2d0pieeg_name),\n prescale=config['PrescaleDst2D0PiEEG'],\n postscale=config['PostscaleDst2D0PiEEG'],\n selection=self.selDst2D0PiEEG,\n HLT1=config['Hlt1Filter'],\n HLT2=config['Hlt2Filter']\n )","def set_builder(self, builder: Builder):\n\t\tself.builder = builder","def config(self) -> NamedTuple:","def init_config(self):\n pass","def __init__(self, name, config):\n self.name = name\n self.config = config\n LineBuilder.__init__(self, name, config)\n \n etaeeg_name = '{0}EtaEEG'.format(name)\n \n d2pietaeeg_name = '{0}D2PiEtaEEG'.format(name) \n d2ketaeeg_name = '{0}D2KEtaEEG'.format(name)\n\n self.selEtaEEG = makeEEGResonance(\n etaeeg_name, \n config,\n inputSel=[StdLooseAllPhotons,StdDiElectronFromTracks],\n decDescriptors=self.EtaEEG\n )\n \n self.selD2PiEtaEEG = makeD(\n d2pietaeeg_name,\n config,\n inputSel=[self.selEtaEEG, StdAllNoPIDsPions],\n decDescriptors=self.D2PiEta,\n useBachelorPID=False\n )\n\n usePIDforKaon = False\n if (config['Bachelor_PIDK_MIN'] > -10):\n usePIDforKaon = True\n else :\n usePIDforKaon = False\n \n self.selD2KEtaEEG = makeD(\n d2ketaeeg_name, \n config,\n inputSel=[self.selEtaEEG, StdAllNoPIDsKaons],\n decDescriptors=self.D2KEta,\n useBachelorPID=usePIDforKaon\n )\n\n self.line_D2PiEtaEEG = make_line(\n self,\n '{0}Line'.format(d2pietaeeg_name),\n prescale=config['PrescaleD2PiEtaEEG'],\n postscale=config['PostscaleD2PiEtaEEG'],\n selection=self.selD2PiEtaEEG,\n HLT1=config['Hlt1Filter'],\n HLT2=config['Hlt2Filter']\n )\n\n self.line_D2KEtaEEG = make_line(\n self,\n '{0}Line'.format(d2ketaeeg_name),\n prescale=config['PrescaleD2KEtaEEG'],\n postscale=config['PostscaleD2KEtaEEG'],\n selection=self.selD2KEtaEEG,\n HLT1=config['Hlt1Filter'],\n HLT2=config['Hlt2Filter']\n )","def configure(self):\r\n pass","def config(self):\n return {}","def get_config():\n name = 'dynamic_pricing'\n num_products = 5\n scale = 1\n noise_var = 10\n p_max = 1\n\n agents = collections.OrderedDict(\n [('bsPricing',\n functools.partial(BootstrapDynamicPricing,\n num_products, scale, noise_var, p_max))]\n )\n\n environments = collections.OrderedDict(\n [('env',\n functools.partial(DynamicPricing,\n num_products, scale, noise_var, p_max))]\n )\n experiments = collections.OrderedDict(\n [(name, ExperimentNoAction)]\n )\n n_steps = 80\n n_seeds = 2000\n config = Config(name, agents, environments, experiments, n_steps, n_seeds)\n return config","def _get_MindtPy_config():\n CONFIG = ConfigBlock('MindtPy')\n\n _add_common_configs(CONFIG)\n _add_subsolver_configs(CONFIG)\n _add_tolerance_configs(CONFIG)\n _add_fp_configs(CONFIG)\n _add_bound_configs(CONFIG)\n _add_roa_configs(CONFIG)\n return CONFIG","def configure(self):\n pass","def configure(self):\n pass","def get_config(self, budget):\n\t\traise NotImplementedError('This function needs to be overwritten in %s.'%(self.__class__.__name__))","def _configure_addon(self):\n cfg = None\n try:\n data_dir = os.path.split(self.props.data_dir)\n\n cfg = Configuration(jobtype='Blender', \n data_path=data_dir[0],\n log_level=int(self.props.log_level),\n name=self.props.ini_file,\n datadir=data_dir[1])\n \n except (InvalidConfigException, IndexError) as exp:\n self.log.warning(\"Warning failed to load config file, \"\n \"creating new default config.\")\n self.log.warning(str(exp))\n \n finally:\n\n if not os.path.isdir(self.props.data_dir):\n raise EnvironmentError(\"Data directory not created - \"\n \"please ensure you have adequate permissions.\")\n\n if not cfg:\n cfg = Configuration(jobtype='Blender', log_level='warning')\n\n if self.props.endpoint:\n cfg = override_config(cfg, endpoint=self.props.endpoint)\n if self.props.account:\n cfg = override_config(cfg, account=self.props.account)\n if self.props.key:\n cfg = override_config(cfg, key=self.props.key)\n if self.props.client_id:\n cfg = override_config(cfg, client_id=self.props.client_id)\n if self.props.tenant:\n cfg = override_config(cfg, tenant=self.props.tenant)\n if self.props.redirect:\n cfg = override_config(cfg, redirect=self.props.redirect)\n\n cfg.save_config()\n return cfg","def getBuilderNames():","def config(ctx):\n return","def build(self) -> None:","def update_config_external_template(config):\r\n\r\n # best parameters from the paper\r\n config['train_batch_size'] = 16384\r\n config['lr'] = 3e-4\r\n config['sgd_minibatch_size'] = 4096\r\n config['num_sgd_iter'] = 4\r\n config['rollout_fragment_length'] = 100\r\n\r\n # run ID to communicate to the http trainer\r\n config['run_uid'] = '_setme'\r\n\r\n # stable baselines accepts full episodes\r\n config[\"batch_mode\"] = \"complete_episodes\"\r\n\r\n # stable baselines server address\r\n config[\"http_remote_port\"] = \"http://127.0.0.1:50001\"\r\n\r\n # no gpus, stable baselines might use them\r\n config['num_gpus'] = 0\r\n\r\n # set trainer class\r\n config['_trainer'] = \"External\"\r\n config['_policy'] = \"PPO\"\r\n\r\n # tuned\r\n config['num_envs_per_worker'] = 10\r\n config['num_workers'] = 3\r\n return config","def configure_for_pokered(config=config):\n attrs = {\n \"version\": \"red\",\n\n \"map_dir\": os.path.join(config.path, 'maps/'),\n \"gfx_dir\": os.path.join(config.path, 'gfx/tilesets/'),\n \"to_gfx_name\": red_gfx_name,\n \"block_dir\": os.path.join(config.path, 'gfx/blocksets/'), # not used\n \"block_ext\": '.bst', # not used\n\n \"palettes_on\": False,\n\n \"constants_filename\": os.path.join(config.path, 'constants.asm'),\n\n \"time_of_day\": 1,\n }\n return attrs","def config(self, **kw):\n self.cfg_fixture.config(**kw)","def set_builder_bot(self, builder_bot): \n self.builder_bot = builder_bot # pragma: no cover","def _generate_config(self, type, org, node):\n args = {}\n if type == \"peer\":\n args.update({\"peer_id\": \"{}.{}\".format(node, org)})\n args.update({\"peer_address\": \"{}.{}:{}\".format(node, org, 7051)})\n args.update(\n {\"peer_gossip_externalEndpoint\": \"{}.{}:{}\".format(node, org, 7051)})\n args.update(\n {\"peer_chaincodeAddress\": \"{}.{}:{}\".format(node, org, 7052)})\n args.update({\"peer_tls_enabled\": True})\n args.update({\"peer_localMspId\": \"{}MSP\".format(org.capitalize())})\n\n a = NodeConfig(org)\n a.peer(node, **args)\n else:\n args.update({\"General_ListenPort\": 7050})\n args.update(\n {\"General_LocalMSPID\": \"{}OrdererMSP\".format(org.capitalize())})\n args.update({\"General_TLS_Enabled\": True})\n args.update({\"General_BootstrapFile\": \"genesis.block\"})\n\n a = NodeConfig(org)\n a.orderer(node, **args)","def get_config_template(self) -> cconfig.Config:\n config = cconfig.get_config_from_nested_dict(\n {\n # Load prices.\n self._get_nid(\"rets/read_data\"): {\n \"frequency\": \"T\",\n \"start_date\": \"2010-01-04 09:00:00\",\n \"end_date\": \"2010-01-04 16:30:00\",\n \"ar_coeffs\": [0],\n \"ma_coeffs\": [0],\n \"scale\": 0.1,\n \"burnin\": 0,\n \"seed\": 0,\n },\n # Filter ATH.\n self._get_nid(\"rets/filter_ath\"): {\n \"col_mode\": \"replace_all\",\n \"transformer_kwargs\": {\n \"start_time\": datetime.time(9, 30),\n \"end_time\": datetime.time(16, 00),\n },\n },\n # Resample returns.\n self._get_nid(\"rets/resample\"): {\n \"rule\": \"1T\",\n \"price_cols\": [\"close\"],\n \"volume_cols\": [\"vol\"],\n },\n # Compute TWAP and VWAP.\n self._get_nid(\"rets/compute_wap\"): {\n \"rule\": \"5T\",\n \"price_col\": \"close\",\n \"volume_col\": \"vol\",\n },\n # Calculate rets.\n self._get_nid(\"rets/compute_ret_0\"): {\n \"cols\": [\"twap\", \"vwap\"],\n \"col_mode\": \"merge_all\",\n \"transformer_kwargs\": {\n \"mode\": \"pct_change\",\n },\n },\n # Model volatility.\n self._get_nid(\"rets/model_volatility\"): {\n \"cols\": [\"vwap_ret_0\"],\n \"steps_ahead\": 2,\n \"nan_mode\": \"leave_unchanged\",\n },\n # Clip rets.\n self._get_nid(\"rets/clip\"): {\n \"cols\": [\"vwap_ret_0_vol_adj\"],\n \"col_mode\": \"replace_selected\",\n },\n }\n )\n return config","def get_google_bigquery_job_config():\n job_config = bigquery.QueryJobConfig()\n job_config.maximum_bytes_billed = getattr(settings, 'OPR_GOOGLE_BIGQUERY_MAX_PROCESS_BYTES', None)\n job_config.use_query_cache = getattr(settings, 'OPR_GOOGLE_BIGQUERY_USE_CACHE', False)\n\n return job_config","def builder(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"builder\")","def get_config(self):\n config = {\n \"units\": self.units,\n \"activation\": activations.serialize(self.activation),\n \"recurrent_activation\": activations.serialize(\n self.recurrent_activation\n ),\n \"attention_activation\": activations.serialize(\n self.attention_activation\n ),\n \"use_bias\": self.use_bias,\n \"kernel_initializer\": initializers.serialize(self.kernel_initializer),\n \"recurrent_initializer\": initializers.serialize(\n self.recurrent_initializer\n ),\n \"bias_initializer\": initializers.serialize(self.bias_initializer),\n \"attention_initializer\": initializers.serialize(\n self.attention_initializer\n ),\n \"use_chrono_initialization\": self.unit_forget_bias,\n \"kernel_regularizer\": regularizers.serialize(self.kernel_regularizer),\n \"recurrent_regularizer\": regularizers.serialize(\n self.recurrent_regularizer\n ),\n \"bias_regularizer\": regularizers.serialize(self.bias_regularizer),\n \"activity_regularizer\": regularizers.serialize(\n self.activity_regularizer\n ),\n \"attention_regularizer\": regularizers.serialize(\n self.attention_regularizer\n ),\n \"kernel_constraint\": constraints.serialize(self.kernel_constraint),\n \"recurrent_constraint\": constraints.serialize(\n self.recurrent_constraint\n ),\n \"bias_constraint\": constraints.serialize(self.bias_constraint),\n \"attention_constraint\": constraints.serialize(\n self.attention_constraint\n ),\n \"dropout\": self.dropout,\n \"recurrent_dropout\": self.recurrent_dropout,\n \"return_attention\": self.return_attention,\n }\n base_config = super().get_config()\n del base_config[\"cell\"]\n return dict(list(base_config.items()) + list(config.items()))","def __init__(self, name, config):\n self.name = name\n self.config = config\n LineBuilder.__init__(self, name, config)\n \n etaprimeppg_name = '{0}EtaPrimePPG'.format(name)\n etaprime3hr_name = '{0}EtaPrime3HR'.format(name)\n \n d2pietaprimeppg_name = '{0}D2PiEtaPrimePPG'.format(name)\n d2pietaprime3hr_name = '{0}D2PiEtaPrime3HR'.format(name)\n \n d2ketaprimeppg_name = '{0}D2KEtaPrimePPG'.format(name)\n d2ketaprime3hr_name = '{0}D2KEtaPrime3HR'.format(name)\n \n self.selEtaPrimePPG = makeResonance(\n etaprimeppg_name,\n config,\n inputSel=[StdAllNoPIDsPions,StdLooseAllPhotons],\n decDescriptors=self.EtaPrimePPG\n )\n \n self.selEtaPrime3HR = makeResonance(\n etaprime3hr_name,\n config,\n inputSel=[StdAllNoPIDsPions,StdLooseResolvedEta],\n decDescriptors=self.EtaPrime3H\n )\n \n self.selD2PiEtaPrimePPG = makeD(\n d2pietaprimeppg_name,\n config,\n inputSel=[self.selEtaPrimePPG, StdAllNoPIDsPions],\n decDescriptors=self.D2PiEtaPrime,\n useBachelorPID=False,\n )\n \n self.selD2KEtaPrimePPG = makeD(\n d2ketaprimeppg_name,\n config,\n inputSel=[self.selEtaPrimePPG, StdAllNoPIDsKaons],\n decDescriptors=self.D2KEtaPrime,\n useBachelorPID=False,\n )\n \n self.selD2PiEtaPrime3HR = makeD(\n d2pietaprime3hr_name,\n config,\n inputSel=[self.selEtaPrime3HR, StdAllNoPIDsPions],\n decDescriptors=self.D2PiEtaPrime,\n useBachelorPID=False, \n )\n \n self.selD2KEtaPrime3HR = makeD(\n d2ketaprime3hr_name,\n config,\n inputSel=[self.selEtaPrime3HR, StdAllNoPIDsKaons],\n decDescriptors=self.D2KEtaPrime,\n useBachelorPID=False,\n )\n \n self.line_D2PiEtaPrimePPG = make_line(\n self,\n name='{0}Line'.format(d2pietaprimeppg_name),\n prescale=config['PrescaleD2PiEtaPrimePPG'],\n postscale=config['PostscaleD2PiEtaPrimePPG'],\n selection=self.selD2PiEtaPrimePPG,\n HLT1=config['Hlt1Filter'],\n HLT2=config['Hlt2Filter']\n )\n \n self.line_D2PiEtaPrime3HR = make_line(\n self,\n name='{0}Line'.format(d2pietaprime3hr_name),\n prescale=config['PrescaleD2PiEtaPrime3HR'],\n postscale=config['PostscaleD2PiEtaPrime3HR'],\n selection=self.selD2PiEtaPrime3HR,\n HLT1=config['Hlt1Filter'],\n HLT2=config['Hlt2Filter']\n )\n \n self.line_D2KEtaPrimePPG = make_line(\n self,\n name='{0}Line'.format(d2ketaprimeppg_name),\n prescale=config['PrescaleD2KEtaPrimePPG'],\n postscale=config['PostscaleD2KEtaPrimePPG'],\n selection=self.selD2KEtaPrimePPG,\n HLT1=config['Hlt1Filter'],\n HLT2=config['Hlt2Filter']\n )\n \n self.line_D2KEtaPrime3HR = make_line(\n self,\n name='{0}Line'.format(d2ketaprime3hr_name),\n prescale=config['PrescaleD2KEtaPrime3HR'],\n postscale=config['PostscaleD2KEtaPrime3HR'],\n selection=self.selD2KEtaPrime3HR,\n HLT1=config['Hlt1Filter'],\n HLT2=config['Hlt2Filter']\n )","def gclient_config(self):\n cfg = self.m.gclient.make_config()\n soln = cfg.solutions.add()\n soln.name = 'chromite'\n soln.url = self.chromite_url\n # Set the revision using 'bot_update' remote branch:revision notation.\n # Omitting the revision uses HEAD.\n soln.revision = '%s:' % (self.c.chromite_branch,)\n return cfg","def cg_config():\n return {}","def generate_config(context):\n\n enable_flow_logs = context.properties.get('enableFlowLogs', False)\n\n subnetwork_resource = {\n 'name': context.properties['resourceName'],\n 'type': 'gcp-types/compute-beta:subnetworks',\n 'properties': {\n # Required properties.\n 'name':\n context.properties['name'],\n 'network':\n context.properties['network'],\n 'ipCidrRange':\n context.properties['ipCidrRange'],\n 'region':\n context.properties['region'],\n 'project':\n context.properties['projectId'],\n\n # Optional properties, with defaults.\n 'enableFlowLogs':\n enable_flow_logs,\n 'privateIpGoogleAccess':\n context.properties.get('privateIpGoogleAccess', False),\n 'secondaryIpRanges':\n context.properties.get('secondaryIpRanges', []),\n }\n }\n \n if enable_flow_logs:\n # If flow logs are enabled, we want to adjust the default config in two ways:\n # (1) Increase the sampling ratio (defaults to 0.5) so we sample all traffic.\n # (2) Reduce the aggregation interval to 30 seconds (default is 5secs) to save on\n # storage.\n subnetwork_resource['properties']['logConfig'] = {\n 'aggregationInterval': 'INTERVAL_30_SEC',\n 'enable': True,\n 'flowSampling': 1.0,\n 'metadata': 'INCLUDE_ALL_METADATA',\n }\n\n # Pass the 'dependsOn' property to the subnetwork resource if present.\n if 'dependsOn' in context.properties:\n subnetwork_resource['metadata'] = {\n 'dependsOn': context.properties['dependsOn']\n }\n\n output = [\n {\n 'name': 'name',\n 'value': subnetwork_resource['name'],\n },\n {\n 'name': 'selfLink',\n 'value': '$(ref.{}.selfLink)'.format(subnetwork_resource['name']),\n },\n ]\n\n return {'resources': [subnetwork_resource], 'outputs': output}","def config_section_data():\n config_data = None\n\n config_data = u\"\"\"[fn_rate_limit]\n# MySQL Database settings\ndb_user = USER\ndb_password = PASSWORD\ndb_host = 127.0.0.1\ndb_port = 3306\ndatabase = Rate_limit\n\"\"\"\n return config_data","def configure(self):\n\n pass","def get_config(self):\n config = {\n 'multichannel': self._multichannel,\n 'complex_part': self._complex_part\n }\n base_config = super().get_config()\n return {**base_config, **config}","def config(self) -> \"AutomationConfig\":","def config(self) -> \"AutomationConfig\":","def generateConfig(run,subrun,conditions):\n \n configname = (conditions.numcdir + \"/\" + str(run) + \"/\" + str(subrun)\n + \"/numc_config_\" + str(run) + \"_\" + str(subrun) + \".cfg\")\n \n configContents = \"\"\n \n configContents += \"[software]\\n\"\n if conditions.oldneut:\n configContents += \"neut_setup_script = /project/t/tanaka/T2K/neut/branches/5.1.4.2_nd280_ROOTv5r34p09n01/src/neutgeom/setup.sh\\n\"\n elif conditions.newoldneut:\n configContents += \"neut_setup_script = /project/t/tanaka/T2K/neut/branches/5.1.4.3_nd280/src/neutgeom/setup.sh\\n\"\n else:\n #configContents += \"neut_setup_script = /project/t/tanaka/T2K/neut/branches/5.3.1_nd280/src/neutgeom/setup.sh\\n\"\n #configContents += \"neut_setup_script = /project/t/tanaka/T2K/neut/branches/5.3.1_nd280_wBBBA05/src/neutgeom/setup.sh\\n\"\n configContents += \"neut_setup_script = /project/t/tanaka/T2K/neut/branches/5.3.2_nd280/src/neutgeom/setup.sh\\n\"\n \n configContents += \"[geometry]\\n\"\n\n configContents += \"baseline = \" + conditions.geometry +\"\\n\"\n if conditions.waterair == \"water\":\n configContents += \"p0d_water_fill = 1\\n\"\n else:\n configContents += \"p0d_water_fill = 0\\n\"\n \n configContents += \"\"\"\n \n[configuration]\nmodule_list = neutMC\n\n[filenaming]\n\"\"\"\n configContents += \"comment = \" + conditions.comment + \"\\n\"\n configContents += \"run_number = \" + str(run) +\"\\n\"\n configContents += \"subrun = \" + str(subrun) + \"\\n\"\n\n if conditions.oldneut:\n configContents += \"\"\" \n\n[neutrino]\nneut_card = /project/t/tanaka/T2K/neut/branches/5.1.4.2_nd280_ROOTv5r34p09n01/src/neutgeom/neut.card\n\"\"\"\n elif conditions.newoldneut:\n configContents += \"\"\" \n\n[neutrino]\nneut_card = /project/t/tanaka/T2K/neut/branches/5.1.4.3_nd280/src/neutgeom/neut.card\n\"\"\"\n else:\n configContents += \"\"\" \n\n[neutrino]\nneut_card = /project/t/tanaka/T2K/neut/branches/5.3.2_nd280/src/neutgeom/neut.card\n\"\"\"\n\n configContents += \"flux_file = \" + conditions.ram_disk + \"/\" + conditions.flux_base + \"\\n\"\n\n#flux_file = flux_file\n#\"\"\"\n\n# configContents += \"flux_file_path = \" + conditions.ram_disk + \"/\" + conditions.flux_base\n\n# configContents += \"\"\" \n#flux_file_start = 1\n#flux_file_stop = 300\n#\"\"\"\n\n configContents += \"maxint_file = \" + conditions.maxint_file_local + \"\\n\"\n\n# default: 5e17 but for basket MC special production higher\n configContents += \"\"\" \npot = 5.0e17\nneutrino_type = beam\n\"\"\"\n if conditions.baskmagn == \"basket\":\n configContents += \"\"\" \nflux_region = basket\nmaster_volume = Basket \nrandom_start = 1\n\"\"\"\n elif conditions.baskmagn == \"magnet\":\n configContents += \"\"\" \nflux_region = magnet\nmaster_volume = Magnet \nrandom_start = 1\n\"\"\"\n else:\n print \"Unknown basket/magnet condition\"\n \n\n configContents += \"random_seed = \" + str(getRandom()) +\"\\n\"\n configContents += \"neut_seed1 = \" + str(getRandom())+\"\\n\" \n configContents += \"neut_seed2 = \" + str(getRandom())+\"\\n\" \n configContents += \"neut_seed3 = \" + str(getRandom())+\"\\n\" \n\n configContents += \"\\n\"\n configContents += \"[nd280mc]\\n\"\n configContents += \"mc_type=Neut_RooTracker \\n\"\n\n #print configContents\n\n try:\n macFile = open(configname,\"w\")\n macFile.write(configContents)\n \n except:\n print \"can't write config file\" \n \n\n return configname","def config(self) -> Dict[str, Any]:"],"string":"[\n \"def getBuilder():\",\n \"def buildersConf() :\\n return dict(_buildersConf)\",\n \"def getBuilder(name):\",\n \"def getBuilder(name):\",\n \"def build_configs():\",\n \"def build(config):\",\n \"def configure_bot(self, builders_dict, additional_configs=None):\\n additional_configs = additional_configs or []\\n\\n # TODO: crbug.com/358481 . The build_config should probably be a property\\n # passed in from the slave config, but that doesn't exist today, so we\\n # need a lookup mechanism to map bot name to build_config.\\n mastername = self.m.properties.get('mastername')\\n buildername = self.m.properties.get('buildername')\\n master_dict = builders_dict.get(mastername, {})\\n bot_config = master_dict.get('builders', {}).get(buildername)\\n\\n self.set_config(bot_config.get('chromium_config', 'chromium'),\\n **bot_config.get('chromium_config_kwargs', {}))\\n\\n for c in bot_config.get('chromium_apply_config', []):\\n self.apply_config(c)\\n\\n for c in additional_configs:\\n self.apply_config(c)\\n\\n # Note that we have to call gclient.set_config() and apply_config() *after*\\n # calling chromium.set_config(), above, because otherwise the chromium\\n # call would reset the gclient config to its defaults.\\n self.m.gclient.set_config(\\n 'chromium',\\n PATCH_PROJECT=self.m.properties.get('patch_project'))\\n for c in bot_config.get('gclient_apply_config', []):\\n self.m.gclient.apply_config(c)\\n\\n return (buildername, bot_config)\",\n \"def albu_builder(self, cfg):\\n assert isinstance(cfg, dict) and 'type' in cfg\\n args = cfg.copy()\\n obj_type = args.pop('type')\\n if mmcv.is_str(obj_type):\\n obj_cls = getattr(albumentations, obj_type)\\n else:\\n raise TypeError(f'type must be str, but got {type(obj_type)}')\\n if 'transforms' in args:\\n args['transforms'] = [\\n self.albu_builder(transform)\\n for transform in args['transforms']\\n ]\\n return obj_cls(**args)\",\n \"def build_config(self, config):\\n \\n config.setdefaults(\\n 'Network', {'IP': '192.168.1.16', 'port': 8000}\\n )\\n config.setdefaults(\\n 'Camera', {'ISO': 100, 'Shutter': 5000, 'Aperture': 4, 'Zoom': 45}\\n )\\n config.setdefaults(\\n 'Admin', {'Logging Path': gs.AUVSI_BASE_FOLDER}\\n )\\n config.setdefaults(\\n 'CV', {'image_rescaling': 0.25}\\n )\\n \\n #\\n # Disable multi touch emulation with the mouse.\\n #\\n from kivy.config import Config\\n Config.set('input', 'mouse', 'mouse,disable_multitouch')\",\n \"def create_config(self) -> None:\\n pass\",\n \"def create_config(self) -> None:\\n pass\",\n \"def build_configuration() -> Config:\\n logger.debug('Building configuration.')\\n config = Config(roman_url=sanitize_url(get_prop('ROMAN_URL')),\\n redis_url=get_prop('REDIS_URL'),\\n redis_port=int(get_prop('REDIS_PORT')),\\n redis_username=get_prop('REDIS_USERNAME', True),\\n redis_password=get_prop('REDIS_PASSWORD', True),\\n charon_url=sanitize_url(get_prop('CHARON_URL')))\\n logger.debug(f'Used configuration: {config}')\\n return config\",\n \"def config(cls) -> 'bittensor.Config':\\n parser = argparse.ArgumentParser()\\n wallet.add_args( parser )\\n return bittensor.config( parser )\",\n \"def albu_builder(self, cfg):\\n\\n assert isinstance(cfg, dict) and 'type' in cfg\\n args = cfg.copy()\\n\\n obj_type = args.pop('type')\\n if general_ocr.is_str(obj_type):\\n if albumentations is None:\\n raise RuntimeError('albumentations is not installed')\\n obj_cls = getattr(albumentations, obj_type)\\n elif inspect.isclass(obj_type):\\n obj_cls = obj_type\\n else:\\n raise TypeError(\\n f'type must be a str or valid type, but got {type(obj_type)}')\\n\\n if 'transforms' in args:\\n args['transforms'] = [\\n self.albu_builder(transform)\\n for transform in args['transforms']\\n ]\\n\\n return obj_cls(**args)\",\n \"def get_config_template() -> dict:\\n return {\\n VENE_PAYMENTS_BAMBORA_API_URL: (str, \\\"https://payform.bambora.com/pbwapi\\\"),\\n VENE_PAYMENTS_BAMBORA_API_KEY: str,\\n VENE_PAYMENTS_BAMBORA_API_SECRET: str,\\n VENE_PAYMENTS_BAMBORA_PAYMENT_METHODS: list,\\n }\",\n \"def config():\",\n \"def config():\",\n \"def configure(self, options, conf):\",\n \"def config(self):\\n pass\",\n \"def config(self):\\n pass\",\n \"def test_builder_config(code_builder: dataset_builder.DatasetBuilder):\\n if not code_builder.BUILDER_CONFIGS:\\n return\\n\\n # Remove the registered configs\\n with mock.patch.object(\\n type(code_builder), 'BUILDER_CONFIGS', []\\n ), mock.patch.object(type(code_builder), 'builder_configs', {}):\\n # Config isn't present in the code anymore\\n with pytest.raises(ValueError, match='BuilderConfig .* not found'):\\n load.builder(\\n f'{code_builder.name}/dummy_config', data_dir='/tmp/path/not-exists'\\n )\\n\\n # But previously generated configs still be loaded from disk\\n builder = load.builder(f'{code_builder.name}/dummy_config')\\n assert not isinstance(builder, type(code_builder))\\n assert isinstance(builder, read_only_builder.ReadOnlyBuilder)\",\n \"def config(self):\\n raise NotImplementedError\",\n \"def configuration():\",\n \"def config( **kwargs ):\",\n \"def vdk_configure(self, config_builder: ConfigurationBuilder) -> None:\\n # Plugin-related configurations\\n config_builder.add(\\n key=\\\"INGEST_METHOD_DEFAULT\\\",\\n default_value=None,\\n description=\\\"Default Ingestion method to be used.\\\",\\n )\\n config_builder.add(\\n key=\\\"INGEST_TARGET_DEFAULT\\\",\\n default_value=None,\\n description=\\\"Default Ingestion target to be used.\\\",\\n )\\n\\n # Configure ingestion specific environment variables\\n ingester_configuration.add_definitions(config_builder=config_builder)\",\n \"def configure(self):\",\n \"def configure(self):\",\n \"def configure(self):\",\n \"def configure(self):\",\n \"def build_configuration(\\n cls,\\n class_name,\\n module_name=\\\"great_expectations.datasource\\\",\\n data_asset_type=None,\\n batch_kwargs_generators=None,\\n **kwargs,\\n ):\\n verify_dynamic_loading_support(module_name=module_name)\\n class_ = load_class(class_name=class_name, module_name=module_name)\\n configuration = class_.build_configuration(\\n data_asset_type=data_asset_type,\\n batch_kwargs_generators=batch_kwargs_generators,\\n **kwargs,\\n )\\n return configuration\",\n \"def config_create():\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n global CONSUMER_KEY \\r\\n global CONSUMER_SECRET \\r\\n global ACCESS_KEY \\r\\n global ACCESS_SECRET\\r\\n global TweetBotName \\r\\n global StreamL \\r\\n global TweetL \\r\\n global NSFW \\r\\n global SFW \\r\\n global searchterm \\r\\n global tMax \\r\\n global tMin \\r\\n global tStep\\r\\n \\r\\n config = configparser.ConfigParser()\\r\\n with open('botconfig.ini', 'r') as configfile:\\r\\n config.read_file(configfile)\\r\\n CONSUMER_KEY = config.get('Auth', 'CONSUMER_KEY') \\r\\n CONSUMER_SECRET = config.get('Auth', 'CONSUMER_SECRET').encode('utf-8') \\r\\n ACCESS_KEY = config.get('Auth', 'ACCESS_KEY').encode('utf-8')\\r\\n ACCESS_SECRET = config.get('Auth', 'ACCESS_SECRET').encode('utf-8')\\r\\n TweetBotName = config.get('Auth', 'BotName')\\r\\n StreamL = config.get('Log', 'Log1')\\r\\n TweetL = config.get('Log', 'Log2')\\r\\n NSFW = config.get('Filter', 'String1')\\r\\n SFW = config.get('Filter', 'String2')\\r\\n searchterm = config.get('Filter', 'Search')\\r\\n tMax = int(float(config.get('Tweet_Delay', 'Max')))\\r\\n tMin = int(float(config.get('Tweet_Delay', 'Min')))\\r\\n tStep = int(float(config.get('Tweet_Delay', 'Step')))\\r\\n global api \\r\\n\\r\\n \\\"\\\"\\\"\\r\\n config = configparser.ConfigParser()\\r\\n with open('botconfig.ini', 'r') as configfile:\\r\\n config.readfp(configfile)\\r\\n return config\",\n \"def configs(self):\\n raise NotImplementedError()\",\n \"def generate(self):\\n\\t\\traise BuilderException(\\\"You can not use this class directly!\\\")\",\n \"def get_builder(self, request):\\n raise NotImplementedError()\",\n \"def build_trainer_config(config):\\r\\n # determining environment parameters\\r\\n env_fcn = config['_env_fcn']\\r\\n env = env_fcn(config['_env'])\\r\\n obs_space, act_space, n_policies = env.observation_space, env.action_space, env.n_policies\\r\\n env.close()\\r\\n\\r\\n policies = config['_get_policies'](config=config, n_policies=n_policies, obs_space=obs_space, act_space=act_space)\\r\\n select_policy = config['_select_policy']\\r\\n\\r\\n config = deepcopy(config)\\r\\n config['_all_policies'] = sorted(policies.keys())\\r\\n\\r\\n if config['_update_withpolicies'] and '_iteration' in config:\\r\\n config = config['_update_withpolicies'](config, iteration=config['_iteration'])\\r\\n\\r\\n config1 = deepcopy(config)\\r\\n config1['multiagent'] = {}\\r\\n config1['multiagent']['policies'] = policies\\r\\n\\r\\n for k in config['_train_policies']:\\r\\n assert k in policies.keys(), f\\\"Unknown policy {k} [range {policies.keys()}]\\\"\\r\\n\\r\\n rl_config = {\\r\\n \\\"env\\\": config['_env_name_rllib'],\\r\\n \\\"env_config\\\": config['_env'],\\r\\n \\\"multiagent\\\": {\\r\\n \\\"policies_to_train\\\": config['_train_policies'],\\r\\n \\\"policies\\\": policies,\\r\\n \\\"policy_mapping_fn\\\": partial(select_policy, config=config1),\\r\\n },\\r\\n 'tf_session_args': {'intra_op_parallelism_threads': config['_num_workers_tf'],\\r\\n 'inter_op_parallelism_threads': config['_num_workers_tf'],\\r\\n 'gpu_options': {'allow_growth': True},\\r\\n 'log_device_placement': True,\\r\\n 'device_count': {'CPU': config['_num_workers_tf']},\\r\\n 'allow_soft_placement': True\\r\\n },\\r\\n \\\"local_tf_session_args\\\": {\\r\\n \\\"intra_op_parallelism_threads\\\": config['_num_workers_tf'],\\r\\n \\\"inter_op_parallelism_threads\\\": config['_num_workers_tf'],\\r\\n },\\r\\n }\\r\\n\\r\\n # filling in the rest of variables\\r\\n for k, v in config.items():\\r\\n if k.startswith('_'): continue\\r\\n rl_config[k] = v\\r\\n\\r\\n if config.get('_verbose', True):\\r\\n print(\\\"Config:\\\")\\r\\n print(pretty_print(rl_config))\\r\\n\\r\\n if config['_trainer'] == 'External' and '_tmp_dir' in config:\\r\\n rl_config['tmp_dir'] = config['_tmp_dir']\\r\\n \\r\\n for key, val in rl_config.items():\\r\\n if isinstance(val, Domain):\\r\\n sampled_val = val.sample()\\r\\n rl_config[key] = sampled_val\\r\\n logging.warning(f\\\"Trainer got a ray.tune.sample for parameter {key}: {type(val)}({val}). Replacing it with a sampled value {sampled_val}\\\")\\r\\n\\r\\n return rl_config\",\n \"def config(self):\\n return None\",\n \"def config(self) -> InstrumentConfig:\\n ...\",\n \"def _generate_slave_config(project: PyfmuProject):\\n return project.project_configuration\",\n \"def dbt_config(self):\\n from dbt.config.runtime import RuntimeConfig as DbtRuntimeConfig\\n from dbt.adapters.factory import register_adapter\\n\\n self.dbt_config = DbtRuntimeConfig.from_args(\\n DbtConfigArgs(\\n project_dir=self._get_project_dir(),\\n profiles_dir=self._get_profiles_dir(),\\n profile=self._get_profile(),\\n )\\n )\\n register_adapter(self.dbt_config)\\n return self.dbt_config\",\n \"def configure(self, **cfg: Any) -> 'Self | None':\",\n \"def defaultconfig(self):\\r\\n\\r\\n config_data = {\\r\\n \\\"path_to_database\\\": \\\"FUDB/FOLLOWUP.DB\\\",\\r\\n \\\"path_to_frontend\\\": \\\"FUDB/\\\",\\r\\n \\\"path_to_dcs_info\\\": \\\"FUDB/\\\",\\r\\n \\\"path_to_bin\\\": \\\"bin/\\\",\\r\\n \\\"path_to_excels_exported_from_database\\\": \\\"excels exported/\\\",\\r\\n \\\"path_to_excels_to_be_imported_in_database\\\": \\\"excels to be imported/\\\",\\r\\n \\\"path_to_new_opfiles\\\": \\\"DC BATCHES IN WORK/0 NEW/\\\",\\r\\n \\\"path_to_batches_unassigned\\\": \\\"DC BATCHES IN WORK/1 UNASSIGNED/\\\",\\r\\n \\\"path_to_batches_prepfiles\\\": \\\"DC BATCHES IN WORK/2 PREPARED FILES/\\\",\\r\\n \\\"path_to_batches_assigned\\\": \\\"DC BATCHES IN WORK/3 ASSIGNED/\\\",\\r\\n \\\"path_to_batches_tobechecked\\\": \\\"DC BATCHES IN WORK/4 TO BE CHECKED/\\\",\\r\\n \\\"path_to_batches_tbimported\\\": \\\"DC BATCHES IN WORK/5 TO BE IMPORTED/\\\",\\r\\n \\\"path_to_batches_finished\\\": \\\"DC BATCHES IN WORK/6 FINISHED/\\\",\\r\\n \\\"path_to_batches_instandby\\\": \\\"DC BATCHES IN WORK/7 IN STANDBY/\\\",\\r\\n \\\"path_to_batches_unrecordable\\\": \\\"DC BATCHES IN WORK/8 UNRECORDABLE/\\\",\\r\\n \\\"batch_status_options_responsible\\\": \\\"PREP. OP FILE, IMPORTATION & SPLIT FILE, RELIABILITY & DATA UPGRADE, CHECK OP FILE, CHECK SPLIT FILE, CHECK FRONT END, **TO BE CHECKED\\\",\\r\\n \\\"batch_status_options_proofreader\\\": \\\"OP FILE OK, SPLIT FILE OK, FRONT END OK, **TO BE IMPORTED, **FINISHED, **REWORK, **STANDBY, **UNRECORDABLE\\\",\\r\\n \\\"batch_status_options_overall\\\": \\\"ONGOING, STANDBY, FINISHED, UNRECORDABLE\\\",\\r\\n \\\"aircrafts\\\": \\\"A300, A300-600, A310, A320, A330, A340, A350, A380\\\",\\r\\n \\\"split_batch_factor\\\": \\\"2, 3, 4, 5, 6, 7, 8, 9\\\",\\r\\n \\\"IDlentgh\\\": \\\"6\\\",\\r\\n \\\"port\\\": \\\"5000\\\"\\r\\n }\\r\\n \\r\\n if not os.path.isfile(os.path.join(self.cwd, \\\"config.json\\\")):\\r\\n self.func.write_json(config_data, self.cwd, fname=\\\"config.json\\\")\",\n \"def configure(self) -> None:\",\n \"def _get_MindtPy_OA_config():\\n CONFIG = ConfigBlock('MindtPy-OA')\\n\\n _add_common_configs(CONFIG)\\n _add_oa_configs(CONFIG)\\n _add_roa_configs(CONFIG)\\n _add_fp_configs(CONFIG)\\n _add_oa_cuts_configs(CONFIG)\\n _add_subsolver_configs(CONFIG)\\n _add_tolerance_configs(CONFIG)\\n _add_bound_configs(CONFIG)\\n return CONFIG\",\n \"def configs(self):\\n yield \\\"singleimage\\\", build_config.BuildConfig()\",\n \"def _configure(self):\\n pass\",\n \"def _add_roa_configs(CONFIG):\\n CONFIG.declare(\\n 'level_coef',\\n ConfigValue(\\n default=0.5,\\n domain=PositiveFloat,\\n description='The coefficient in the regularization main problem'\\n 'represents how much the linear approximation of the MINLP problem is trusted.',\\n ),\\n )\\n CONFIG.declare(\\n 'solution_limit',\\n ConfigValue(\\n default=10,\\n domain=PositiveInt,\\n description='The solution limit for the regularization problem since it does not need to be solved to optimality.',\\n ),\\n )\\n CONFIG.declare(\\n 'reduce_level_coef',\\n ConfigValue(\\n default=False,\\n description='Whether to reduce level coefficient in ROA single tree when regularization problem is infeasible.',\\n domain=bool,\\n ),\\n )\\n CONFIG.declare(\\n 'use_bb_tree_incumbent',\\n ConfigValue(\\n default=False,\\n description='Whether to use the incumbent solution of branch & bound tree in ROA single tree when regularization problem is infeasible.',\\n domain=bool,\\n ),\\n )\\n CONFIG.declare(\\n 'sqp_lag_scaling_coef',\\n ConfigValue(\\n default='fixed',\\n domain=In(['fixed', 'variable_dependent']),\\n description='The coefficient used to scale the L2 norm in sqp_lag.',\\n ),\\n )\",\n \"def _build_config() -> None:\\n\\n global CONFIGURATION\\n\\n configuration_common = {\\n 'SERVICE_HOST': os.getenv('SERVICE_HOST', '0.0.0.0'),\\n 'SERVICE_PORT': os.getenv('SERVICE_PORT', 8080),\\n 'FILE_NAME': os.getenv('FILE_NAME', 'example'),\\n }\\n\\n CONFIGURATION = {\\n **configuration_common\\n }\",\n \"def default_configs(cls):\\n config = super().default_configs()\\n config.update(\\n {\\n \\\"entry_type\\\": \\\"ft.onto.base_ontology.Document\\\",\\n \\\"model_name\\\": \\\"ktrapeznikov/biobert_v1.1_pubmed_squad_v2\\\",\\n \\\"question\\\": \\\"Where do I live\\\",\\n \\\"max_answer_len\\\": 15,\\n \\\"cuda_devices\\\": -1,\\n \\\"handle_impossible_answer\\\": False,\\n }\\n )\\n return config\",\n \"def _build_config() -> dict:\\n d : dict = {}\\n d['api'] = {}\\n d['interval'] = FoobarExtensionBot.STD_INTERVAL\\n d['api']['cmd_id'] = 'dummy'\\n d['api']['client_id'] = input('client_id: ')\\n d['api']['client_secret'] = input('client_secret: ')\\n d['outtext'] = input('output_text: ')\\n # build dummy bot to retrieve command info\\n try:\\n b : FoobarExtensionBot = FoobarExtensionBot(ExtensionConfig(**d))\\n except InvalidTokenError:\\n print('error: could not retrive access token with your given credentials')\\n _exit()\\n except NoReplaceTokenFoundError:\\n print(f'error: there was no {FoobarExtensionBot.REPLACE_TOKEN} in your given output')\\n _exit()\\n # get commands and make user select\\n cmds : list = b.get_custom_commands()\\n cmd_id : int = cmds[_prompt_choice([c.command_name for c in cmds])].id\\n # build and return config\\n d['api']['cmd_id'] = cmd_id\\n return d\",\n \"def initialize_from_config(self):\",\n \"def target_builder(self):\\n return object_loader.get('target_builder')\",\n \"def config():\\n return Config()\",\n \"def config():\\n return Config()\",\n \"def get_config_template(self) -> cconfig.Config:\",\n \"def _GetVirtualEntityBuildingConfigBlock(\\n self, entity: VirtualEntity\\n ) -> Dict[str, object]:\\n virtual_entity_yaml = {CONFIG_CODE: entity.code}\\n virtual_entity_yaml.update(self._GetConnections(entity=entity))\\n if entity.links:\\n virtual_entity_yaml.update({CONFIG_LINKS: self._SortLinks(entity)})\\n virtual_entity_yaml.update(\\n {CONFIG_TYPE: entity.namespace + '/' + str(entity.type_name)}\\n )\\n return virtual_entity_yaml\",\n \"def build():\",\n \"def config_bot(self):\\n # Return the config detail to API requests\\n config_data = dict(SPARK_BOT_EMAIL=self.spark_bot_email,\\n SPARK_BOT_TOKEN=\\\"--Redacted--\\\",\\n SPARK_BOT_URL=self.spark_bot_url,\\n SPARK_BOT_NAME=self.spark_bot_name)\\n\\n return json.dumps(config_data)\",\n \"def config() -> Config:\\n return Config()\",\n \"def generate_config():\\n\\n return {\\n \\\"email_subject\\\": DEFAULT_EMAIL_SUBJECT,\\n \\\"from_email\\\": DEFAULT_FROM_EMAIL,\\n \\\"to_email\\\": DEFAULT_TO_EMAIL,\\n \\\"url\\\": DEFAULT_URL,\\n \\\"start_value\\\": DEFAULT_START_VALUE,\\n \\\"look_ahead\\\": DEFAULT_LOOK_AHEAD,\\n \\\"slide_window\\\": DEFAULT_SLIDE_WINDOW,\\n }\",\n \"def configure(self, conf):\\n return\",\n \"def _build(self):\",\n \"def _build(self):\",\n \"def _configure_robot(self, builder: RobotComponentBuilder):\\n super()._configure_robot(builder)\",\n \"def init_config() -> Config:\\n ...\",\n \"def __init__(self, name, config):\\n self.name = name\\n self.config = config\\n LineBuilder.__init__(self, name, config)\\n \\n etappg_name = '{0}EtaPPG'.format(name)\\n eta3hr_name = '{0}Eta3HR'.format(name)\\n eta3hm_name = '{0}Eta3HM'.format(name)\\n \\n d2pietappg_name = '{0}D2PiEtaPPG'.format(name)\\n d2pieta3hr_name = '{0}D2PiEta3HR'.format(name)\\n d2pieta3hm_name = '{0}D2PiEta3HM'.format(name)\\n \\n d2ketappg_name = '{0}D2KEtaPPG'.format(name)\\n d2keta3hr_name = '{0}D2KEta3HR'.format(name)\\n d2keta3hm_name = '{0}D2KEta3HM'.format(name)\\n\\n self.selEtaPPG = makeResonance(\\n etappg_name,\\n config,\\n inputSel=[StdAllNoPIDsPions,StdLooseAllPhotons],\\n decDescriptors=self.EtaPPG\\n )\\n\\n self.selEta3HR = makeResonance(\\n eta3hr_name,\\n config,\\n inputSel=[StdAllNoPIDsPions,StdLooseResolvedPi0],\\n decDescriptors=self.Eta3H\\n )\\n\\n self.selEta3HM = makeResonance(\\n eta3hm_name,\\n config,\\n inputSel=[StdAllNoPIDsPions,StdLooseMergedPi0],\\n decDescriptors=self.Eta3H\\n )\\n\\n self.selD2PiEtaPPG = makeD(\\n d2pietappg_name,\\n config,\\n inputSel=[self.selEtaPPG, StdAllNoPIDsPions],\\n decDescriptors=self.D2PiEta,\\n useBachelorPID=False,\\n )\\n\\n self.selD2KEtaPPG = makeD(\\n d2ketappg_name,\\n config,\\n inputSel=[self.selEtaPPG, StdAllNoPIDsKaons],\\n decDescriptors=self.D2KEta,\\n useBachelorPID=False,\\n )\\n \\n self.selD2PiEta3HR = makeD(\\n d2pieta3hr_name,\\n config,\\n inputSel=[self.selEta3HR, StdAllNoPIDsPions],\\n decDescriptors=self.D2PiEta,\\n useBachelorPID=False,\\n )\\n\\n self.selD2KEta3HR = makeD(\\n d2keta3hr_name,\\n config,\\n inputSel=[self.selEta3HR, StdAllNoPIDsKaons],\\n decDescriptors=self.D2KEta,\\n useBachelorPID=False,\\n )\\n \\n self.selD2PiEta3HM = makeD(\\n d2pieta3hm_name,\\n config,\\n inputSel=[self.selEta3HM, StdAllNoPIDsPions],\\n decDescriptors=self.D2PiEta,\\n useBachelorPID=False,\\n )\\n \\n\\n self.selD2KEta3HM = makeD(\\n d2keta3hm_name,\\n config,\\n inputSel=[self.selEta3HM, StdAllNoPIDsKaons],\\n decDescriptors=self.D2KEta,\\n useBachelorPID=False,\\n )\\n \\n\\n self.line_D2PiEtaPPG = make_line(\\n self,\\n name='{0}Line'.format(d2pietappg_name),\\n prescale=config['PrescaleD2PiEtaPPG'],\\n postscale=config['PostscaleD2PiEtaPPG'],\\n selection=self.selD2PiEtaPPG,\\n HLT1=config['Hlt1Filter'],\\n HLT2=config['Hlt2Filter']\\n )\\n\\n self.line_D2PiEta3HM = make_line(\\n self,\\n name='{0}Line'.format(d2pieta3hm_name),\\n prescale=config['PrescaleD2PiEta3HM'],\\n postscale=config['PostscaleD2PiEta3HM'],\\n selection=self.selD2PiEta3HM,\\n HLT1=config['Hlt1Filter'],\\n HLT2=config['Hlt2Filter']\\n )\\n\\n self.line_D2PiEta3HR = make_line(\\n self,\\n name='{0}Line'.format(d2pieta3hr_name),\\n prescale=config['PrescaleD2PiEta3HR'],\\n postscale=config['PostscaleD2PiEta3HR'],\\n selection=self.selD2PiEta3HR,\\n HLT1=config['Hlt1Filter'],\\n HLT2=config['Hlt2Filter']\\n )\\n\\n self.line_D2KEtaPPG = make_line(\\n self,\\n name='{0}Line'.format(d2ketappg_name),\\n prescale=config['PrescaleD2KEtaPPG'],\\n postscale=config['PostscaleD2KEtaPPG'],\\n selection=self.selD2KEtaPPG,\\n HLT1=config['Hlt1Filter'],\\n HLT2=config['Hlt2Filter']\\n )\\n \\n self.line_D2KEta3HM = make_line(\\n self,\\n name='{0}Line'.format(d2keta3hm_name),\\n prescale=config['PrescaleD2KEta3HM'],\\n postscale=config['PostscaleD2KEta3HM'],\\n selection=self.selD2KEta3HM,\\n HLT1=config['Hlt1Filter'],\\n HLT2=config['Hlt2Filter']\\n )\\n \\n self.line_D2KEta3HR = make_line(\\n self,\\n name='{0}Line'.format(d2keta3hr_name),\\n prescale=config['PrescaleD2KEta3HR'],\\n postscale=config['PostscaleD2KEta3HR'],\\n selection=self.selD2KEta3HR,\\n HLT1=config['Hlt1Filter'],\\n HLT2=config['Hlt2Filter']\\n )\",\n \"def __init__(self, name, config):\\n self.name = name\\n self.config = config\\n LineBuilder.__init__(self, name, config)\\n \\n pi0eeg_name = '{0}Pi0EEG'.format(name)\\n \\n d2pipi0eeg_name = '{0}D2PiPi0EEG'.format(name) \\n d2kpi0eeg_name = '{0}D2KPi0EEG'.format(name)\\n\\n d02pi0pi0eeg_name = '{0}D02Pi0Pi0EEG'.format(name) \\n dst2d0pieeg_name = '{0}Dst2D0PiEEG'.format(name)\\n\\n self.selPi0EEG = makeEEGResonance(\\n pi0eeg_name, \\n config,\\n inputSel=[StdLooseAllPhotons,StdDiElectronFromTracks],\\n decDescriptors=self.Pi0EEG\\n )\\n \\n self.selD2PiPi0EEG = makeD(\\n d2pipi0eeg_name,\\n config,\\n inputSel=[self.selPi0EEG, StdAllNoPIDsPions],\\n decDescriptors=self.D2PiPi0,\\n useBachelorPID=False\\n )\\n\\n usePIDforKaon = False\\n if (config['Bachelor_PIDK_MIN'] > -10):\\n usePIDforKaon = True\\n else :\\n usePIDforKaon = False\\n \\n self.selD2KPi0EEG = makeD(\\n d2kpi0eeg_name, \\n config,\\n inputSel=[self.selPi0EEG, StdAllNoPIDsKaons],\\n decDescriptors=self.D2KPi0,\\n useBachelorPID=usePIDforKaon\\n )\\n\\n self.selD02Pi0Pi0EEG = makeD(\\n d02pi0pi0eeg_name, \\n config,\\n inputSel=[self.selPi0EEG],\\n decDescriptors=self.D02Pi0Pi0,\\n useBachelorPID=False,\\n )\\n\\n self.selDst2D0PiEEG = makeDstar(\\n dst2d0pieeg_name,\\n config,\\n inputSel=[self.selD02Pi0Pi0EEG, StdAllNoPIDsPions],\\n decDescriptors=self.Dst2D0Pi,\\n )\\n\\n self.line_D2PiPi0EEG = make_line(\\n self,\\n '{0}Line'.format(d2pipi0eeg_name),\\n prescale=config['PrescaleD2PiPi0EEG'],\\n postscale=config['PostscaleD2PiPi0EEG'],\\n selection=self.selD2PiPi0EEG,\\n HLT1=config['Hlt1Filter'],\\n HLT2=config['Hlt2Filter']\\n )\\n\\n self.line_D2KPi0EEG = make_line(\\n self,\\n '{0}Line'.format(d2kpi0eeg_name),\\n prescale=config['PrescaleD2KPi0EEG'],\\n postscale=config['PostscaleD2KPi0EEG'],\\n selection=self.selD2KPi0EEG,\\n HLT1=config['Hlt1Filter'],\\n HLT2=config['Hlt2Filter']\\n )\\n \\n self.line_Dst2D0PiEEG = make_line(\\n self,\\n '{0}Line'.format(dst2d0pieeg_name),\\n prescale=config['PrescaleDst2D0PiEEG'],\\n postscale=config['PostscaleDst2D0PiEEG'],\\n selection=self.selDst2D0PiEEG,\\n HLT1=config['Hlt1Filter'],\\n HLT2=config['Hlt2Filter']\\n )\",\n \"def set_builder(self, builder: Builder):\\n\\t\\tself.builder = builder\",\n \"def config(self) -> NamedTuple:\",\n \"def init_config(self):\\n pass\",\n \"def __init__(self, name, config):\\n self.name = name\\n self.config = config\\n LineBuilder.__init__(self, name, config)\\n \\n etaeeg_name = '{0}EtaEEG'.format(name)\\n \\n d2pietaeeg_name = '{0}D2PiEtaEEG'.format(name) \\n d2ketaeeg_name = '{0}D2KEtaEEG'.format(name)\\n\\n self.selEtaEEG = makeEEGResonance(\\n etaeeg_name, \\n config,\\n inputSel=[StdLooseAllPhotons,StdDiElectronFromTracks],\\n decDescriptors=self.EtaEEG\\n )\\n \\n self.selD2PiEtaEEG = makeD(\\n d2pietaeeg_name,\\n config,\\n inputSel=[self.selEtaEEG, StdAllNoPIDsPions],\\n decDescriptors=self.D2PiEta,\\n useBachelorPID=False\\n )\\n\\n usePIDforKaon = False\\n if (config['Bachelor_PIDK_MIN'] > -10):\\n usePIDforKaon = True\\n else :\\n usePIDforKaon = False\\n \\n self.selD2KEtaEEG = makeD(\\n d2ketaeeg_name, \\n config,\\n inputSel=[self.selEtaEEG, StdAllNoPIDsKaons],\\n decDescriptors=self.D2KEta,\\n useBachelorPID=usePIDforKaon\\n )\\n\\n self.line_D2PiEtaEEG = make_line(\\n self,\\n '{0}Line'.format(d2pietaeeg_name),\\n prescale=config['PrescaleD2PiEtaEEG'],\\n postscale=config['PostscaleD2PiEtaEEG'],\\n selection=self.selD2PiEtaEEG,\\n HLT1=config['Hlt1Filter'],\\n HLT2=config['Hlt2Filter']\\n )\\n\\n self.line_D2KEtaEEG = make_line(\\n self,\\n '{0}Line'.format(d2ketaeeg_name),\\n prescale=config['PrescaleD2KEtaEEG'],\\n postscale=config['PostscaleD2KEtaEEG'],\\n selection=self.selD2KEtaEEG,\\n HLT1=config['Hlt1Filter'],\\n HLT2=config['Hlt2Filter']\\n )\",\n \"def configure(self):\\r\\n pass\",\n \"def config(self):\\n return {}\",\n \"def get_config():\\n name = 'dynamic_pricing'\\n num_products = 5\\n scale = 1\\n noise_var = 10\\n p_max = 1\\n\\n agents = collections.OrderedDict(\\n [('bsPricing',\\n functools.partial(BootstrapDynamicPricing,\\n num_products, scale, noise_var, p_max))]\\n )\\n\\n environments = collections.OrderedDict(\\n [('env',\\n functools.partial(DynamicPricing,\\n num_products, scale, noise_var, p_max))]\\n )\\n experiments = collections.OrderedDict(\\n [(name, ExperimentNoAction)]\\n )\\n n_steps = 80\\n n_seeds = 2000\\n config = Config(name, agents, environments, experiments, n_steps, n_seeds)\\n return config\",\n \"def _get_MindtPy_config():\\n CONFIG = ConfigBlock('MindtPy')\\n\\n _add_common_configs(CONFIG)\\n _add_subsolver_configs(CONFIG)\\n _add_tolerance_configs(CONFIG)\\n _add_fp_configs(CONFIG)\\n _add_bound_configs(CONFIG)\\n _add_roa_configs(CONFIG)\\n return CONFIG\",\n \"def configure(self):\\n pass\",\n \"def configure(self):\\n pass\",\n \"def get_config(self, budget):\\n\\t\\traise NotImplementedError('This function needs to be overwritten in %s.'%(self.__class__.__name__))\",\n \"def _configure_addon(self):\\n cfg = None\\n try:\\n data_dir = os.path.split(self.props.data_dir)\\n\\n cfg = Configuration(jobtype='Blender', \\n data_path=data_dir[0],\\n log_level=int(self.props.log_level),\\n name=self.props.ini_file,\\n datadir=data_dir[1])\\n \\n except (InvalidConfigException, IndexError) as exp:\\n self.log.warning(\\\"Warning failed to load config file, \\\"\\n \\\"creating new default config.\\\")\\n self.log.warning(str(exp))\\n \\n finally:\\n\\n if not os.path.isdir(self.props.data_dir):\\n raise EnvironmentError(\\\"Data directory not created - \\\"\\n \\\"please ensure you have adequate permissions.\\\")\\n\\n if not cfg:\\n cfg = Configuration(jobtype='Blender', log_level='warning')\\n\\n if self.props.endpoint:\\n cfg = override_config(cfg, endpoint=self.props.endpoint)\\n if self.props.account:\\n cfg = override_config(cfg, account=self.props.account)\\n if self.props.key:\\n cfg = override_config(cfg, key=self.props.key)\\n if self.props.client_id:\\n cfg = override_config(cfg, client_id=self.props.client_id)\\n if self.props.tenant:\\n cfg = override_config(cfg, tenant=self.props.tenant)\\n if self.props.redirect:\\n cfg = override_config(cfg, redirect=self.props.redirect)\\n\\n cfg.save_config()\\n return cfg\",\n \"def getBuilderNames():\",\n \"def config(ctx):\\n return\",\n \"def build(self) -> None:\",\n \"def update_config_external_template(config):\\r\\n\\r\\n # best parameters from the paper\\r\\n config['train_batch_size'] = 16384\\r\\n config['lr'] = 3e-4\\r\\n config['sgd_minibatch_size'] = 4096\\r\\n config['num_sgd_iter'] = 4\\r\\n config['rollout_fragment_length'] = 100\\r\\n\\r\\n # run ID to communicate to the http trainer\\r\\n config['run_uid'] = '_setme'\\r\\n\\r\\n # stable baselines accepts full episodes\\r\\n config[\\\"batch_mode\\\"] = \\\"complete_episodes\\\"\\r\\n\\r\\n # stable baselines server address\\r\\n config[\\\"http_remote_port\\\"] = \\\"http://127.0.0.1:50001\\\"\\r\\n\\r\\n # no gpus, stable baselines might use them\\r\\n config['num_gpus'] = 0\\r\\n\\r\\n # set trainer class\\r\\n config['_trainer'] = \\\"External\\\"\\r\\n config['_policy'] = \\\"PPO\\\"\\r\\n\\r\\n # tuned\\r\\n config['num_envs_per_worker'] = 10\\r\\n config['num_workers'] = 3\\r\\n return config\",\n \"def configure_for_pokered(config=config):\\n attrs = {\\n \\\"version\\\": \\\"red\\\",\\n\\n \\\"map_dir\\\": os.path.join(config.path, 'maps/'),\\n \\\"gfx_dir\\\": os.path.join(config.path, 'gfx/tilesets/'),\\n \\\"to_gfx_name\\\": red_gfx_name,\\n \\\"block_dir\\\": os.path.join(config.path, 'gfx/blocksets/'), # not used\\n \\\"block_ext\\\": '.bst', # not used\\n\\n \\\"palettes_on\\\": False,\\n\\n \\\"constants_filename\\\": os.path.join(config.path, 'constants.asm'),\\n\\n \\\"time_of_day\\\": 1,\\n }\\n return attrs\",\n \"def config(self, **kw):\\n self.cfg_fixture.config(**kw)\",\n \"def set_builder_bot(self, builder_bot): \\n self.builder_bot = builder_bot # pragma: no cover\",\n \"def _generate_config(self, type, org, node):\\n args = {}\\n if type == \\\"peer\\\":\\n args.update({\\\"peer_id\\\": \\\"{}.{}\\\".format(node, org)})\\n args.update({\\\"peer_address\\\": \\\"{}.{}:{}\\\".format(node, org, 7051)})\\n args.update(\\n {\\\"peer_gossip_externalEndpoint\\\": \\\"{}.{}:{}\\\".format(node, org, 7051)})\\n args.update(\\n {\\\"peer_chaincodeAddress\\\": \\\"{}.{}:{}\\\".format(node, org, 7052)})\\n args.update({\\\"peer_tls_enabled\\\": True})\\n args.update({\\\"peer_localMspId\\\": \\\"{}MSP\\\".format(org.capitalize())})\\n\\n a = NodeConfig(org)\\n a.peer(node, **args)\\n else:\\n args.update({\\\"General_ListenPort\\\": 7050})\\n args.update(\\n {\\\"General_LocalMSPID\\\": \\\"{}OrdererMSP\\\".format(org.capitalize())})\\n args.update({\\\"General_TLS_Enabled\\\": True})\\n args.update({\\\"General_BootstrapFile\\\": \\\"genesis.block\\\"})\\n\\n a = NodeConfig(org)\\n a.orderer(node, **args)\",\n \"def get_config_template(self) -> cconfig.Config:\\n config = cconfig.get_config_from_nested_dict(\\n {\\n # Load prices.\\n self._get_nid(\\\"rets/read_data\\\"): {\\n \\\"frequency\\\": \\\"T\\\",\\n \\\"start_date\\\": \\\"2010-01-04 09:00:00\\\",\\n \\\"end_date\\\": \\\"2010-01-04 16:30:00\\\",\\n \\\"ar_coeffs\\\": [0],\\n \\\"ma_coeffs\\\": [0],\\n \\\"scale\\\": 0.1,\\n \\\"burnin\\\": 0,\\n \\\"seed\\\": 0,\\n },\\n # Filter ATH.\\n self._get_nid(\\\"rets/filter_ath\\\"): {\\n \\\"col_mode\\\": \\\"replace_all\\\",\\n \\\"transformer_kwargs\\\": {\\n \\\"start_time\\\": datetime.time(9, 30),\\n \\\"end_time\\\": datetime.time(16, 00),\\n },\\n },\\n # Resample returns.\\n self._get_nid(\\\"rets/resample\\\"): {\\n \\\"rule\\\": \\\"1T\\\",\\n \\\"price_cols\\\": [\\\"close\\\"],\\n \\\"volume_cols\\\": [\\\"vol\\\"],\\n },\\n # Compute TWAP and VWAP.\\n self._get_nid(\\\"rets/compute_wap\\\"): {\\n \\\"rule\\\": \\\"5T\\\",\\n \\\"price_col\\\": \\\"close\\\",\\n \\\"volume_col\\\": \\\"vol\\\",\\n },\\n # Calculate rets.\\n self._get_nid(\\\"rets/compute_ret_0\\\"): {\\n \\\"cols\\\": [\\\"twap\\\", \\\"vwap\\\"],\\n \\\"col_mode\\\": \\\"merge_all\\\",\\n \\\"transformer_kwargs\\\": {\\n \\\"mode\\\": \\\"pct_change\\\",\\n },\\n },\\n # Model volatility.\\n self._get_nid(\\\"rets/model_volatility\\\"): {\\n \\\"cols\\\": [\\\"vwap_ret_0\\\"],\\n \\\"steps_ahead\\\": 2,\\n \\\"nan_mode\\\": \\\"leave_unchanged\\\",\\n },\\n # Clip rets.\\n self._get_nid(\\\"rets/clip\\\"): {\\n \\\"cols\\\": [\\\"vwap_ret_0_vol_adj\\\"],\\n \\\"col_mode\\\": \\\"replace_selected\\\",\\n },\\n }\\n )\\n return config\",\n \"def get_google_bigquery_job_config():\\n job_config = bigquery.QueryJobConfig()\\n job_config.maximum_bytes_billed = getattr(settings, 'OPR_GOOGLE_BIGQUERY_MAX_PROCESS_BYTES', None)\\n job_config.use_query_cache = getattr(settings, 'OPR_GOOGLE_BIGQUERY_USE_CACHE', False)\\n\\n return job_config\",\n \"def builder(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"builder\\\")\",\n \"def get_config(self):\\n config = {\\n \\\"units\\\": self.units,\\n \\\"activation\\\": activations.serialize(self.activation),\\n \\\"recurrent_activation\\\": activations.serialize(\\n self.recurrent_activation\\n ),\\n \\\"attention_activation\\\": activations.serialize(\\n self.attention_activation\\n ),\\n \\\"use_bias\\\": self.use_bias,\\n \\\"kernel_initializer\\\": initializers.serialize(self.kernel_initializer),\\n \\\"recurrent_initializer\\\": initializers.serialize(\\n self.recurrent_initializer\\n ),\\n \\\"bias_initializer\\\": initializers.serialize(self.bias_initializer),\\n \\\"attention_initializer\\\": initializers.serialize(\\n self.attention_initializer\\n ),\\n \\\"use_chrono_initialization\\\": self.unit_forget_bias,\\n \\\"kernel_regularizer\\\": regularizers.serialize(self.kernel_regularizer),\\n \\\"recurrent_regularizer\\\": regularizers.serialize(\\n self.recurrent_regularizer\\n ),\\n \\\"bias_regularizer\\\": regularizers.serialize(self.bias_regularizer),\\n \\\"activity_regularizer\\\": regularizers.serialize(\\n self.activity_regularizer\\n ),\\n \\\"attention_regularizer\\\": regularizers.serialize(\\n self.attention_regularizer\\n ),\\n \\\"kernel_constraint\\\": constraints.serialize(self.kernel_constraint),\\n \\\"recurrent_constraint\\\": constraints.serialize(\\n self.recurrent_constraint\\n ),\\n \\\"bias_constraint\\\": constraints.serialize(self.bias_constraint),\\n \\\"attention_constraint\\\": constraints.serialize(\\n self.attention_constraint\\n ),\\n \\\"dropout\\\": self.dropout,\\n \\\"recurrent_dropout\\\": self.recurrent_dropout,\\n \\\"return_attention\\\": self.return_attention,\\n }\\n base_config = super().get_config()\\n del base_config[\\\"cell\\\"]\\n return dict(list(base_config.items()) + list(config.items()))\",\n \"def __init__(self, name, config):\\n self.name = name\\n self.config = config\\n LineBuilder.__init__(self, name, config)\\n \\n etaprimeppg_name = '{0}EtaPrimePPG'.format(name)\\n etaprime3hr_name = '{0}EtaPrime3HR'.format(name)\\n \\n d2pietaprimeppg_name = '{0}D2PiEtaPrimePPG'.format(name)\\n d2pietaprime3hr_name = '{0}D2PiEtaPrime3HR'.format(name)\\n \\n d2ketaprimeppg_name = '{0}D2KEtaPrimePPG'.format(name)\\n d2ketaprime3hr_name = '{0}D2KEtaPrime3HR'.format(name)\\n \\n self.selEtaPrimePPG = makeResonance(\\n etaprimeppg_name,\\n config,\\n inputSel=[StdAllNoPIDsPions,StdLooseAllPhotons],\\n decDescriptors=self.EtaPrimePPG\\n )\\n \\n self.selEtaPrime3HR = makeResonance(\\n etaprime3hr_name,\\n config,\\n inputSel=[StdAllNoPIDsPions,StdLooseResolvedEta],\\n decDescriptors=self.EtaPrime3H\\n )\\n \\n self.selD2PiEtaPrimePPG = makeD(\\n d2pietaprimeppg_name,\\n config,\\n inputSel=[self.selEtaPrimePPG, StdAllNoPIDsPions],\\n decDescriptors=self.D2PiEtaPrime,\\n useBachelorPID=False,\\n )\\n \\n self.selD2KEtaPrimePPG = makeD(\\n d2ketaprimeppg_name,\\n config,\\n inputSel=[self.selEtaPrimePPG, StdAllNoPIDsKaons],\\n decDescriptors=self.D2KEtaPrime,\\n useBachelorPID=False,\\n )\\n \\n self.selD2PiEtaPrime3HR = makeD(\\n d2pietaprime3hr_name,\\n config,\\n inputSel=[self.selEtaPrime3HR, StdAllNoPIDsPions],\\n decDescriptors=self.D2PiEtaPrime,\\n useBachelorPID=False, \\n )\\n \\n self.selD2KEtaPrime3HR = makeD(\\n d2ketaprime3hr_name,\\n config,\\n inputSel=[self.selEtaPrime3HR, StdAllNoPIDsKaons],\\n decDescriptors=self.D2KEtaPrime,\\n useBachelorPID=False,\\n )\\n \\n self.line_D2PiEtaPrimePPG = make_line(\\n self,\\n name='{0}Line'.format(d2pietaprimeppg_name),\\n prescale=config['PrescaleD2PiEtaPrimePPG'],\\n postscale=config['PostscaleD2PiEtaPrimePPG'],\\n selection=self.selD2PiEtaPrimePPG,\\n HLT1=config['Hlt1Filter'],\\n HLT2=config['Hlt2Filter']\\n )\\n \\n self.line_D2PiEtaPrime3HR = make_line(\\n self,\\n name='{0}Line'.format(d2pietaprime3hr_name),\\n prescale=config['PrescaleD2PiEtaPrime3HR'],\\n postscale=config['PostscaleD2PiEtaPrime3HR'],\\n selection=self.selD2PiEtaPrime3HR,\\n HLT1=config['Hlt1Filter'],\\n HLT2=config['Hlt2Filter']\\n )\\n \\n self.line_D2KEtaPrimePPG = make_line(\\n self,\\n name='{0}Line'.format(d2ketaprimeppg_name),\\n prescale=config['PrescaleD2KEtaPrimePPG'],\\n postscale=config['PostscaleD2KEtaPrimePPG'],\\n selection=self.selD2KEtaPrimePPG,\\n HLT1=config['Hlt1Filter'],\\n HLT2=config['Hlt2Filter']\\n )\\n \\n self.line_D2KEtaPrime3HR = make_line(\\n self,\\n name='{0}Line'.format(d2ketaprime3hr_name),\\n prescale=config['PrescaleD2KEtaPrime3HR'],\\n postscale=config['PostscaleD2KEtaPrime3HR'],\\n selection=self.selD2KEtaPrime3HR,\\n HLT1=config['Hlt1Filter'],\\n HLT2=config['Hlt2Filter']\\n )\",\n \"def gclient_config(self):\\n cfg = self.m.gclient.make_config()\\n soln = cfg.solutions.add()\\n soln.name = 'chromite'\\n soln.url = self.chromite_url\\n # Set the revision using 'bot_update' remote branch:revision notation.\\n # Omitting the revision uses HEAD.\\n soln.revision = '%s:' % (self.c.chromite_branch,)\\n return cfg\",\n \"def cg_config():\\n return {}\",\n \"def generate_config(context):\\n\\n enable_flow_logs = context.properties.get('enableFlowLogs', False)\\n\\n subnetwork_resource = {\\n 'name': context.properties['resourceName'],\\n 'type': 'gcp-types/compute-beta:subnetworks',\\n 'properties': {\\n # Required properties.\\n 'name':\\n context.properties['name'],\\n 'network':\\n context.properties['network'],\\n 'ipCidrRange':\\n context.properties['ipCidrRange'],\\n 'region':\\n context.properties['region'],\\n 'project':\\n context.properties['projectId'],\\n\\n # Optional properties, with defaults.\\n 'enableFlowLogs':\\n enable_flow_logs,\\n 'privateIpGoogleAccess':\\n context.properties.get('privateIpGoogleAccess', False),\\n 'secondaryIpRanges':\\n context.properties.get('secondaryIpRanges', []),\\n }\\n }\\n \\n if enable_flow_logs:\\n # If flow logs are enabled, we want to adjust the default config in two ways:\\n # (1) Increase the sampling ratio (defaults to 0.5) so we sample all traffic.\\n # (2) Reduce the aggregation interval to 30 seconds (default is 5secs) to save on\\n # storage.\\n subnetwork_resource['properties']['logConfig'] = {\\n 'aggregationInterval': 'INTERVAL_30_SEC',\\n 'enable': True,\\n 'flowSampling': 1.0,\\n 'metadata': 'INCLUDE_ALL_METADATA',\\n }\\n\\n # Pass the 'dependsOn' property to the subnetwork resource if present.\\n if 'dependsOn' in context.properties:\\n subnetwork_resource['metadata'] = {\\n 'dependsOn': context.properties['dependsOn']\\n }\\n\\n output = [\\n {\\n 'name': 'name',\\n 'value': subnetwork_resource['name'],\\n },\\n {\\n 'name': 'selfLink',\\n 'value': '$(ref.{}.selfLink)'.format(subnetwork_resource['name']),\\n },\\n ]\\n\\n return {'resources': [subnetwork_resource], 'outputs': output}\",\n \"def config_section_data():\\n config_data = None\\n\\n config_data = u\\\"\\\"\\\"[fn_rate_limit]\\n# MySQL Database settings\\ndb_user = USER\\ndb_password = PASSWORD\\ndb_host = 127.0.0.1\\ndb_port = 3306\\ndatabase = Rate_limit\\n\\\"\\\"\\\"\\n return config_data\",\n \"def configure(self):\\n\\n pass\",\n \"def get_config(self):\\n config = {\\n 'multichannel': self._multichannel,\\n 'complex_part': self._complex_part\\n }\\n base_config = super().get_config()\\n return {**base_config, **config}\",\n \"def config(self) -> \\\"AutomationConfig\\\":\",\n \"def config(self) -> \\\"AutomationConfig\\\":\",\n \"def generateConfig(run,subrun,conditions):\\n \\n configname = (conditions.numcdir + \\\"/\\\" + str(run) + \\\"/\\\" + str(subrun)\\n + \\\"/numc_config_\\\" + str(run) + \\\"_\\\" + str(subrun) + \\\".cfg\\\")\\n \\n configContents = \\\"\\\"\\n \\n configContents += \\\"[software]\\\\n\\\"\\n if conditions.oldneut:\\n configContents += \\\"neut_setup_script = /project/t/tanaka/T2K/neut/branches/5.1.4.2_nd280_ROOTv5r34p09n01/src/neutgeom/setup.sh\\\\n\\\"\\n elif conditions.newoldneut:\\n configContents += \\\"neut_setup_script = /project/t/tanaka/T2K/neut/branches/5.1.4.3_nd280/src/neutgeom/setup.sh\\\\n\\\"\\n else:\\n #configContents += \\\"neut_setup_script = /project/t/tanaka/T2K/neut/branches/5.3.1_nd280/src/neutgeom/setup.sh\\\\n\\\"\\n #configContents += \\\"neut_setup_script = /project/t/tanaka/T2K/neut/branches/5.3.1_nd280_wBBBA05/src/neutgeom/setup.sh\\\\n\\\"\\n configContents += \\\"neut_setup_script = /project/t/tanaka/T2K/neut/branches/5.3.2_nd280/src/neutgeom/setup.sh\\\\n\\\"\\n \\n configContents += \\\"[geometry]\\\\n\\\"\\n\\n configContents += \\\"baseline = \\\" + conditions.geometry +\\\"\\\\n\\\"\\n if conditions.waterair == \\\"water\\\":\\n configContents += \\\"p0d_water_fill = 1\\\\n\\\"\\n else:\\n configContents += \\\"p0d_water_fill = 0\\\\n\\\"\\n \\n configContents += \\\"\\\"\\\"\\n \\n[configuration]\\nmodule_list = neutMC\\n\\n[filenaming]\\n\\\"\\\"\\\"\\n configContents += \\\"comment = \\\" + conditions.comment + \\\"\\\\n\\\"\\n configContents += \\\"run_number = \\\" + str(run) +\\\"\\\\n\\\"\\n configContents += \\\"subrun = \\\" + str(subrun) + \\\"\\\\n\\\"\\n\\n if conditions.oldneut:\\n configContents += \\\"\\\"\\\" \\n\\n[neutrino]\\nneut_card = /project/t/tanaka/T2K/neut/branches/5.1.4.2_nd280_ROOTv5r34p09n01/src/neutgeom/neut.card\\n\\\"\\\"\\\"\\n elif conditions.newoldneut:\\n configContents += \\\"\\\"\\\" \\n\\n[neutrino]\\nneut_card = /project/t/tanaka/T2K/neut/branches/5.1.4.3_nd280/src/neutgeom/neut.card\\n\\\"\\\"\\\"\\n else:\\n configContents += \\\"\\\"\\\" \\n\\n[neutrino]\\nneut_card = /project/t/tanaka/T2K/neut/branches/5.3.2_nd280/src/neutgeom/neut.card\\n\\\"\\\"\\\"\\n\\n configContents += \\\"flux_file = \\\" + conditions.ram_disk + \\\"/\\\" + conditions.flux_base + \\\"\\\\n\\\"\\n\\n#flux_file = flux_file\\n#\\\"\\\"\\\"\\n\\n# configContents += \\\"flux_file_path = \\\" + conditions.ram_disk + \\\"/\\\" + conditions.flux_base\\n\\n# configContents += \\\"\\\"\\\" \\n#flux_file_start = 1\\n#flux_file_stop = 300\\n#\\\"\\\"\\\"\\n\\n configContents += \\\"maxint_file = \\\" + conditions.maxint_file_local + \\\"\\\\n\\\"\\n\\n# default: 5e17 but for basket MC special production higher\\n configContents += \\\"\\\"\\\" \\npot = 5.0e17\\nneutrino_type = beam\\n\\\"\\\"\\\"\\n if conditions.baskmagn == \\\"basket\\\":\\n configContents += \\\"\\\"\\\" \\nflux_region = basket\\nmaster_volume = Basket \\nrandom_start = 1\\n\\\"\\\"\\\"\\n elif conditions.baskmagn == \\\"magnet\\\":\\n configContents += \\\"\\\"\\\" \\nflux_region = magnet\\nmaster_volume = Magnet \\nrandom_start = 1\\n\\\"\\\"\\\"\\n else:\\n print \\\"Unknown basket/magnet condition\\\"\\n \\n\\n configContents += \\\"random_seed = \\\" + str(getRandom()) +\\\"\\\\n\\\"\\n configContents += \\\"neut_seed1 = \\\" + str(getRandom())+\\\"\\\\n\\\" \\n configContents += \\\"neut_seed2 = \\\" + str(getRandom())+\\\"\\\\n\\\" \\n configContents += \\\"neut_seed3 = \\\" + str(getRandom())+\\\"\\\\n\\\" \\n\\n configContents += \\\"\\\\n\\\"\\n configContents += \\\"[nd280mc]\\\\n\\\"\\n configContents += \\\"mc_type=Neut_RooTracker \\\\n\\\"\\n\\n #print configContents\\n\\n try:\\n macFile = open(configname,\\\"w\\\")\\n macFile.write(configContents)\\n \\n except:\\n print \\\"can't write config file\\\" \\n \\n\\n return configname\",\n \"def config(self) -> Dict[str, Any]:\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71267474","0.70139384","0.6695297","0.6695297","0.6452325","0.61890537","0.58279073","0.5709033","0.5683073","0.5581039","0.5581039","0.55700415","0.5538782","0.5537797","0.55327755","0.5504798","0.5504798","0.549545","0.5481937","0.5481937","0.54747856","0.54729486","0.54273564","0.5427297","0.54195637","0.54127544","0.54127544","0.54127544","0.54127544","0.5404038","0.5401153","0.53942746","0.5366179","0.53653985","0.53641737","0.5362162","0.53599864","0.53456485","0.533613","0.53355944","0.5296449","0.5290918","0.52901727","0.5279578","0.5265854","0.5258809","0.5256539","0.5239632","0.52372307","0.52344","0.5232475","0.5226472","0.5226472","0.5220193","0.52192366","0.52150685","0.5202963","0.5201259","0.51911616","0.51895136","0.5187462","0.5187462","0.5180944","0.5179789","0.51745975","0.5174519","0.5167432","0.5164662","0.51636297","0.5130684","0.5123058","0.5120719","0.51108754","0.50979406","0.5092723","0.5092723","0.50921637","0.5089375","0.50874805","0.50796187","0.5078361","0.50761825","0.50734055","0.50604916","0.50587356","0.5058665","0.50563216","0.50524974","0.5051789","0.5051565","0.5051528","0.5046221","0.5041399","0.5034604","0.50286067","0.5024043","0.5020626","0.5012662","0.5012662","0.5009764","0.5002845"],"string":"[\n \"0.71267474\",\n \"0.70139384\",\n \"0.6695297\",\n \"0.6695297\",\n \"0.6452325\",\n \"0.61890537\",\n \"0.58279073\",\n \"0.5709033\",\n \"0.5683073\",\n \"0.5581039\",\n \"0.5581039\",\n \"0.55700415\",\n \"0.5538782\",\n \"0.5537797\",\n \"0.55327755\",\n \"0.5504798\",\n \"0.5504798\",\n \"0.549545\",\n \"0.5481937\",\n \"0.5481937\",\n \"0.54747856\",\n \"0.54729486\",\n \"0.54273564\",\n \"0.5427297\",\n \"0.54195637\",\n \"0.54127544\",\n \"0.54127544\",\n \"0.54127544\",\n \"0.54127544\",\n \"0.5404038\",\n \"0.5401153\",\n \"0.53942746\",\n \"0.5366179\",\n \"0.53653985\",\n \"0.53641737\",\n \"0.5362162\",\n \"0.53599864\",\n \"0.53456485\",\n \"0.533613\",\n \"0.53355944\",\n \"0.5296449\",\n \"0.5290918\",\n \"0.52901727\",\n \"0.5279578\",\n \"0.5265854\",\n \"0.5258809\",\n \"0.5256539\",\n \"0.5239632\",\n \"0.52372307\",\n \"0.52344\",\n \"0.5232475\",\n \"0.5226472\",\n \"0.5226472\",\n \"0.5220193\",\n \"0.52192366\",\n \"0.52150685\",\n \"0.5202963\",\n \"0.5201259\",\n \"0.51911616\",\n \"0.51895136\",\n \"0.5187462\",\n \"0.5187462\",\n \"0.5180944\",\n \"0.5179789\",\n \"0.51745975\",\n \"0.5174519\",\n \"0.5167432\",\n \"0.5164662\",\n \"0.51636297\",\n \"0.5130684\",\n \"0.5123058\",\n \"0.5120719\",\n \"0.51108754\",\n \"0.50979406\",\n \"0.5092723\",\n \"0.5092723\",\n \"0.50921637\",\n \"0.5089375\",\n \"0.50874805\",\n \"0.50796187\",\n \"0.5078361\",\n \"0.50761825\",\n \"0.50734055\",\n \"0.50604916\",\n \"0.50587356\",\n \"0.5058665\",\n \"0.50563216\",\n \"0.50524974\",\n \"0.5051789\",\n \"0.5051565\",\n \"0.5051528\",\n \"0.5046221\",\n \"0.5041399\",\n \"0.5034604\",\n \"0.50286067\",\n \"0.5024043\",\n \"0.5020626\",\n \"0.5012662\",\n \"0.5012662\",\n \"0.5009764\",\n \"0.5002845\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93194,"cells":{"query":{"kind":"string","value":"Get the specified JSON input file's contents as a dict"},"document":{"kind":"string","value":"def get_inputs_from_file(filename=\"\"):\n import json\n\n with open(filename) as input_text:\n json_obj = json.load(input_text)\n return json_obj"},"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 _read_json(cls, input_file):\n with open(input_file, 'rb') as f:\n return json.load(f)","def _read_json(cls, input_file):\n with open(input_file, 'rb') as f:\n return json.load(f)","def _read_json(cls, input_file):\n with open(input_file) as f:\n return json.load(f)","def _read_json(cls, input_file):\n with open(input_file) as f:\n return json.load(f)","def read_json(file: str) -> Dict[str, Dict[str, Dict[str, str]]]:\n if os.path.exists(file):\n with open(file, 'r') as input_file:\n return json.load(input_file)\n else:\n print('Invalid signature file.')\n sys.exit(-1)","def read_json_file(file_name: str) -> Dict[str, Any]:\n with open(file_name) as file:\n return json.load(file)","def get_json(filename):\n with open(filename) as f:\n file_content = f.read()\n data = json.loads(file_content)\n return data","def json_dict(path):\n json_file=open(path)\n json_str = json_file.read()\n json_data = json.loads(json_str)\n return json_data","def get_json(filename) :\n result = json.load(open(filename,'r'))\n return result","def json_dict(path):\n json_file=open(path)\n json_str = json_file.read()\n json_data = loads(json_str)\n return json_data","def json_reader(file_path):\n\n with open(file_path) as file:\n json_dict = json.load(file)\n\n return json_dict","def read_json_file(self, fname):\n return {}","def _parse_json_file(json_path):\n app.app.logger.info('Reading JSON file %s' % json_path)\n with open(json_path, 'r') as f:\n # Remove comments using jsmin, as recommended by JSON creator:\n # https://plus.google.com/+DouglasCrockfordEsq/posts/RK8qyGVaGSr\n jsonDict = json.loads(jsmin.jsmin(f.read()))\n return jsonDict","def read_file(input_file):\n ext = utils._get_file_ext(input_file)\n if ext != 'json':\n raise ValueError(\"Expecting a json file, but got: {ext}\".format(ext=ext))\n\n input_data = None\n with open(utils._get_absolute_path(input_file)) as json_data:\n input_data = json.load(json_data)\n\n return input_data","def read_json(filepath):\n return json.loads(open(filepath).read())","def _parse_json(self, file_location: str) -> Dict:\n with open(file_location, mode=\"r\") as json_file:\n raw_json = json.loads(json_file.read())\n return raw_json","def read_json(filename):\n # Implement this function\n file = open(filename)\n text = file.read()\n result = json.loads(text)\n file.close()\n return result","def get_json_data(json_file):\n logging.log(logging.DEBUG, \"Extracting JSON file %s\" % json_file)\n with open(json_file, \"r\") as json_d:\n d = json.load(json_d)\n return d","def read_json(json_file):\n with open(json_file) as f:\n content = json.load(f)\n return(content)","def get_json(input):\n\n if os.path.isfile(input):\n try:\n with open(input, 'r') as f:\n obj = json.load(f)\n f.close()\n except Exception as e:\n raise ValueError(\"Unable to read the JSON file: %s\" % input)\n else:\n try:\n obj = json.loads(input)\n except Exception as e:\n raise ValueError(\"Unable to read the JSON: %s\" % input)\n\n return obj","def import_json(self) -> dict:\n with open(self.path, encoding=\"utf8\") as json_file:\n return json.load(json_file)","def parse_json(json_file: str) -> dict:\n json_data = {}\n\n if not os.path.isfile(json_file):\n error_log(os.path.basename(json_file) + ' does not exist.')\n sys.exit(1)\n\n with open(json_file) as f:\n json_data = json.load(f)\n\n return json_data","def example_json(example_json_file):\n return json.loads(example_json_file)","def get_file(file):\n with open(file) as data_file:\n return json.load(data_file)","def json_input():\r\n with open (FILE_INPUT,'rb') as file:\r\n data = json.load(file)\r\n return data['input_data'][0]","def read_file(filename: str) -> Dict:\n if not Path(filename).exists():\n raise Exception(f\"file {filename} does not exists.\")\n else:\n with open(filename, \"r\") as f:\n return json.load(f)","def openJson(self):\n json_file = open(self.file, 'r')\n json_data = json_file.read()\n result = json.loads(json_data)\n return result","def read(self, filepath, dirpath=None):\n try:\n #filepath = os.path.normpath(filepath)\n with open(filepath) as f_p:\n try:\n self.json_dict = json.load(f_p)\n self.filepath = filepath\n return self.json_dict\n except ValueError as err:\n print('JSON content error in \"%s\"' % filepath)\n print(err)\n except (IOError, FileNotFoundError):\n print(\n 'Failed to open JSON file \"%s\" \"%s\"' %\n (os.path.abspath(''), filepath))\n raise NoSuchFileError(filepath)\n raise JsonContentError","def json_from_file(name):\n with open(name) as f_p:\n return json.load(f_p)","def read_json(f):\n with open(f, \"r\") as fin:\n return json.loads(fin.read())","def read_json(file_name):\n try:\n with open(file_name, \"rt\") as input_file:\n return json.loads(input_file.read())\n except TypeError:\n print(\"No valid JSON data!\")\n raise\n except IOError:\n print(\"Could not read file from disk!\")\n raise","def read_json_file(jsonfile):\n with jsonfile.open('r') as cfile:\n return json.loads(cfile.read())","def _json_read(filename):\n with open(filename) as file:\n return json.load(file)","def json_load(path):\n with open(path) as f:\n dictionary = json.load(f)\n return dictionary","def read_json(file):\n with open(file, \"r\") as fid:\n return json.load(fid)","def read_json_file(filename):\n with open(filename) as f:\n try:\n data = json.loads(f.read())\n except:\n data = {}\n return data","def input_data(self):\n return read_json(self.file_path)","def _read_json(filename):\n with open(filename) as f:\n import json\n return json.load(f)","def importJSON(path_to_json) -> dict:\n try:\n with open(path_to_json, 'r') as f:\n json_data = json.load(f)\n return(json_data)\n except Exception as error:\n print(f\"Error: importJSON({path_to_json}) -> {error}\")","def _read_json_file(self):\n with open(self.subcfgfilename) as json_file:\n json_string = json_file.read()\n json_data = json.loads(json_string)\n return(json_data)","def read_json(filename: Union[pathlib.Path, str]):\n if isinstance(filename, str):\n filename = pathlib.Path(filename)\n with open(filename) as fh:\n return json.loads(fh.read())","def _get_json_file_content(file_dir_arg):\n result = None\n\n try:\n with open(file_dir_arg, 'r', encoding='UTF-8-SIG') as f:\n result_tmp = f\n result = load(result_tmp)\n except Exception as e:\n print(e.args)\n\n return result","def load_json(file_path):\n\n \n with open(file_path, 'r') as json_file:\n # print(file_path)\n dictionary = json.loads(json_file.read())\n\n return dictionary","def read_json(fname):\n with open(fname) as f:\n d = json.load(f)\n return d","def load_json(file_name):\n return json.load(open(file_name))","def _json_probe(srcfile):\n return json.loads(__run(srcfile))","def _read_json(self, filename):\n path = os.path.join(self.script_path, filename)\n try:\n with open(path) as file:\n return json.load(file)\n except Exception as exception:\n print('Error parsing {}: {}'.format(path, str(exception)))\n raise","def read_file(filename):\n with open(filename) as json_file:\n data = json.load(json_file)\n return data","def read_json_document(json_file_name):\n\n with open(json_file_name) as fd:\n data = json.load(fd)\n\n return data","def example_json42(example_json_file42):\n return json.loads(example_json_file42)","def read_json(file_path):\n return json.loads(strip_comments(read_text(file_path)))","def process_json(path):\n path = os.path.abspath(os.path.expanduser(path))\n try:\n with open(path) as f:\n return json.load(f, object_hook=ascii_encode_dict)\n except ValueError as e:\n logging.error(\"File: %s\\nInvalid JSON:\\n%s\", str(path), str(e))\n raise\n except IOError as io:\n logging.error(\"Provided json file path does not exist %s\", str(path))\n raise","def read_file(path):\n with open(path) as json_file:\n data = json.load(json_file)\n return data","def read_json(file_path):\n with open(file_path) as file:\n return json.load(file)","def parse_json_from_path(self, infile_path):\r\n with open(infile_path, 'r') as infile:\r\n return self.parse_from_json(infile)","def readjson(path):\n\twith open(path, 'r') as file:\n\t\treturn json.load(file)","def read_json(file):\n\n with open(file, 'r') as fp:\n data = json.load(fp)\n return data","def reading_json(json_file):\n with open(json_file, encoding=\"utf-8\") as file:\n r_json = json.load(file)\n return r_json","def parse_json(json_file):\n try:\n with open(json_file, \"r\") as file_reader:\n file_contents = file_reader.read()\n return json.loads(file_contents)\n except FileNotFoundError:\n raise FileNotFoundError(\"File not found.\")","def read_json(jsonfp):\n with JsonFile(jsonfp) as jsondata:\n return jsondata","def get_file(filename: str) -> dict:\n return loads(open(f\"data/gamedata/{filename}.json\", \"r\", encoding=\"utf-8\").read())","def read(self):\n with open(self._path, 'r') as f:\n content = os.linesep.join(f.readlines())\n try:\n return json.loads(content)\n except json.JSONDecodeError:\n return content","def load_json_file(json_path):\n with open(json_path, 'r') as json_file:\n contents = load(json_file)\n\n return contents","def read_json(json_file):\n with open(json_file, \"r\") as fp:\n data = json.load(fp)\n return data","def read_json(self):\n self._fopen.seek(self._json_start, 0)\n return json.loads(self._fopen.read().decode('utf-8'))","def convert_json_to_object(file_content):\n object = json.loads(file_content)\n print(object)\n return object","def read_json(fullpath):\n import json\n \n with open(fullpath, \"r\") as json_file_readed:\n json_readed = json.load(json_file_readed)\n\n return json_readed","def read_json(filename):\r\n\r\n with open(filename, 'r') as data_file:\r\n return json.load(data_file)","def data_from_file(filename):\n with open(data_full_filename(filename)) as f:\n return json.loads(f.read())","def parse_json(json_path):\n with open(json_path, 'r') as f:\n out = json.load(f)\n return out","def read_cinder_input(input_file_name):\n if input_file_name:\n # reading from a file, not stdin\n with open(input_file_name, \"r\") as input_file:\n info = json.loads(input_file.read())\n return info\n else:\n # read json from stdin\n return json.loads(sys.stdin.read())","def get_data_json(filename):\n with open(filename) as f:\n data = json.load(f)\n return data","def get_relevant_dict(domain: str) -> dict:\n file = json.load(open(jsonfp + domain + \".json\"))\n print(file)\n return file","def read_json(file):\n with open(file) as r:\n jsn = r.read()\n\n data = json.loads(jsn)\n res = data[\"response\"][\"docs\"]\n return res","def dictionary_from_json_file(_json_file):\n with open(_json_file) as _f:\n _dict = json.load(_f)\n return _dict","def read_json(filepath):\n\n with open(filepath, 'r', encoding='utf-8') as file_obj:\n data = json.load(file_obj)\n\n return data","def read_json(path):\n with open(path, 'r') as f:\n return json.load(f)","def read_json(filepath):\n if (filepath in _json_cache):\n return _json_cache[filepath]\n with open(filepath, 'r', encoding='utf-8') as fileinfo:\n data = json.load(fileinfo)\n _json_cache[filepath] = data\n return data","def ingest_json_file(request):\n path = save_file(request) \n try:\n with open(path, encoding='utf-8') as f:\n data = json.loads(f.read())\n except Exception as e:\n log.error(log.exc(e))\n return None\n return data","def _json_from_file(file: IO[AnyStr]) -> Json:\n if os.path.getsize(file.name) > 0:\n return typing.cast(Json, json.load(file))\n return {}","def load_json_data(filepath):\n with open(filepath,'r') as f:\n return json.load(f)","def read_json(fn):\n with open(fn) as f:\n return json.load(f, object_hook=_operator_object_hook)","def extract_model_output_from_json(json_file_path: str) -> dict:\n cprint(f\"### Function Name:-> {inspect.stack()[0][3]} ###\", 'yellow', 'on_grey', attrs=['bold'])\n try:\n json_data = dict()\n json_file_path = Path(json_file_path)\n if json_file_path.exists():\n with open(json_file_path.as_posix(), \"r\") as json_file:\n json_data = json.load(json_file)\n\n return json_data\n except Exception as ex:\n cprint(traceback.format_exc(), 'red')\n log_exception(traceback.format_exc())\n return json_data","def load_json_file(i):\n\n import json\n\n fn = i['json_file']\n\n try:\n if sys.version_info[0] > 2:\n f = open(fn, 'r', encoding='utf8')\n else:\n f = open(fn, 'r')\n except Exception as e:\n return {'return': 16, 'error': 'problem opening json file='+fn+' ('+format(e)+')'}\n\n try:\n s = f.read()\n except Exception as e:\n f.close()\n return {'return': 1, 'error': 'problem reading json file='+fn+' ('+format(e)+')'}\n\n f.close()\n\n try:\n if sys.version_info[0] > 2:\n d = json.loads(s)\n else:\n d = json.loads(s, encoding='utf8')\n except Exception as e:\n return {'return': 1, 'error': 'problem parsing json from file='+fn+' ('+format(e)+')'}\n\n return {'return': 0, 'dict': d}","def read_json_fixture(filename: str) -> Dict[str, str]:\n fixture_path = Path(__file__).resolve().parents[0] / f\"fixtures/{filename}\"\n with open(fixture_path, mode=\"r\") as f:\n data = json.load(f)\n return data","def load(self, filename):\n _json = self.read_json(filename, byteify=True)\n _json = self._byteify(_json, ignore_dicts=True)\n if not _json:\n return None\n _dict = {k : self._parse_value(v) for k, v in _json.items()}\n return _dict","def get_json_data_from_file(file_path):\n with open(file_path) as json_file:\n data = json.load(json_file)\n return data","def json_load(file_path):\n\n with open(file_path) as f:\n return json_loads(f.read())","def JSONtoObject(fileName):\n # TODO: ensure file exists first!!\n \n with open(fileName) as json_data:\n d = json.load(json_data)\n \n return d\n #return json.loads(d, object_hook=_json_object_hook)","def read_json(filename):\n with open(filename, 'r') as f:\n data = json.load(f)\n return data","def example_json43(example_json_file43):\n return json.loads(example_json_file43)","def load_json(filename: str) -> Dict:\n \n with open(filename, 'r') as json_file:\n return json.load(json_file)","def read_json(fpath):\n with open(fpath, 'r') as f:\n obj = json.load(f)\n return obj","def parse_json(file_path):\n j_data = open(file_path, 'r')\n s_data = \"\"\n for line in j_data:\n s_data += line\n j_data.close()\n s_data.strip()\n p_data = json.loads(s_data)\n return p_data","def loadJsonFromFile(filename):\n with open(filename) as f:\n return json.loads(f.read())","def read_json(path):\n with open(path) as json_file:\n data = json.load(json_file)\n return data","def load_json(file_name):\n with open(file_name) as f:\n data = json.load(f)\n\n return data","def loadJSONFile(filename):\n\twith open(filename, 'r') as f:\n\t\treturn json.loads(f.read())","def read_json(filepath: str):\n if not filepath:\n raise ValueError\n if not os.path.isfile(filepath):\n raise FileNotFoundError\n with open(filepath) as f:\n return json.load(f)","def load_json(self, filename):\n with open(filename, 'r', encoding='utf-8') as f:\n data_dict = json.load(f)\n return data_dict"],"string":"[\n \"def _read_json(cls, input_file):\\n with open(input_file, 'rb') as f:\\n return json.load(f)\",\n \"def _read_json(cls, input_file):\\n with open(input_file, 'rb') as f:\\n return json.load(f)\",\n \"def _read_json(cls, input_file):\\n with open(input_file) as f:\\n return json.load(f)\",\n \"def _read_json(cls, input_file):\\n with open(input_file) as f:\\n return json.load(f)\",\n \"def read_json(file: str) -> Dict[str, Dict[str, Dict[str, str]]]:\\n if os.path.exists(file):\\n with open(file, 'r') as input_file:\\n return json.load(input_file)\\n else:\\n print('Invalid signature file.')\\n sys.exit(-1)\",\n \"def read_json_file(file_name: str) -> Dict[str, Any]:\\n with open(file_name) as file:\\n return json.load(file)\",\n \"def get_json(filename):\\n with open(filename) as f:\\n file_content = f.read()\\n data = json.loads(file_content)\\n return data\",\n \"def json_dict(path):\\n json_file=open(path)\\n json_str = json_file.read()\\n json_data = json.loads(json_str)\\n return json_data\",\n \"def get_json(filename) :\\n result = json.load(open(filename,'r'))\\n return result\",\n \"def json_dict(path):\\n json_file=open(path)\\n json_str = json_file.read()\\n json_data = loads(json_str)\\n return json_data\",\n \"def json_reader(file_path):\\n\\n with open(file_path) as file:\\n json_dict = json.load(file)\\n\\n return json_dict\",\n \"def read_json_file(self, fname):\\n return {}\",\n \"def _parse_json_file(json_path):\\n app.app.logger.info('Reading JSON file %s' % json_path)\\n with open(json_path, 'r') as f:\\n # Remove comments using jsmin, as recommended by JSON creator:\\n # https://plus.google.com/+DouglasCrockfordEsq/posts/RK8qyGVaGSr\\n jsonDict = json.loads(jsmin.jsmin(f.read()))\\n return jsonDict\",\n \"def read_file(input_file):\\n ext = utils._get_file_ext(input_file)\\n if ext != 'json':\\n raise ValueError(\\\"Expecting a json file, but got: {ext}\\\".format(ext=ext))\\n\\n input_data = None\\n with open(utils._get_absolute_path(input_file)) as json_data:\\n input_data = json.load(json_data)\\n\\n return input_data\",\n \"def read_json(filepath):\\n return json.loads(open(filepath).read())\",\n \"def _parse_json(self, file_location: str) -> Dict:\\n with open(file_location, mode=\\\"r\\\") as json_file:\\n raw_json = json.loads(json_file.read())\\n return raw_json\",\n \"def read_json(filename):\\n # Implement this function\\n file = open(filename)\\n text = file.read()\\n result = json.loads(text)\\n file.close()\\n return result\",\n \"def get_json_data(json_file):\\n logging.log(logging.DEBUG, \\\"Extracting JSON file %s\\\" % json_file)\\n with open(json_file, \\\"r\\\") as json_d:\\n d = json.load(json_d)\\n return d\",\n \"def read_json(json_file):\\n with open(json_file) as f:\\n content = json.load(f)\\n return(content)\",\n \"def get_json(input):\\n\\n if os.path.isfile(input):\\n try:\\n with open(input, 'r') as f:\\n obj = json.load(f)\\n f.close()\\n except Exception as e:\\n raise ValueError(\\\"Unable to read the JSON file: %s\\\" % input)\\n else:\\n try:\\n obj = json.loads(input)\\n except Exception as e:\\n raise ValueError(\\\"Unable to read the JSON: %s\\\" % input)\\n\\n return obj\",\n \"def import_json(self) -> dict:\\n with open(self.path, encoding=\\\"utf8\\\") as json_file:\\n return json.load(json_file)\",\n \"def parse_json(json_file: str) -> dict:\\n json_data = {}\\n\\n if not os.path.isfile(json_file):\\n error_log(os.path.basename(json_file) + ' does not exist.')\\n sys.exit(1)\\n\\n with open(json_file) as f:\\n json_data = json.load(f)\\n\\n return json_data\",\n \"def example_json(example_json_file):\\n return json.loads(example_json_file)\",\n \"def get_file(file):\\n with open(file) as data_file:\\n return json.load(data_file)\",\n \"def json_input():\\r\\n with open (FILE_INPUT,'rb') as file:\\r\\n data = json.load(file)\\r\\n return data['input_data'][0]\",\n \"def read_file(filename: str) -> Dict:\\n if not Path(filename).exists():\\n raise Exception(f\\\"file {filename} does not exists.\\\")\\n else:\\n with open(filename, \\\"r\\\") as f:\\n return json.load(f)\",\n \"def openJson(self):\\n json_file = open(self.file, 'r')\\n json_data = json_file.read()\\n result = json.loads(json_data)\\n return result\",\n \"def read(self, filepath, dirpath=None):\\n try:\\n #filepath = os.path.normpath(filepath)\\n with open(filepath) as f_p:\\n try:\\n self.json_dict = json.load(f_p)\\n self.filepath = filepath\\n return self.json_dict\\n except ValueError as err:\\n print('JSON content error in \\\"%s\\\"' % filepath)\\n print(err)\\n except (IOError, FileNotFoundError):\\n print(\\n 'Failed to open JSON file \\\"%s\\\" \\\"%s\\\"' %\\n (os.path.abspath(''), filepath))\\n raise NoSuchFileError(filepath)\\n raise JsonContentError\",\n \"def json_from_file(name):\\n with open(name) as f_p:\\n return json.load(f_p)\",\n \"def read_json(f):\\n with open(f, \\\"r\\\") as fin:\\n return json.loads(fin.read())\",\n \"def read_json(file_name):\\n try:\\n with open(file_name, \\\"rt\\\") as input_file:\\n return json.loads(input_file.read())\\n except TypeError:\\n print(\\\"No valid JSON data!\\\")\\n raise\\n except IOError:\\n print(\\\"Could not read file from disk!\\\")\\n raise\",\n \"def read_json_file(jsonfile):\\n with jsonfile.open('r') as cfile:\\n return json.loads(cfile.read())\",\n \"def _json_read(filename):\\n with open(filename) as file:\\n return json.load(file)\",\n \"def json_load(path):\\n with open(path) as f:\\n dictionary = json.load(f)\\n return dictionary\",\n \"def read_json(file):\\n with open(file, \\\"r\\\") as fid:\\n return json.load(fid)\",\n \"def read_json_file(filename):\\n with open(filename) as f:\\n try:\\n data = json.loads(f.read())\\n except:\\n data = {}\\n return data\",\n \"def input_data(self):\\n return read_json(self.file_path)\",\n \"def _read_json(filename):\\n with open(filename) as f:\\n import json\\n return json.load(f)\",\n \"def importJSON(path_to_json) -> dict:\\n try:\\n with open(path_to_json, 'r') as f:\\n json_data = json.load(f)\\n return(json_data)\\n except Exception as error:\\n print(f\\\"Error: importJSON({path_to_json}) -> {error}\\\")\",\n \"def _read_json_file(self):\\n with open(self.subcfgfilename) as json_file:\\n json_string = json_file.read()\\n json_data = json.loads(json_string)\\n return(json_data)\",\n \"def read_json(filename: Union[pathlib.Path, str]):\\n if isinstance(filename, str):\\n filename = pathlib.Path(filename)\\n with open(filename) as fh:\\n return json.loads(fh.read())\",\n \"def _get_json_file_content(file_dir_arg):\\n result = None\\n\\n try:\\n with open(file_dir_arg, 'r', encoding='UTF-8-SIG') as f:\\n result_tmp = f\\n result = load(result_tmp)\\n except Exception as e:\\n print(e.args)\\n\\n return result\",\n \"def load_json(file_path):\\n\\n \\n with open(file_path, 'r') as json_file:\\n # print(file_path)\\n dictionary = json.loads(json_file.read())\\n\\n return dictionary\",\n \"def read_json(fname):\\n with open(fname) as f:\\n d = json.load(f)\\n return d\",\n \"def load_json(file_name):\\n return json.load(open(file_name))\",\n \"def _json_probe(srcfile):\\n return json.loads(__run(srcfile))\",\n \"def _read_json(self, filename):\\n path = os.path.join(self.script_path, filename)\\n try:\\n with open(path) as file:\\n return json.load(file)\\n except Exception as exception:\\n print('Error parsing {}: {}'.format(path, str(exception)))\\n raise\",\n \"def read_file(filename):\\n with open(filename) as json_file:\\n data = json.load(json_file)\\n return data\",\n \"def read_json_document(json_file_name):\\n\\n with open(json_file_name) as fd:\\n data = json.load(fd)\\n\\n return data\",\n \"def example_json42(example_json_file42):\\n return json.loads(example_json_file42)\",\n \"def read_json(file_path):\\n return json.loads(strip_comments(read_text(file_path)))\",\n \"def process_json(path):\\n path = os.path.abspath(os.path.expanduser(path))\\n try:\\n with open(path) as f:\\n return json.load(f, object_hook=ascii_encode_dict)\\n except ValueError as e:\\n logging.error(\\\"File: %s\\\\nInvalid JSON:\\\\n%s\\\", str(path), str(e))\\n raise\\n except IOError as io:\\n logging.error(\\\"Provided json file path does not exist %s\\\", str(path))\\n raise\",\n \"def read_file(path):\\n with open(path) as json_file:\\n data = json.load(json_file)\\n return data\",\n \"def read_json(file_path):\\n with open(file_path) as file:\\n return json.load(file)\",\n \"def parse_json_from_path(self, infile_path):\\r\\n with open(infile_path, 'r') as infile:\\r\\n return self.parse_from_json(infile)\",\n \"def readjson(path):\\n\\twith open(path, 'r') as file:\\n\\t\\treturn json.load(file)\",\n \"def read_json(file):\\n\\n with open(file, 'r') as fp:\\n data = json.load(fp)\\n return data\",\n \"def reading_json(json_file):\\n with open(json_file, encoding=\\\"utf-8\\\") as file:\\n r_json = json.load(file)\\n return r_json\",\n \"def parse_json(json_file):\\n try:\\n with open(json_file, \\\"r\\\") as file_reader:\\n file_contents = file_reader.read()\\n return json.loads(file_contents)\\n except FileNotFoundError:\\n raise FileNotFoundError(\\\"File not found.\\\")\",\n \"def read_json(jsonfp):\\n with JsonFile(jsonfp) as jsondata:\\n return jsondata\",\n \"def get_file(filename: str) -> dict:\\n return loads(open(f\\\"data/gamedata/{filename}.json\\\", \\\"r\\\", encoding=\\\"utf-8\\\").read())\",\n \"def read(self):\\n with open(self._path, 'r') as f:\\n content = os.linesep.join(f.readlines())\\n try:\\n return json.loads(content)\\n except json.JSONDecodeError:\\n return content\",\n \"def load_json_file(json_path):\\n with open(json_path, 'r') as json_file:\\n contents = load(json_file)\\n\\n return contents\",\n \"def read_json(json_file):\\n with open(json_file, \\\"r\\\") as fp:\\n data = json.load(fp)\\n return data\",\n \"def read_json(self):\\n self._fopen.seek(self._json_start, 0)\\n return json.loads(self._fopen.read().decode('utf-8'))\",\n \"def convert_json_to_object(file_content):\\n object = json.loads(file_content)\\n print(object)\\n return object\",\n \"def read_json(fullpath):\\n import json\\n \\n with open(fullpath, \\\"r\\\") as json_file_readed:\\n json_readed = json.load(json_file_readed)\\n\\n return json_readed\",\n \"def read_json(filename):\\r\\n\\r\\n with open(filename, 'r') as data_file:\\r\\n return json.load(data_file)\",\n \"def data_from_file(filename):\\n with open(data_full_filename(filename)) as f:\\n return json.loads(f.read())\",\n \"def parse_json(json_path):\\n with open(json_path, 'r') as f:\\n out = json.load(f)\\n return out\",\n \"def read_cinder_input(input_file_name):\\n if input_file_name:\\n # reading from a file, not stdin\\n with open(input_file_name, \\\"r\\\") as input_file:\\n info = json.loads(input_file.read())\\n return info\\n else:\\n # read json from stdin\\n return json.loads(sys.stdin.read())\",\n \"def get_data_json(filename):\\n with open(filename) as f:\\n data = json.load(f)\\n return data\",\n \"def get_relevant_dict(domain: str) -> dict:\\n file = json.load(open(jsonfp + domain + \\\".json\\\"))\\n print(file)\\n return file\",\n \"def read_json(file):\\n with open(file) as r:\\n jsn = r.read()\\n\\n data = json.loads(jsn)\\n res = data[\\\"response\\\"][\\\"docs\\\"]\\n return res\",\n \"def dictionary_from_json_file(_json_file):\\n with open(_json_file) as _f:\\n _dict = json.load(_f)\\n return _dict\",\n \"def read_json(filepath):\\n\\n with open(filepath, 'r', encoding='utf-8') as file_obj:\\n data = json.load(file_obj)\\n\\n return data\",\n \"def read_json(path):\\n with open(path, 'r') as f:\\n return json.load(f)\",\n \"def read_json(filepath):\\n if (filepath in _json_cache):\\n return _json_cache[filepath]\\n with open(filepath, 'r', encoding='utf-8') as fileinfo:\\n data = json.load(fileinfo)\\n _json_cache[filepath] = data\\n return data\",\n \"def ingest_json_file(request):\\n path = save_file(request) \\n try:\\n with open(path, encoding='utf-8') as f:\\n data = json.loads(f.read())\\n except Exception as e:\\n log.error(log.exc(e))\\n return None\\n return data\",\n \"def _json_from_file(file: IO[AnyStr]) -> Json:\\n if os.path.getsize(file.name) > 0:\\n return typing.cast(Json, json.load(file))\\n return {}\",\n \"def load_json_data(filepath):\\n with open(filepath,'r') as f:\\n return json.load(f)\",\n \"def read_json(fn):\\n with open(fn) as f:\\n return json.load(f, object_hook=_operator_object_hook)\",\n \"def extract_model_output_from_json(json_file_path: str) -> dict:\\n cprint(f\\\"### Function Name:-> {inspect.stack()[0][3]} ###\\\", 'yellow', 'on_grey', attrs=['bold'])\\n try:\\n json_data = dict()\\n json_file_path = Path(json_file_path)\\n if json_file_path.exists():\\n with open(json_file_path.as_posix(), \\\"r\\\") as json_file:\\n json_data = json.load(json_file)\\n\\n return json_data\\n except Exception as ex:\\n cprint(traceback.format_exc(), 'red')\\n log_exception(traceback.format_exc())\\n return json_data\",\n \"def load_json_file(i):\\n\\n import json\\n\\n fn = i['json_file']\\n\\n try:\\n if sys.version_info[0] > 2:\\n f = open(fn, 'r', encoding='utf8')\\n else:\\n f = open(fn, 'r')\\n except Exception as e:\\n return {'return': 16, 'error': 'problem opening json file='+fn+' ('+format(e)+')'}\\n\\n try:\\n s = f.read()\\n except Exception as e:\\n f.close()\\n return {'return': 1, 'error': 'problem reading json file='+fn+' ('+format(e)+')'}\\n\\n f.close()\\n\\n try:\\n if sys.version_info[0] > 2:\\n d = json.loads(s)\\n else:\\n d = json.loads(s, encoding='utf8')\\n except Exception as e:\\n return {'return': 1, 'error': 'problem parsing json from file='+fn+' ('+format(e)+')'}\\n\\n return {'return': 0, 'dict': d}\",\n \"def read_json_fixture(filename: str) -> Dict[str, str]:\\n fixture_path = Path(__file__).resolve().parents[0] / f\\\"fixtures/{filename}\\\"\\n with open(fixture_path, mode=\\\"r\\\") as f:\\n data = json.load(f)\\n return data\",\n \"def load(self, filename):\\n _json = self.read_json(filename, byteify=True)\\n _json = self._byteify(_json, ignore_dicts=True)\\n if not _json:\\n return None\\n _dict = {k : self._parse_value(v) for k, v in _json.items()}\\n return _dict\",\n \"def get_json_data_from_file(file_path):\\n with open(file_path) as json_file:\\n data = json.load(json_file)\\n return data\",\n \"def json_load(file_path):\\n\\n with open(file_path) as f:\\n return json_loads(f.read())\",\n \"def JSONtoObject(fileName):\\n # TODO: ensure file exists first!!\\n \\n with open(fileName) as json_data:\\n d = json.load(json_data)\\n \\n return d\\n #return json.loads(d, object_hook=_json_object_hook)\",\n \"def read_json(filename):\\n with open(filename, 'r') as f:\\n data = json.load(f)\\n return data\",\n \"def example_json43(example_json_file43):\\n return json.loads(example_json_file43)\",\n \"def load_json(filename: str) -> Dict:\\n \\n with open(filename, 'r') as json_file:\\n return json.load(json_file)\",\n \"def read_json(fpath):\\n with open(fpath, 'r') as f:\\n obj = json.load(f)\\n return obj\",\n \"def parse_json(file_path):\\n j_data = open(file_path, 'r')\\n s_data = \\\"\\\"\\n for line in j_data:\\n s_data += line\\n j_data.close()\\n s_data.strip()\\n p_data = json.loads(s_data)\\n return p_data\",\n \"def loadJsonFromFile(filename):\\n with open(filename) as f:\\n return json.loads(f.read())\",\n \"def read_json(path):\\n with open(path) as json_file:\\n data = json.load(json_file)\\n return data\",\n \"def load_json(file_name):\\n with open(file_name) as f:\\n data = json.load(f)\\n\\n return data\",\n \"def loadJSONFile(filename):\\n\\twith open(filename, 'r') as f:\\n\\t\\treturn json.loads(f.read())\",\n \"def read_json(filepath: str):\\n if not filepath:\\n raise ValueError\\n if not os.path.isfile(filepath):\\n raise FileNotFoundError\\n with open(filepath) as f:\\n return json.load(f)\",\n \"def load_json(self, filename):\\n with open(filename, 'r', encoding='utf-8') as f:\\n data_dict = json.load(f)\\n return data_dict\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7587827","0.7587827","0.7569293","0.7569293","0.75602573","0.753806","0.7389315","0.7381221","0.73781174","0.7354496","0.7349716","0.73322374","0.73126495","0.7310526","0.7288044","0.728155","0.7277607","0.7270094","0.7233338","0.7233158","0.72300816","0.72300476","0.7228032","0.7208064","0.71898973","0.7177155","0.7119518","0.7111403","0.71079993","0.7105902","0.71048975","0.70971304","0.70713884","0.70634675","0.70600766","0.7053198","0.7041882","0.70399815","0.7036182","0.7022514","0.6987785","0.69845515","0.696808","0.6959383","0.69533294","0.69513017","0.6946553","0.6944728","0.6940775","0.69407517","0.6936719","0.6921926","0.69104075","0.68917096","0.68898576","0.68801326","0.6873752","0.6869127","0.6858937","0.68527657","0.68510246","0.6847996","0.68391675","0.68371814","0.68319714","0.6830366","0.6824906","0.6804549","0.6794156","0.678416","0.67709863","0.677087","0.6770681","0.67700696","0.6769988","0.6759155","0.67563564","0.67527205","0.6750817","0.67504627","0.6747331","0.6745839","0.6741041","0.67407066","0.6740407","0.6740095","0.6737648","0.67292464","0.67275953","0.6718911","0.6711698","0.6708824","0.6695524","0.66735536","0.6672601","0.66707087","0.66684556","0.66661465","0.6649212","0.6621336"],"string":"[\n \"0.7587827\",\n \"0.7587827\",\n \"0.7569293\",\n \"0.7569293\",\n \"0.75602573\",\n \"0.753806\",\n \"0.7389315\",\n \"0.7381221\",\n \"0.73781174\",\n \"0.7354496\",\n \"0.7349716\",\n \"0.73322374\",\n \"0.73126495\",\n \"0.7310526\",\n \"0.7288044\",\n \"0.728155\",\n \"0.7277607\",\n \"0.7270094\",\n \"0.7233338\",\n \"0.7233158\",\n \"0.72300816\",\n \"0.72300476\",\n \"0.7228032\",\n \"0.7208064\",\n \"0.71898973\",\n \"0.7177155\",\n \"0.7119518\",\n \"0.7111403\",\n \"0.71079993\",\n \"0.7105902\",\n \"0.71048975\",\n \"0.70971304\",\n \"0.70713884\",\n \"0.70634675\",\n \"0.70600766\",\n \"0.7053198\",\n \"0.7041882\",\n \"0.70399815\",\n \"0.7036182\",\n \"0.7022514\",\n \"0.6987785\",\n \"0.69845515\",\n \"0.696808\",\n \"0.6959383\",\n \"0.69533294\",\n \"0.69513017\",\n \"0.6946553\",\n \"0.6944728\",\n \"0.6940775\",\n \"0.69407517\",\n \"0.6936719\",\n \"0.6921926\",\n \"0.69104075\",\n \"0.68917096\",\n \"0.68898576\",\n \"0.68801326\",\n \"0.6873752\",\n \"0.6869127\",\n \"0.6858937\",\n \"0.68527657\",\n \"0.68510246\",\n \"0.6847996\",\n \"0.68391675\",\n \"0.68371814\",\n \"0.68319714\",\n \"0.6830366\",\n \"0.6824906\",\n \"0.6804549\",\n \"0.6794156\",\n \"0.678416\",\n \"0.67709863\",\n \"0.677087\",\n \"0.6770681\",\n \"0.67700696\",\n \"0.6769988\",\n \"0.6759155\",\n \"0.67563564\",\n \"0.67527205\",\n \"0.6750817\",\n \"0.67504627\",\n \"0.6747331\",\n \"0.6745839\",\n \"0.6741041\",\n \"0.67407066\",\n \"0.6740407\",\n \"0.6740095\",\n \"0.6737648\",\n \"0.67292464\",\n \"0.67275953\",\n \"0.6718911\",\n \"0.6711698\",\n \"0.6708824\",\n \"0.6695524\",\n \"0.66735536\",\n \"0.6672601\",\n \"0.66707087\",\n \"0.66684556\",\n \"0.66661465\",\n \"0.6649212\",\n \"0.6621336\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7359419"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":93195,"cells":{"query":{"kind":"string","value":"Convention for saving the elev arrays to file."},"document":{"kind":"string","value":"def save_lists_to_file(filename, elev_list, dist_list):\n import numpy as np\n\n np.save(file=filename,arr=np.array([elev_list, dist_list]))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def save_enu(self, filename):\n x, y, z = self.get_coords_enu()\n coords = np.vstack([x, y, z]).T\n np.savetxt(filename, coords, fmt=b'%.12e')","def save_iantconfig(self, filename_root):\n x, y, z = self.get_coords_enu()\n d = np.ones_like(x) # set to 1 to avoid shadowing in iantconfig\n coords = np.vstack([d, x, y, z]).T\n coords = np.vstack([coords, [0, self.lon_deg, self.lat_deg, 0]])\n np.savetxt('%s.enu.%ix%i.txt' % (filename_root, x.size, 4),\n coords, fmt=b'%-5i %.12f %.12f %.12f')","def save(self, filename = 'array_zest', path = '/home/eric/dev/insitu/data/zs_recovery/'):\n filename = filename# + '_Lx_' + str(self.Lx) + 'm_Ly_' + str(self.Ly) + 'm'\n self.path_filename = path + filename + '.pkl'\n f = open(self.path_filename, 'wb')\n pickle.dump(self.__dict__, f, 2)\n f.close()","def save(self):\n filename = os.path.expanduser(\"~/\" + self.name)\n print(filename)\n np.savetxt(filename + \"_left.txt\", self.central)\n np.savetxt(filename + \"_right.txt\", self.boundaries)","def save(self):\n data = \"\"\n for y in xrange(0, BLOCK_NUM_HEIGHT):\n for x in xrange(0, BLOCK_NUM_WIDTH):\n data += self.blocks[y][x]\n data += '\\n'\n print data\n options = {'defaultextension': '.lvl',\n 'filetypes': [('Levels', '.lvl'), ('All files', '*')],\n 'initialdir': 'levels',\n 'initialfile': '',\n 'title': 'Save level'}\n # filename = tkFileDialog.asksaveasfile(**options)\n filename = asksaveasfilename(**options)\n if filename:\n with open(filename, \"w\") as level:\n level.write(data)","def save_band_for_path(self, path, filename):\n with open(filename, 'ab') as file_hander:\n for point in path:\n energies = self.problem.energy_eigenvalues(point[0], point[1])\n np.savetxt(file_hander, energies)","def save(self, filename):\n np.savetxt(\n filename,\n np.array([np.array(list(e)) for e in self]),\n fmt=\"%.03f\",\n delimiter=\"\\t\",\n )","def save_array(array, filename):\n np.save(filename, array)","def save(self, filename):\n\t\tnp.savetxt(filename, self.V)\n\t\treturn","def _save(self, data: np.ndarray) -> None:\n ...","def save(self, file):\n boulders = []\n elephants = []\n rhinos = []\n for i in range(5):\n for j in range(5):\n if self[i][j]!= 0:\n piece = self[i][j]\n L = []\n if not isinstance(self[i][j], Boulder):\n L.append(self[i][j].direction[0])\n L.append(self[i][j].direction[1])\n if piece.species == \"Elephant\":\n elephants.append(\"(\" + str(i) + \",\" + str(j)+ \") : np.array([\"+str(L[0])+ \",\" + str(L[1])+\"])\")\n elif piece.species == \"Rhinoceros\":\n rhinos.append(\"(\"+str(i)+\",\" +str(j)+ \") : np.array([\"+str(L[0]) + \",\" + str(L[1])+\"])\")\n elif isinstance(piece, Boulder):\n boulders.append(\"(\" + str(i) + \",\" + str(j) + \")\")\n file.write(\"# King of Siam GameFile \\n\\nplayer_turn {\\n \" + self.playerTurn + \"\\n}\\n\\n\")\n file.write(\"Boulder {\")\n for k in range(len(boulders)):\n file.write(\"\\n \" + boulders[k] + \";\")\n file.write(\"\\n}\\n\\nElephant {\")\n for elt in elephants:\n file.write(\"\\n \" + elt + \";\")\n file.write(\"\\n}\\n\\nRhinoceros {\")\n for elt in rhinos:\n file.write(\"\\n \" + elt + \";\")\n file.write(\"\\n}\")\n\n file.close()","def save_seed(self, seed: np.ndarray):\n print(\"Reconstructed trace saved as seed to \", CONFIG_DIR)\n np.savetxt(CONFIG_DIR / self.name_seed, seed.view(float).reshape(-1, 2))","def save_file(self):\n f = open(self._file_name, \"w\")\n try:\n for rental in self.list:\n rental_str = self.obj_to_string(rental)\n f.write(rental_str)\n f.close()\n except Exception as e:\n raise e","def save(self, path):\n\n if not os.path.exists(path):\n os.makedirs(path)\n\n np.save(os.path.join(path, 'V.npy'), self.V.cpu().numpy())\n\n if self.W is not None:\n np.save(os.path.join(path, 'W.npy'), self.W.cpu().numpy())\n\n if self.vb is not None:\n np.save(os.path.join(path, 'v_bias.npy'), self.vb.cpu().numpy())\n\n if self.wb is not None:\n np.save(os.path.join(path, 'w_bias.npy'), self.wb.cpu().numpy())\n\n if self.dictionary is not None:\n self.dictionary.save(os.path.join(path, 'dictionary'))","def outputPulses(self,filename):\n np.save(filename,self.getData())\n return","def save(self):\n\n if (self._save != '0'):\n p = self._save+self._path[-3:-1]+'_'+str(self._qn)+'.dat'\n np.savetxt(p, self._gf)\n else:\n sys.exit(\"Wrong path to save\")","def save_ASCII(self, filename):\n if not self.__check_flat_array__():\n if isinstance(self.mess_inst, MessagesGUI):\n self.mess_inst.message('No flattened array is present to save')\n else:\n print('No flattened array is present to save')\n return\n\n if isinstance(self.mess_inst, MessagesGUI):\n self.mess_inst.message('Saving ASCII file: {}'.format(filename))\n else:\n print('Saving ASCII file...')\n\n filename = filename.split('.')[0] + '.xyz'\n length = len(self.get_temp())\n self.flat_array[np.isnan(self.flat_array)] = 0 # Just make nan zero for ease\n\n min_vals = self.flat_array[self.temp_idx, :] - np.amin(self.flat_array[self.temp_idx, :])\n norm_temp = min_vals / np.amax(min_vals)\n\n with open(filename, 'w') as f:\n for i in range(length):\n f.write('{}\\t{}\\t{}\\t{}\\t{}\\r\\n'.format(self.flat_array[self.x_idx, i], self.flat_array[self.y_idx, i],\n self.flat_array[self.z_idx, i],\n self.flat_array[self.temp_idx, i], norm_temp[i]))","def saveexpvalues(erw, erwq):\n erwartung = np.zeros(len(erw))\n erwartungquad = np.zeros(len(erwq))\n for ii in range(0, len(erw)):\n erwartung[ii] = erw[ii]\n erwartungquad[ii] = erwq[ii]\n np.savetxt(\"expvalues.dat\", np.transpose([erwartung, erwartungquad]), fmt='%s')","def save2file(lis, path):\r\n np.save(path, np.array(lis))","def save(self, filename):\n fptr = open(filename, 'w')\n for node in self.val_l:\n fptr.write(str(node) + \" \" + str(self.val_l[node]) +\n \" \" + str(self.val_c[node]) + \"\\n\")\n fptr.close()","def saveeigenvalues(eigenvalue, fvalue, lvalue):\n eigenval = []\n for ii in range(fvalue, lvalue+1):\n test = eigenvalue[ii]\n eigenval.append(test)\n np.savetxt(\"energies.dat\", eigenval, fmt='%s')","def quick_save_array(data, file_name, delimiter=',', ):\n data.tofile(file_name, sep=delimiter)","def _save_edges(self, path_to_split: str) -> NoReturn:\n print(f'Save edges in {path_to_split}')\n np.save(f'{path_to_split}/train_edges.npy', self.train_edges)\n np.save(f'{path_to_split}/val_edges.npy', self.val_edges)\n np.save(f'{path_to_split}/test_edges.npy', self.test_edges)\n np.save(f'{path_to_split}/test_edges_false.npy', self.test_edges_false)\n np.save(f'{path_to_split}/val_edges_false.npy', self.val_edges_false)\n np.save(f'{path_to_split}/adj_train.npy', self.adj_train)","def save_pickle(self, filename):\n x, y, _ = self.get_coords_enu()\n cx, cy = self.get_centres_enu()\n coords = dict(x=x, y=y, cx=cx, cy=cy)\n pickle.dump(coords, open(filename, 'wb'))","def save(self, exp_file, gat_file):\n\t\tto_save = np.stack((self.b, self.sigma)) #(2, K)\n\t\tto_save = np.concatenate((self.W,to_save) , axis = 0) #(D+2,K)\n\t\tnp.savetxt(exp_file, to_save)\n\t\tself.gating.save(gat_file)\n\t\treturn","def save_file(self):\n # paginate over deputies and senators getting their fields\n fieldnames = set([])\n congressmen = self.deputies + self.senators\n for data in congressmen:\n fieldnames = fieldnames.union(data.dump().keys())\n\n\n with open(IDENTITY_FILE_UPDATED, 'a') as csvfile:\n writer = csv.DictWriter(csvfile, fieldnames=list(fieldnames), delimiter=';')\n writer.writeheader()\n\n for data in congressmen:\n writer.writerow(data.dump())","def save(file, arr, allow_pickle=True, fix_imports=True):\n\n return numpy.save(file, array_create.array(arr, bohrium=False), allow_pickle, fix_imports)","def save_file(self, filename):\n if self.t3data:\n np.savetxt(filename, self.t3data)\n else:\n self.export_to_ascii()","def saveToFile (self, filename=\"priv.key\"):\n key_file = open(filename, \"w\")\n key_file.write(str(self.lamb) + \";\" + str(self.mu))\n key_file.close()","def save(self, _name):\r\n try:\r\n with open(_name, 'w+') as fout:\r\n fout.write(\".cube file generated from prt_esolv.py\\n\")\r\n fout.write(f\"{_name}\\n\")\r\n\r\n fout.write(\r\n f\"{int(self.n_atoms)} {float(self.origin[0])} {float(self.origin[1])} {float(self.origin[2])}\\n\")\r\n\r\n fout.write(f\"{int(self.n_x)} {float(self.x[0])} {float(self.x[1])} {float(self.x[2])}\\n\")\r\n fout.write(f\"{int(self.n_y)} {float(self.y[0])} {float(self.y[1])} {float(self.y[2])}\\n\")\r\n fout.write(f\"{int(self.n_z)} {float(self.z[0])} {float(self.z[1])} {float(self.z[2])}\\n\")\r\n\r\n for atom, xyz in zip(self.atoms, self.atoms_xyz):\r\n fout.write(f\"{atom} 0 {xyz[0]} {xyz[1]} {xyz[2]}\\n\")\r\n\r\n for ix in range(self.n_x):\r\n for iy in range(self.n_y):\r\n for iz in range(self.n_z):\r\n fout.write(f\"{self.data[ix][iy][iz]}\")\r\n if iz % 6 == 5:\r\n fout.write('\\n')\r\n fout.write(\"\\n\")\r\n except IOError:\r\n print(f\"Can't create {_name} file!!!\")\r\n raise\r\n\r\n return None","def save_state(self, file):\n np.savez(file, z_mn=self.z_mn, theta=self.theta, phi=self.phi,\n z_best=self.z_best, ll_best=self.ll_best, log=self.log)","def save(self):\n # Sanity checks\n assert len(self.actions) == len(self.rewards)\n assert len(self.actions) == len(self.normalized_states)\n assert len(self.actions) == len(self.states)\n\n data = {\n 'rewards': np.array(self.rewards),\n 'actions': np.array(self.actions),\n 'states': np.array(self.states),\n 'normalized_states': np.array(self.normalized_states),\n }\n\n np.savez('{}/full_log.npz'.format(self.log_folder), **data)\n np.savez('{}/states_rewards.npz'.format(self.log_folder),\n **{'states': data['states'], 'rewards': data['rewards']})\n np.savez('{}/normalized_states_rewards.npz'.format(self.log_folder),\n **{'states': data['normalized_states'], 'rewards': data['rewards']})","def save(self, directory):\n for field in self.save_fields:\n np.save(pjoin(directory, field+'.npy'), self.__dict__[field])","def write_output(arr, filename):\n print('Started writing the output..')\n f = open(filename, 'w')\n for a in arr:\n f.write(str(a) + '\\n')\n f.close()\n print('Done!, Open the file to see the approved loans.')","def write_towhee_coord(self, filename):\n with open(filename, 'w') as f:\n df = self.contents[['X', 'Y', 'Z']].copy()\n np.savetxt(f, df.values, fmt=\" %20.15f\"*3)","def save(self, path_to_save):\n for item in self.data_array:\n item.save(path_to_save+item.file_name)","def save_data(self, filename, coordinates=True):\n\n if not coordinates:\n savetxt(self.wpath+filename, self.dataset, delimiter=',', fmt='%.18e,%.18e,%d,%s')\n else:\n print self.wpath+filename\n savetxt(self.wpath+filename, self.getDataCoordinates(), delimiter=',', fmt='%.18e,%.18e')","def save_eigval(self, eigval=None, infodir='auto', attribute=True, force_hdf5=True, save_png=False):\n # print 'mlat.save_eigval(): eigval = ', eigval\n if infodir == 'auto':\n infodir = dio.prepdir(self.lattice.lp['meshfn'])\n\n if eigval is None:\n eigval = self.get_eigval(attribute=attribute)\n\n # Naming\n basis_str = glatfns.get_basis_str(self)\n eigval_name = 'eigval' + self.lp['meshfn_exten'] + basis_str\n if force_hdf5:\n eigvalfn = dio.prepdir(self.lp['meshfn']) + 'eigvals_magnetic_gyro' + basis_str + '.hdf5'\n h5io.save_dset_hdf5(eigval, eigval_name, eigvalfn)\n else:\n eigvalfn = infodir + eigval_name + '.pkl'\n output = open(eigvalfn, 'wb')\n pickle.dump(eigval, output)\n output.close()\n\n if save_png:\n fig, DOS_ax = leplt.initialize_DOS_plot(eigval, 'gyro')\n plt.savefig(infodir + 'eigval_magnetic_gyro_hist' + self.lp['meshfn_exten'] + '.png')\n plt.clf()\n print 'Saved gyro DOS to ' + eigvalfn","def save(self):\n super(YacoFile, self).save(self._filename)","def save(self, filename):\n data = {\"sizes\": self.sizes,\n \"weights\": [w.tolist() for w in self.weights],\n \"biases\": [b.tolist() for b in self.biases]}\n f = open(filename, \"w\")\n json.dump(data, f)\n f.close()","def write_xyz_file(allxyz):\n if SAVEXYZ:\n print('+> Saving riverbed topography file...', end='')\n if MODE == 1:\n np.savetxt('kinoshita_topo.xyz', allxyz, fmt='%.6e')\n elif MODE == 2:\n np.savetxt(FNAME.rsplit('.', 1)[0] + '_topo.xyz', allxyz, fmt='%.6e')\n print(' [done]')","def save(self, filename):\n np.savez(temp_dir + '/' + filename + '.npz', chip_ids=self.chip_ids, core_ids=self.core_ids, cx_ids=self.cx_ids)","def save_EGRID( self , filename , output_unit = EclUnitTypeEnum.ERT_ECL_METRIC_UNITS):\n self._fwrite_EGRID2( filename, output_unit )","def save_numpy_array(self):\n np.save(\"smallest_particles.npy\", self.smallest_particles)\n np.save(\"number_counts.npy\", self.number_counts)\n np.save(\"number_counts_2.npy\", self.number_counts_2)","def save(self,outPath=None):\n if (not self.canSave): raise StateError(_(\"Insufficient data to write file.\"))\n if not outPath:\n fileInfo = self.fileInfo\n outPath = os.path.join(fileInfo.dir,fileInfo.name)\n out = file(outPath,'wb')\n #--Tes3 Record\n self.tes3.setChanged()\n self.tes3.hedr.setChanged()\n self.tes3.hedr.numRecords = len(self.records) #--numRecords AFTER TES3 record\n self.tes3.getSize()\n self.tes3.dump(out)\n #--Other Records\n for record in self.records:\n record.getSize()\n record.dump(out)\n out.close()","def toFile(self,fid):\n stack = []\n for w,b in self.stack:\n w.copy_to_host()\n b.copy_to_host()\n stack.append([w.numpy_array,b.numpy_array])\n\tpickle.dump(stack,fid)","def save(self, output, data):","def save(self, filename):\n with open(filename, 'w') as f:\n pickle.dump((self.mean, self.std_dev), f)","def save_array_as(arr, loc=None):\n if loc is None:\n root = tk.Tk()\n root.loc = filedialog.asksaveasfilename(initialdir=\"/\",\n title=\"Save as\",\n filetypes=((\"npy files\", \"*.npy\"),\n (\"all files\", \"*.*\"))\n )\n np.save(root.loc, arr)\n root.destroy()\n else:\n np.save(loc, arr)","def write_opal(self, file_name):\n \n return 0","def _toFile(self):\n pass","def sauvegarde(self):\r\n\r\n # On vérifie que le fichier existe\r\n # 'exists' est un booléen\r\n exists = os.path.isfile(\"cartes/Save.txt\")\r\n if exists:\r\n # Le fichier existe => On l'ouvre en écriture 'r'\r\n with open (\"cartes/Save.txt\",\"w\") as f: \r\n for elt in self.listeLignes:\r\n f.write(\"%s\" %elt)\r\n else:\r\n with open (\"cartes/Save.txt\",\"x\") as f: \r\n # Le fichier n'existe pas, on le créer et on l'ouvre en écriture 'x'\r\n for elt in self.listeLignes:\r\n f.write(\"%s\" %elt)","def savemat(self, file_name):\n d = {'dG0_prime': self.dG0_prime,\n 'dG0': self.dG0,\n 'T': self.T,\n 'I': self.I,\n 'pH': self.pH,\n 'pMg': self.pMg,\n 'weight': self.weight,\n 'cids': self.cids,\n 'S': self.S.values}\n savemat(file_name, d, oned_as='row')","def savepotentialtest(pot, xx, path):\n potential = []\n coordinates = []\n for ii in range(0, len(pot)):\n coordinates.append(xx[ii])\n potential.append(pot[ii])\n np.savetxt(path, np.transpose([coordinates, potential]))","def filemenu_Export(self):\n line_dict = {}\n for line in self.lines.values():\n for name, arr in line.to_mat().items():\n line_dict[name] = arr\n fileTypes = [(\"MATLAB file\",\"*.mat\"), (\"NumPy file\",\"*.npz\")]\n options = {}\n options['initialdir'] = os.path.expanduser('~')\n options['filetypes'] = fileTypes\n options['parent'] = self.master\n filename = filedialog.asksaveasfilename(**options)\n if filename:\n _, ext = os.path.splitext(filename)\n if ext == \".mat\":\n sio.savemat(filename, line_dict)\n elif ext == \".npz\":\n np.savez(filename, lines=line_dict)","def save(self, fname):\n fmt = \" %7.1f %7.1f %8.2f %8.2f %8.2f %8.3f %8.3f %8.3f %8.3f %6.1f\"\n with open(fname, 'wb') as fid:\n fid.write('# CoordinateSystem \"Head\"\\n'.encode('utf-8'))\n fid.write('# begin end X (mm) Y (mm) Z (mm)'\n ' Q(nAm) Qx(nAm) Qy(nAm) Qz(nAm) g/%\\n'\n .encode('utf-8'))\n t = self.times[:, np.newaxis] * 1000.\n gof = self.gof[:, np.newaxis]\n amp = 1e9 * self.amplitude[:, np.newaxis]\n out = np.concatenate((t, t, self.pos / 1e-3, amp,\n self.ori * amp, gof), axis=-1)\n np.savetxt(fid, out, fmt=fmt)\n if self.name is not None:\n fid.write(('## Name \"%s dipoles\" Style \"Dipoles\"'\n % self.name).encode('utf-8'))","def save(self, filename):\n pass","def save_data(self, f): \n if not self.sampling:\n self.convert_to_array()\n np.save(f, self.reads)","def save_calibration(filename):\n pass","def test_save_as_ascii(self):\n array = np.array([0, 1, 3])\n errors = np.array([1, 1, 1])\n hen.io.save_as_ascii(\n [array, errors],\n filename=os.path.join(self.datadir, \"monol_test.txt\"),\n colnames=[\"array\", \"err\"])","def write_checkpoint(self):\n self.file_checkpoint_data = open(self.path_checkpoint, \"a+\")\n array_to_write = [str(self.radious), self.type_feature, self.type_filtering, self.h_filterig]\n self.file_checkpoint_data.write(','.join(array_to_write) + \"\\n\")\n self.file_checkpoint_data.flush()","def save(self, fname):\n pass","def save_data_to_disk(self):\n Omega_M = self.theta_fid[0]\n for key in self.data.keys():\n np.save(f'./preloaded_data/{Omega_M}_{self.delta_theta[0]}_{key}.npy', self.data[key])","def analysis_save(plotables,analysis_attributes,file_name):\n#TODO implement error handling\n for (plotable,plt_type), ana_attr in zip(plotables,analysis_attributes):\n scipy.io.savemat(\n \"{0}_{1}\".format(file_name,str(ana_attr)),\n { plt_type: plotable }\n )","def save(self, path):\n individual = self.population.fittest_individual()\n order = [int(l) for l in individual.label_order]\n fitness = individual.fitness\n data = {'name': self.ds.name,\n 'num_labels': len(order),\n 'order': order,\n 'fitness': fitness\n }\n with open(path, 'w') as f:\n json.dump(data, f)","def save(self,filepath):\n d = self.X.tocoo(copy=False)\n v = self.col_view.tocoo(copy=False)\n np.savez(filepath,row=d.row,col=d.col,data=d.data,shape=d.shape,\n v_row=v.row,v_col=v.col,v_data=v.data,v_shape=v.shape)","def save_offsets(offsets_hres, offsets_std, savePath):\n check_folder(savePath)\n \n with open(pjn(savePath,'offsets_hres.npy'), 'wb') as f:\n np.save(f, offsets_hres) \n with open(pjn(savePath, 'offsets_std.npy'), 'wb') as f:\n np.save(f, offsets_std)","def save_values(self):\n f_name = self.img_path.split('.')[0] + '_{}_'.\\\n format(self.data_type_name) + '.csv'\n dir_name = os.path.join(self.base_dir, f_name)\n if not os.path.exists(dir_name):\n for data_list in self.converted_values():\n with open(f_name, 'a') as f:\n wr = csv.writer(f, delimiter=';')\n wr.writerow(data_list)\n else:\n os.remove(f_name)\n for data_list in self.converted_values():\n with open(f_name, 'a') as f:\n wr = csv.writer(f, delimiter=';')\n wr.writerow(data_list)","def write(self,data): \n if not os.path.exists(self.output_dir):\n os.makedirs(self.output_dir)\n\n # We will store these in a separate file and link them to the level2s\n fname = data.filename.split('/')[-1]\n \n if os.path.exists(self.outfile):\n output = h5py.File(self.outfile,'a')\n else:\n output = h5py.File(self.outfile,'w')\n\n # Set permissions and group\n if self.set_permissions:\n try:\n os.chmod(self.outfile,0o664)\n shutil.chown(self.outfile, group=self.permissions_group)\n except PermissionError:\n self.logger(f'{fname}:{self.name}: Warning, couldnt set the file permissions.')\n\n # Store datasets in root\n data_out = {'tod':self.all_tod,\n 'weights':self.all_weights,\n 'mask':self.all_mask,\n 'cal_factors':self.all_cal_factors,\n 'frequency':self.all_frequency,\n 'auto_rms':self.all_auto}\n\n for dname, dset in data_out.items():\n if dname in output:\n del output[dname]\n output.create_dataset(dname, data=dset)\n\n output.attrs['version'] = __level3_version__\n output['cal_factors'].attrs['source'] = self.cal_source\n output['cal_factors'].attrs['calibrator_obsid'] = self.nearest_calibrator\n\n output.close()\n \n if self.level3 in data.keys():\n del data[self.level3]\n data[self.level3] = h5py.ExternalLink(self.outfile,'/')","def writeout(self):\n out_file = ''.join(['theta_w_t', str(self.t), '.dat'])\n data_list = [] \n\n for i in xrange(self.n_params): \n data_list.append( self.theta_t[i,:] ) \n\n data_list.append(self.w_t)\n\n np.savetxt(\n out_file, \n (np.vstack(np.array(data_list))).T, \n delimiter='\\t'\n )\n\n return None","def save(self, file, name):\n np.savetxt(os.path.join(file, name), self.matrix, fmt='%f')","def dumpCoordinatesToFile(self, coordinate_ids): \n coordinate_ids_dump_file = open(self.COORDINATES_DUMP_FNAME , 'w')\n pickle.dump(coordinate_ids, coordinate_ids_dump_file)\n coordinate_ids_dump_file.close()","def __savePreProcessedData(self):\n np.savetxt(self.X_filename, self.X, delimiter=',')\n np.savetxt(self.y_filename, self.le.fit_transform(self.y), delimiter=',')\n #Need to save the label Enconder to inverse transform later\n joblib.dump(self.le, self.le_filename)\n\n print(\"Saved X and y\")","def save(self, path_to_save):\n data_to_save = []\n for item in self.data_array:\n if isinstance(item, Result):\n data_to_save.append(item.get())\n\n np.savetxt(path_to_save+'.txt', data_to_save, fmt='%5s', delimiter=',')","def save_to_xyz(self, filename): \n with open( filename, 'a' ) as F:\n F = open( filename, 'a' )\n F.write( '%d\\n'%self.num_atoms )\n F.write( \"XYZ\\n\" )\n for num,row in enumerate(self.atoms):\n try:\n F.write('%s '%self.species[num])\n except:\n F.write('X%d '%num)\n F.write( mat2str( row, \"%16.10f\" ) )\n F.write( \"\\n\" )","def savealist(alist, filename):\n out = open(filename, \"w\")\n for i in alist:\n out.write(str(i) + \"\\n\") # if i is numeric\n out.close()","def store(self, filename):","def store(obj, filename, suffix = ''):\n # It is a numpy array\n if type(obj) == np.ndarray:\n path,f = writefile(filename, obj_id='numpy_objs', suffix=suffix)\n json.dump(obj, fp=f, cls=NumpyEncoder,\n separators=(',', ':'), sort_keys=True, indent=4)\n print '> saved with JSON to {}'.format(path)\n else:\n path, f = writefile(filename, obj_id='other_objs', suffix=suffix)\n pickle.dump(obj, file=f)\n print '> saved with dill (pickled) to {}'.format(path)\n return path","def writexyz(self,fname):\n xyzfile = open(fname + \".xyz\",\"a+\")\n xyzfile.write(str(self.natoms) + \"\\n\\n\")\n for a in self.atoms:\n \tcxyz = a.xyz - np.array(self.pbc_correction(a.xyz))\n\t\t\txyzfile.write(str(a.type) + \"\\t\" + str(cxyz[0]) + \"\\t\" + str(cxyz[1]) + \"\\t\" + str(cxyz[2]) + \"\\n\")\n xyzfile.close()","def save(self, filename, type='CSV'):\n # Convenient form for saving:\n save = np.ndarray(shape=(self.Pbrem.shape[0]+1, self.Pbrem.shape[1]), dtype=np.float)\n save[0,:] = self.time\n save[1:,:] = self.Pbrem\n\n if type == 'CSV':\n with open(filename, 'wb') as file:\n np.savetxt(file, save, delimiter=',', header='Time,Total,Fuel,Shell\\n')\n\n elif type == 'pickle':\n with open(filename, 'wb') as file:\n pickle.dump(save, file)","def eeg_writeavr(array,tsb,di,file):\t\t\n import shutil as shu\n f=open(file,'w')\n firstline = 'Npts= %i TSB= %i DI= %7.5f SB= %7.5f SC= %i NChan= %i\\n' %(array.shape[1],tsb,di,1,200,array.shape[0]) \n chnam = 'Cz FP1 FP2 F3 F4 C3 C4 P3 P4 O1 O2 F7 F8 T7 T8 P7 P8 Fz Pz FC1 FC2 CP1 CP2 FC5 FC6 CP5 CP6 FT9 FT10 TP9 TP10 PO9 PO10\\n'\n f.write(firstline)\n f.write(chnam)\n for i in range(array.shape[0]):\n tmp = array[i,:]\n f.write(('%7.5f ' * len(tmp)) %tuple(tmp))\n f.write('\\n')\n \n f.close()\n #may want to change this on different machines...\n src = '/Users/crislanting/Projects/EEG/data/33.elp'\n dest = file[:-4] + '.elp'\n shu.copyfile(src,dest)","def save_values(self):\n # TODO: Add self.prefix and extension\n NetworkTables.saveEntries(self.file.get_filename(), prefix='/vision/' + self.name + '_')","def save_per_gene(filename, tn_per_gene, reads_per_gene, aliases_designation):\n\n with open(filename, \"w\") as f:\n\n f.write(\"Gene name\\tNumber of transposons per gene\\tNumber of reads per gene\\n\")\n\n for gene in tn_per_gene:\n tnpergene = tn_per_gene[gene]\n readpergene = reads_per_gene[gene]\n if gene in aliases_designation:\n gene_alias = aliases_designation.get(gene)[0]\n else:\n gene_alias = gene\n f.write(gene_alias + \"\\t\" + str(tnpergene) + \"\\t\" + str(readpergene) + \"\\n\")","def save(self, filename):\n data = {\"sizes\": self.sizes,\n \"weights\": [w.tolist() for w in self.weights],\n \"biases\": [b.tolist() for b in self.biases],\n \"cost\": str(self.cost.__name__)}\n f = open(filename, \"w\")\n json.dump(data, f)\n f.close()","def save_to_array(arr_name, arr_object):\n return np.save(arr_name, arr_object)","def SaveToFile(self):\n\n if len(self.paris) == 0:\n with open(self.fileLoc, \"w\") as file:\n file.write(\" \")\n return\n\n data = \"\"\n for x in self.paris.iterkeys():\n data += \"%\" + x + \":\" + self.paris[x] + \"%\"\n \n data = self.Encrypt(data)\n\n with open(self.fileLoc, \"w\") as file:\n file.write(data)","def save(self):\n with open(self.slide_coords_file, 'w') as f:\n json.dump(self.dump(), f)","def save_traces(traces, save_dir, file_format=\"MSEED\"):\n for event in traces:\n if config.dir_per_event and len(event) > 0:\n base_dir_name = event[0][4]\n if len(event[0]) == 7 and event[0][6] is not None:\n base_dir_name = event[0][6]\n dir_name = base_dir_name\n index = 0\n while os.path.isdir(save_dir + '/' + dir_name):\n dir_name = base_dir_name + str(index)\n index += 1\n os.mkdir(save_dir + '/' + dir_name)\n for x in event:\n try:\n if config.dir_per_event:\n file_name = x[1] + '.' + x[3] + '.' + x[5]\n index = 0\n while os.path.isfile(save_dir + '/' + dir_name + '/' + file_name):\n file_name = x[1] + '.' + x[5] + '.' + str(index)\n index += 1\n x[0].write(save_dir + '/' + dir_name + '/' + file_name, format=file_format)\n else:\n file_name = x[1] + '.' + x[5]\n index = 0\n while os.path.isfile(save_dir + '/' + file_name):\n file_name = x[1] + '.' + x[5] + '.' + str(index)\n index += 1\n\n x[0].write(save_dir + '/' + file_name, format=file_format)\n except InternalMSEEDError:\n logging.warning(str(InternalMSEEDError))\n except OSError:\n logging.warning(str(OSError))","def save_new_joint_angles(self,save_file):\n with open(directory + save_file, \"w\") as outfile:\n writer = csv.writer(outfile)\n writer.writerow(robot.joint_angles.values())\n outfile.close()","def __saveKnownAtlases(self):\n\n if self.__atlasDescs is None:\n return\n\n atlases = []\n\n for desc in self.__atlasDescs:\n atlases.append((desc.atlasID, desc.specPath))\n\n atlases = ['{}={}'.format(name, path) for name, path in atlases]\n atlases = op.pathsep.join(atlases)\n\n fslsettings.write('fsl.data.atlases', atlases)","def savez(d,file):\n np.savez(file,row=d.row,col=d.col,data=d.data,shape=d.shape)","def save_data(self, speaker_name, data):\n if not os.path.exists(self.data_dir):\n os.makedirs(self.data_dir)\n \n path = os.path.join(self.data_dir, speaker_name + \".pkl\")\n np.array(data).dump(path)","def symSave(saveMe,saveFile='symsave'):\n indices = np.triu_indices_from(saveMe)\n np.save(saveFile,saveMe[indices])","def write_array(uri: str):\n a1_data = np.reshape(np.arange(1, 26), (5, 5))\n l1_data = np.arange(5, 0, -1)\n l2_data = np.arange(-2, 3)\n l3_data = np.linspace(-1.0, 1.0, 5)\n with tiledb.open(uri, \"w\") as array:\n array[:] = {\"a1\": a1_data, \"l1\": l1_data, \"l2\": l2_data, \"l3\": l3_data}","def write_data_to_file(pos, fps, data_file):\n xs = []\n for x,y in pos:\n xs.append(x)\n with open(data_file,'wb') as f:\n np.save(f,pos)\n np.save(f,xs)\n np.save(f,fps)","def saveeigenvaluestest(eigenValue, fvalue, lvalue, path):\n chEigen = []\n for ii in range(fvalue, lvalue+1):\n test = eigenValue[ii]\n chEigen.append(test)\n np.savetxt(path, chEigen, fmt='%s')","def save_chain_to_file(config_dict, samplesOutlet, samplesInlet, samplesFD, logPostList, w_num):\n outlet_path = f\"outputs/{config_dict['dir_name']}/AIES_LWR-outlet-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-walker{w_num}.txt\"\n inlet_path = f\"outputs/{config_dict['dir_name']}/AIES_LWR-inlet-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-walker{w_num}.txt\"\n FD_path = f\"outputs/{config_dict['dir_name']}/AIES_LWR-FD-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-walker{w_num}.txt\"\n logPostList_path = f\"outputs/{config_dict['dir_name']}/AIES_LWR-FD-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-LogPostList.txt\"\n np.savetxt(outlet_path, samplesOutlet)\n np.savetxt(inlet_path, samplesInlet)\n np.savetxt(FD_path, samplesFD)\n np.savetxt(logPostList_path, logPostList)\n\n Run_settings = gen_run_setting_str(config_dict)\n run_settings_path = f\"outputs/{config_dict['dir_name']}/run_settings.txt\"\n with open(run_settings_path, 'w') as f:\n f.write(Run_settings)\n if config_dict[\"save_to_S3\"] == True:\n upload_chain(s3_path=os.path.join(\"AIES_LWR\", outlet_path), local_path=outlet_path)\n upload_chain(s3_path=os.path.join(\"AIES_LWR\", inlet_path), local_path=inlet_path)\n upload_chain(s3_path=os.path.join(\"AIES_LWR\", FD_path), local_path=FD_path)\n upload_chain(s3_path=os.path.join(\"AIES_LWR\", logPostList_path), local_path=logPostList_path)\n upload_chain(s3_path=os.path.join(\"AIES_LWR\", run_settings_path), local_path=run_settings_path)","def save(self, filename):\n np.savez(temp_dir + '/' + filename + '.npz', core_ids=self.core_ids, cx_ids=self.cx_ids)","def save_to_array(x, y):\n\n with open(settings.data(\"x.npy\"), \"wb\") as file:\n np.save(file, x)\n\n with open(settings.data(\"y.npy\"), \"wb\") as file:\n np.save(file, y)","def tofile(self, filename:'Union[str, Path]'):\n\n with open(filename, mode='w') as file:\n dims = ','.join(map(str, self._dims))\n file.write(f'dims={dims}\\n')\n for dim, axes in self.items():\n if isinstance(axes, dict):\n axes = ','.join(map(str, axesiter(axes)))\n file.write(f'axes={axes}\\n')\n else:\n file.write(f'dim={axes}\\n')"],"string":"[\n \"def save_enu(self, filename):\\n x, y, z = self.get_coords_enu()\\n coords = np.vstack([x, y, z]).T\\n np.savetxt(filename, coords, fmt=b'%.12e')\",\n \"def save_iantconfig(self, filename_root):\\n x, y, z = self.get_coords_enu()\\n d = np.ones_like(x) # set to 1 to avoid shadowing in iantconfig\\n coords = np.vstack([d, x, y, z]).T\\n coords = np.vstack([coords, [0, self.lon_deg, self.lat_deg, 0]])\\n np.savetxt('%s.enu.%ix%i.txt' % (filename_root, x.size, 4),\\n coords, fmt=b'%-5i %.12f %.12f %.12f')\",\n \"def save(self, filename = 'array_zest', path = '/home/eric/dev/insitu/data/zs_recovery/'):\\n filename = filename# + '_Lx_' + str(self.Lx) + 'm_Ly_' + str(self.Ly) + 'm'\\n self.path_filename = path + filename + '.pkl'\\n f = open(self.path_filename, 'wb')\\n pickle.dump(self.__dict__, f, 2)\\n f.close()\",\n \"def save(self):\\n filename = os.path.expanduser(\\\"~/\\\" + self.name)\\n print(filename)\\n np.savetxt(filename + \\\"_left.txt\\\", self.central)\\n np.savetxt(filename + \\\"_right.txt\\\", self.boundaries)\",\n \"def save(self):\\n data = \\\"\\\"\\n for y in xrange(0, BLOCK_NUM_HEIGHT):\\n for x in xrange(0, BLOCK_NUM_WIDTH):\\n data += self.blocks[y][x]\\n data += '\\\\n'\\n print data\\n options = {'defaultextension': '.lvl',\\n 'filetypes': [('Levels', '.lvl'), ('All files', '*')],\\n 'initialdir': 'levels',\\n 'initialfile': '',\\n 'title': 'Save level'}\\n # filename = tkFileDialog.asksaveasfile(**options)\\n filename = asksaveasfilename(**options)\\n if filename:\\n with open(filename, \\\"w\\\") as level:\\n level.write(data)\",\n \"def save_band_for_path(self, path, filename):\\n with open(filename, 'ab') as file_hander:\\n for point in path:\\n energies = self.problem.energy_eigenvalues(point[0], point[1])\\n np.savetxt(file_hander, energies)\",\n \"def save(self, filename):\\n np.savetxt(\\n filename,\\n np.array([np.array(list(e)) for e in self]),\\n fmt=\\\"%.03f\\\",\\n delimiter=\\\"\\\\t\\\",\\n )\",\n \"def save_array(array, filename):\\n np.save(filename, array)\",\n \"def save(self, filename):\\n\\t\\tnp.savetxt(filename, self.V)\\n\\t\\treturn\",\n \"def _save(self, data: np.ndarray) -> None:\\n ...\",\n \"def save(self, file):\\n boulders = []\\n elephants = []\\n rhinos = []\\n for i in range(5):\\n for j in range(5):\\n if self[i][j]!= 0:\\n piece = self[i][j]\\n L = []\\n if not isinstance(self[i][j], Boulder):\\n L.append(self[i][j].direction[0])\\n L.append(self[i][j].direction[1])\\n if piece.species == \\\"Elephant\\\":\\n elephants.append(\\\"(\\\" + str(i) + \\\",\\\" + str(j)+ \\\") : np.array([\\\"+str(L[0])+ \\\",\\\" + str(L[1])+\\\"])\\\")\\n elif piece.species == \\\"Rhinoceros\\\":\\n rhinos.append(\\\"(\\\"+str(i)+\\\",\\\" +str(j)+ \\\") : np.array([\\\"+str(L[0]) + \\\",\\\" + str(L[1])+\\\"])\\\")\\n elif isinstance(piece, Boulder):\\n boulders.append(\\\"(\\\" + str(i) + \\\",\\\" + str(j) + \\\")\\\")\\n file.write(\\\"# King of Siam GameFile \\\\n\\\\nplayer_turn {\\\\n \\\" + self.playerTurn + \\\"\\\\n}\\\\n\\\\n\\\")\\n file.write(\\\"Boulder {\\\")\\n for k in range(len(boulders)):\\n file.write(\\\"\\\\n \\\" + boulders[k] + \\\";\\\")\\n file.write(\\\"\\\\n}\\\\n\\\\nElephant {\\\")\\n for elt in elephants:\\n file.write(\\\"\\\\n \\\" + elt + \\\";\\\")\\n file.write(\\\"\\\\n}\\\\n\\\\nRhinoceros {\\\")\\n for elt in rhinos:\\n file.write(\\\"\\\\n \\\" + elt + \\\";\\\")\\n file.write(\\\"\\\\n}\\\")\\n\\n file.close()\",\n \"def save_seed(self, seed: np.ndarray):\\n print(\\\"Reconstructed trace saved as seed to \\\", CONFIG_DIR)\\n np.savetxt(CONFIG_DIR / self.name_seed, seed.view(float).reshape(-1, 2))\",\n \"def save_file(self):\\n f = open(self._file_name, \\\"w\\\")\\n try:\\n for rental in self.list:\\n rental_str = self.obj_to_string(rental)\\n f.write(rental_str)\\n f.close()\\n except Exception as e:\\n raise e\",\n \"def save(self, path):\\n\\n if not os.path.exists(path):\\n os.makedirs(path)\\n\\n np.save(os.path.join(path, 'V.npy'), self.V.cpu().numpy())\\n\\n if self.W is not None:\\n np.save(os.path.join(path, 'W.npy'), self.W.cpu().numpy())\\n\\n if self.vb is not None:\\n np.save(os.path.join(path, 'v_bias.npy'), self.vb.cpu().numpy())\\n\\n if self.wb is not None:\\n np.save(os.path.join(path, 'w_bias.npy'), self.wb.cpu().numpy())\\n\\n if self.dictionary is not None:\\n self.dictionary.save(os.path.join(path, 'dictionary'))\",\n \"def outputPulses(self,filename):\\n np.save(filename,self.getData())\\n return\",\n \"def save(self):\\n\\n if (self._save != '0'):\\n p = self._save+self._path[-3:-1]+'_'+str(self._qn)+'.dat'\\n np.savetxt(p, self._gf)\\n else:\\n sys.exit(\\\"Wrong path to save\\\")\",\n \"def save_ASCII(self, filename):\\n if not self.__check_flat_array__():\\n if isinstance(self.mess_inst, MessagesGUI):\\n self.mess_inst.message('No flattened array is present to save')\\n else:\\n print('No flattened array is present to save')\\n return\\n\\n if isinstance(self.mess_inst, MessagesGUI):\\n self.mess_inst.message('Saving ASCII file: {}'.format(filename))\\n else:\\n print('Saving ASCII file...')\\n\\n filename = filename.split('.')[0] + '.xyz'\\n length = len(self.get_temp())\\n self.flat_array[np.isnan(self.flat_array)] = 0 # Just make nan zero for ease\\n\\n min_vals = self.flat_array[self.temp_idx, :] - np.amin(self.flat_array[self.temp_idx, :])\\n norm_temp = min_vals / np.amax(min_vals)\\n\\n with open(filename, 'w') as f:\\n for i in range(length):\\n f.write('{}\\\\t{}\\\\t{}\\\\t{}\\\\t{}\\\\r\\\\n'.format(self.flat_array[self.x_idx, i], self.flat_array[self.y_idx, i],\\n self.flat_array[self.z_idx, i],\\n self.flat_array[self.temp_idx, i], norm_temp[i]))\",\n \"def saveexpvalues(erw, erwq):\\n erwartung = np.zeros(len(erw))\\n erwartungquad = np.zeros(len(erwq))\\n for ii in range(0, len(erw)):\\n erwartung[ii] = erw[ii]\\n erwartungquad[ii] = erwq[ii]\\n np.savetxt(\\\"expvalues.dat\\\", np.transpose([erwartung, erwartungquad]), fmt='%s')\",\n \"def save2file(lis, path):\\r\\n np.save(path, np.array(lis))\",\n \"def save(self, filename):\\n fptr = open(filename, 'w')\\n for node in self.val_l:\\n fptr.write(str(node) + \\\" \\\" + str(self.val_l[node]) +\\n \\\" \\\" + str(self.val_c[node]) + \\\"\\\\n\\\")\\n fptr.close()\",\n \"def saveeigenvalues(eigenvalue, fvalue, lvalue):\\n eigenval = []\\n for ii in range(fvalue, lvalue+1):\\n test = eigenvalue[ii]\\n eigenval.append(test)\\n np.savetxt(\\\"energies.dat\\\", eigenval, fmt='%s')\",\n \"def quick_save_array(data, file_name, delimiter=',', ):\\n data.tofile(file_name, sep=delimiter)\",\n \"def _save_edges(self, path_to_split: str) -> NoReturn:\\n print(f'Save edges in {path_to_split}')\\n np.save(f'{path_to_split}/train_edges.npy', self.train_edges)\\n np.save(f'{path_to_split}/val_edges.npy', self.val_edges)\\n np.save(f'{path_to_split}/test_edges.npy', self.test_edges)\\n np.save(f'{path_to_split}/test_edges_false.npy', self.test_edges_false)\\n np.save(f'{path_to_split}/val_edges_false.npy', self.val_edges_false)\\n np.save(f'{path_to_split}/adj_train.npy', self.adj_train)\",\n \"def save_pickle(self, filename):\\n x, y, _ = self.get_coords_enu()\\n cx, cy = self.get_centres_enu()\\n coords = dict(x=x, y=y, cx=cx, cy=cy)\\n pickle.dump(coords, open(filename, 'wb'))\",\n \"def save(self, exp_file, gat_file):\\n\\t\\tto_save = np.stack((self.b, self.sigma)) #(2, K)\\n\\t\\tto_save = np.concatenate((self.W,to_save) , axis = 0) #(D+2,K)\\n\\t\\tnp.savetxt(exp_file, to_save)\\n\\t\\tself.gating.save(gat_file)\\n\\t\\treturn\",\n \"def save_file(self):\\n # paginate over deputies and senators getting their fields\\n fieldnames = set([])\\n congressmen = self.deputies + self.senators\\n for data in congressmen:\\n fieldnames = fieldnames.union(data.dump().keys())\\n\\n\\n with open(IDENTITY_FILE_UPDATED, 'a') as csvfile:\\n writer = csv.DictWriter(csvfile, fieldnames=list(fieldnames), delimiter=';')\\n writer.writeheader()\\n\\n for data in congressmen:\\n writer.writerow(data.dump())\",\n \"def save(file, arr, allow_pickle=True, fix_imports=True):\\n\\n return numpy.save(file, array_create.array(arr, bohrium=False), allow_pickle, fix_imports)\",\n \"def save_file(self, filename):\\n if self.t3data:\\n np.savetxt(filename, self.t3data)\\n else:\\n self.export_to_ascii()\",\n \"def saveToFile (self, filename=\\\"priv.key\\\"):\\n key_file = open(filename, \\\"w\\\")\\n key_file.write(str(self.lamb) + \\\";\\\" + str(self.mu))\\n key_file.close()\",\n \"def save(self, _name):\\r\\n try:\\r\\n with open(_name, 'w+') as fout:\\r\\n fout.write(\\\".cube file generated from prt_esolv.py\\\\n\\\")\\r\\n fout.write(f\\\"{_name}\\\\n\\\")\\r\\n\\r\\n fout.write(\\r\\n f\\\"{int(self.n_atoms)} {float(self.origin[0])} {float(self.origin[1])} {float(self.origin[2])}\\\\n\\\")\\r\\n\\r\\n fout.write(f\\\"{int(self.n_x)} {float(self.x[0])} {float(self.x[1])} {float(self.x[2])}\\\\n\\\")\\r\\n fout.write(f\\\"{int(self.n_y)} {float(self.y[0])} {float(self.y[1])} {float(self.y[2])}\\\\n\\\")\\r\\n fout.write(f\\\"{int(self.n_z)} {float(self.z[0])} {float(self.z[1])} {float(self.z[2])}\\\\n\\\")\\r\\n\\r\\n for atom, xyz in zip(self.atoms, self.atoms_xyz):\\r\\n fout.write(f\\\"{atom} 0 {xyz[0]} {xyz[1]} {xyz[2]}\\\\n\\\")\\r\\n\\r\\n for ix in range(self.n_x):\\r\\n for iy in range(self.n_y):\\r\\n for iz in range(self.n_z):\\r\\n fout.write(f\\\"{self.data[ix][iy][iz]}\\\")\\r\\n if iz % 6 == 5:\\r\\n fout.write('\\\\n')\\r\\n fout.write(\\\"\\\\n\\\")\\r\\n except IOError:\\r\\n print(f\\\"Can't create {_name} file!!!\\\")\\r\\n raise\\r\\n\\r\\n return None\",\n \"def save_state(self, file):\\n np.savez(file, z_mn=self.z_mn, theta=self.theta, phi=self.phi,\\n z_best=self.z_best, ll_best=self.ll_best, log=self.log)\",\n \"def save(self):\\n # Sanity checks\\n assert len(self.actions) == len(self.rewards)\\n assert len(self.actions) == len(self.normalized_states)\\n assert len(self.actions) == len(self.states)\\n\\n data = {\\n 'rewards': np.array(self.rewards),\\n 'actions': np.array(self.actions),\\n 'states': np.array(self.states),\\n 'normalized_states': np.array(self.normalized_states),\\n }\\n\\n np.savez('{}/full_log.npz'.format(self.log_folder), **data)\\n np.savez('{}/states_rewards.npz'.format(self.log_folder),\\n **{'states': data['states'], 'rewards': data['rewards']})\\n np.savez('{}/normalized_states_rewards.npz'.format(self.log_folder),\\n **{'states': data['normalized_states'], 'rewards': data['rewards']})\",\n \"def save(self, directory):\\n for field in self.save_fields:\\n np.save(pjoin(directory, field+'.npy'), self.__dict__[field])\",\n \"def write_output(arr, filename):\\n print('Started writing the output..')\\n f = open(filename, 'w')\\n for a in arr:\\n f.write(str(a) + '\\\\n')\\n f.close()\\n print('Done!, Open the file to see the approved loans.')\",\n \"def write_towhee_coord(self, filename):\\n with open(filename, 'w') as f:\\n df = self.contents[['X', 'Y', 'Z']].copy()\\n np.savetxt(f, df.values, fmt=\\\" %20.15f\\\"*3)\",\n \"def save(self, path_to_save):\\n for item in self.data_array:\\n item.save(path_to_save+item.file_name)\",\n \"def save_data(self, filename, coordinates=True):\\n\\n if not coordinates:\\n savetxt(self.wpath+filename, self.dataset, delimiter=',', fmt='%.18e,%.18e,%d,%s')\\n else:\\n print self.wpath+filename\\n savetxt(self.wpath+filename, self.getDataCoordinates(), delimiter=',', fmt='%.18e,%.18e')\",\n \"def save_eigval(self, eigval=None, infodir='auto', attribute=True, force_hdf5=True, save_png=False):\\n # print 'mlat.save_eigval(): eigval = ', eigval\\n if infodir == 'auto':\\n infodir = dio.prepdir(self.lattice.lp['meshfn'])\\n\\n if eigval is None:\\n eigval = self.get_eigval(attribute=attribute)\\n\\n # Naming\\n basis_str = glatfns.get_basis_str(self)\\n eigval_name = 'eigval' + self.lp['meshfn_exten'] + basis_str\\n if force_hdf5:\\n eigvalfn = dio.prepdir(self.lp['meshfn']) + 'eigvals_magnetic_gyro' + basis_str + '.hdf5'\\n h5io.save_dset_hdf5(eigval, eigval_name, eigvalfn)\\n else:\\n eigvalfn = infodir + eigval_name + '.pkl'\\n output = open(eigvalfn, 'wb')\\n pickle.dump(eigval, output)\\n output.close()\\n\\n if save_png:\\n fig, DOS_ax = leplt.initialize_DOS_plot(eigval, 'gyro')\\n plt.savefig(infodir + 'eigval_magnetic_gyro_hist' + self.lp['meshfn_exten'] + '.png')\\n plt.clf()\\n print 'Saved gyro DOS to ' + eigvalfn\",\n \"def save(self):\\n super(YacoFile, self).save(self._filename)\",\n \"def save(self, filename):\\n data = {\\\"sizes\\\": self.sizes,\\n \\\"weights\\\": [w.tolist() for w in self.weights],\\n \\\"biases\\\": [b.tolist() for b in self.biases]}\\n f = open(filename, \\\"w\\\")\\n json.dump(data, f)\\n f.close()\",\n \"def write_xyz_file(allxyz):\\n if SAVEXYZ:\\n print('+> Saving riverbed topography file...', end='')\\n if MODE == 1:\\n np.savetxt('kinoshita_topo.xyz', allxyz, fmt='%.6e')\\n elif MODE == 2:\\n np.savetxt(FNAME.rsplit('.', 1)[0] + '_topo.xyz', allxyz, fmt='%.6e')\\n print(' [done]')\",\n \"def save(self, filename):\\n np.savez(temp_dir + '/' + filename + '.npz', chip_ids=self.chip_ids, core_ids=self.core_ids, cx_ids=self.cx_ids)\",\n \"def save_EGRID( self , filename , output_unit = EclUnitTypeEnum.ERT_ECL_METRIC_UNITS):\\n self._fwrite_EGRID2( filename, output_unit )\",\n \"def save_numpy_array(self):\\n np.save(\\\"smallest_particles.npy\\\", self.smallest_particles)\\n np.save(\\\"number_counts.npy\\\", self.number_counts)\\n np.save(\\\"number_counts_2.npy\\\", self.number_counts_2)\",\n \"def save(self,outPath=None):\\n if (not self.canSave): raise StateError(_(\\\"Insufficient data to write file.\\\"))\\n if not outPath:\\n fileInfo = self.fileInfo\\n outPath = os.path.join(fileInfo.dir,fileInfo.name)\\n out = file(outPath,'wb')\\n #--Tes3 Record\\n self.tes3.setChanged()\\n self.tes3.hedr.setChanged()\\n self.tes3.hedr.numRecords = len(self.records) #--numRecords AFTER TES3 record\\n self.tes3.getSize()\\n self.tes3.dump(out)\\n #--Other Records\\n for record in self.records:\\n record.getSize()\\n record.dump(out)\\n out.close()\",\n \"def toFile(self,fid):\\n stack = []\\n for w,b in self.stack:\\n w.copy_to_host()\\n b.copy_to_host()\\n stack.append([w.numpy_array,b.numpy_array])\\n\\tpickle.dump(stack,fid)\",\n \"def save(self, output, data):\",\n \"def save(self, filename):\\n with open(filename, 'w') as f:\\n pickle.dump((self.mean, self.std_dev), f)\",\n \"def save_array_as(arr, loc=None):\\n if loc is None:\\n root = tk.Tk()\\n root.loc = filedialog.asksaveasfilename(initialdir=\\\"/\\\",\\n title=\\\"Save as\\\",\\n filetypes=((\\\"npy files\\\", \\\"*.npy\\\"),\\n (\\\"all files\\\", \\\"*.*\\\"))\\n )\\n np.save(root.loc, arr)\\n root.destroy()\\n else:\\n np.save(loc, arr)\",\n \"def write_opal(self, file_name):\\n \\n return 0\",\n \"def _toFile(self):\\n pass\",\n \"def sauvegarde(self):\\r\\n\\r\\n # On vérifie que le fichier existe\\r\\n # 'exists' est un booléen\\r\\n exists = os.path.isfile(\\\"cartes/Save.txt\\\")\\r\\n if exists:\\r\\n # Le fichier existe => On l'ouvre en écriture 'r'\\r\\n with open (\\\"cartes/Save.txt\\\",\\\"w\\\") as f: \\r\\n for elt in self.listeLignes:\\r\\n f.write(\\\"%s\\\" %elt)\\r\\n else:\\r\\n with open (\\\"cartes/Save.txt\\\",\\\"x\\\") as f: \\r\\n # Le fichier n'existe pas, on le créer et on l'ouvre en écriture 'x'\\r\\n for elt in self.listeLignes:\\r\\n f.write(\\\"%s\\\" %elt)\",\n \"def savemat(self, file_name):\\n d = {'dG0_prime': self.dG0_prime,\\n 'dG0': self.dG0,\\n 'T': self.T,\\n 'I': self.I,\\n 'pH': self.pH,\\n 'pMg': self.pMg,\\n 'weight': self.weight,\\n 'cids': self.cids,\\n 'S': self.S.values}\\n savemat(file_name, d, oned_as='row')\",\n \"def savepotentialtest(pot, xx, path):\\n potential = []\\n coordinates = []\\n for ii in range(0, len(pot)):\\n coordinates.append(xx[ii])\\n potential.append(pot[ii])\\n np.savetxt(path, np.transpose([coordinates, potential]))\",\n \"def filemenu_Export(self):\\n line_dict = {}\\n for line in self.lines.values():\\n for name, arr in line.to_mat().items():\\n line_dict[name] = arr\\n fileTypes = [(\\\"MATLAB file\\\",\\\"*.mat\\\"), (\\\"NumPy file\\\",\\\"*.npz\\\")]\\n options = {}\\n options['initialdir'] = os.path.expanduser('~')\\n options['filetypes'] = fileTypes\\n options['parent'] = self.master\\n filename = filedialog.asksaveasfilename(**options)\\n if filename:\\n _, ext = os.path.splitext(filename)\\n if ext == \\\".mat\\\":\\n sio.savemat(filename, line_dict)\\n elif ext == \\\".npz\\\":\\n np.savez(filename, lines=line_dict)\",\n \"def save(self, fname):\\n fmt = \\\" %7.1f %7.1f %8.2f %8.2f %8.2f %8.3f %8.3f %8.3f %8.3f %6.1f\\\"\\n with open(fname, 'wb') as fid:\\n fid.write('# CoordinateSystem \\\"Head\\\"\\\\n'.encode('utf-8'))\\n fid.write('# begin end X (mm) Y (mm) Z (mm)'\\n ' Q(nAm) Qx(nAm) Qy(nAm) Qz(nAm) g/%\\\\n'\\n .encode('utf-8'))\\n t = self.times[:, np.newaxis] * 1000.\\n gof = self.gof[:, np.newaxis]\\n amp = 1e9 * self.amplitude[:, np.newaxis]\\n out = np.concatenate((t, t, self.pos / 1e-3, amp,\\n self.ori * amp, gof), axis=-1)\\n np.savetxt(fid, out, fmt=fmt)\\n if self.name is not None:\\n fid.write(('## Name \\\"%s dipoles\\\" Style \\\"Dipoles\\\"'\\n % self.name).encode('utf-8'))\",\n \"def save(self, filename):\\n pass\",\n \"def save_data(self, f): \\n if not self.sampling:\\n self.convert_to_array()\\n np.save(f, self.reads)\",\n \"def save_calibration(filename):\\n pass\",\n \"def test_save_as_ascii(self):\\n array = np.array([0, 1, 3])\\n errors = np.array([1, 1, 1])\\n hen.io.save_as_ascii(\\n [array, errors],\\n filename=os.path.join(self.datadir, \\\"monol_test.txt\\\"),\\n colnames=[\\\"array\\\", \\\"err\\\"])\",\n \"def write_checkpoint(self):\\n self.file_checkpoint_data = open(self.path_checkpoint, \\\"a+\\\")\\n array_to_write = [str(self.radious), self.type_feature, self.type_filtering, self.h_filterig]\\n self.file_checkpoint_data.write(','.join(array_to_write) + \\\"\\\\n\\\")\\n self.file_checkpoint_data.flush()\",\n \"def save(self, fname):\\n pass\",\n \"def save_data_to_disk(self):\\n Omega_M = self.theta_fid[0]\\n for key in self.data.keys():\\n np.save(f'./preloaded_data/{Omega_M}_{self.delta_theta[0]}_{key}.npy', self.data[key])\",\n \"def analysis_save(plotables,analysis_attributes,file_name):\\n#TODO implement error handling\\n for (plotable,plt_type), ana_attr in zip(plotables,analysis_attributes):\\n scipy.io.savemat(\\n \\\"{0}_{1}\\\".format(file_name,str(ana_attr)),\\n { plt_type: plotable }\\n )\",\n \"def save(self, path):\\n individual = self.population.fittest_individual()\\n order = [int(l) for l in individual.label_order]\\n fitness = individual.fitness\\n data = {'name': self.ds.name,\\n 'num_labels': len(order),\\n 'order': order,\\n 'fitness': fitness\\n }\\n with open(path, 'w') as f:\\n json.dump(data, f)\",\n \"def save(self,filepath):\\n d = self.X.tocoo(copy=False)\\n v = self.col_view.tocoo(copy=False)\\n np.savez(filepath,row=d.row,col=d.col,data=d.data,shape=d.shape,\\n v_row=v.row,v_col=v.col,v_data=v.data,v_shape=v.shape)\",\n \"def save_offsets(offsets_hres, offsets_std, savePath):\\n check_folder(savePath)\\n \\n with open(pjn(savePath,'offsets_hres.npy'), 'wb') as f:\\n np.save(f, offsets_hres) \\n with open(pjn(savePath, 'offsets_std.npy'), 'wb') as f:\\n np.save(f, offsets_std)\",\n \"def save_values(self):\\n f_name = self.img_path.split('.')[0] + '_{}_'.\\\\\\n format(self.data_type_name) + '.csv'\\n dir_name = os.path.join(self.base_dir, f_name)\\n if not os.path.exists(dir_name):\\n for data_list in self.converted_values():\\n with open(f_name, 'a') as f:\\n wr = csv.writer(f, delimiter=';')\\n wr.writerow(data_list)\\n else:\\n os.remove(f_name)\\n for data_list in self.converted_values():\\n with open(f_name, 'a') as f:\\n wr = csv.writer(f, delimiter=';')\\n wr.writerow(data_list)\",\n \"def write(self,data): \\n if not os.path.exists(self.output_dir):\\n os.makedirs(self.output_dir)\\n\\n # We will store these in a separate file and link them to the level2s\\n fname = data.filename.split('/')[-1]\\n \\n if os.path.exists(self.outfile):\\n output = h5py.File(self.outfile,'a')\\n else:\\n output = h5py.File(self.outfile,'w')\\n\\n # Set permissions and group\\n if self.set_permissions:\\n try:\\n os.chmod(self.outfile,0o664)\\n shutil.chown(self.outfile, group=self.permissions_group)\\n except PermissionError:\\n self.logger(f'{fname}:{self.name}: Warning, couldnt set the file permissions.')\\n\\n # Store datasets in root\\n data_out = {'tod':self.all_tod,\\n 'weights':self.all_weights,\\n 'mask':self.all_mask,\\n 'cal_factors':self.all_cal_factors,\\n 'frequency':self.all_frequency,\\n 'auto_rms':self.all_auto}\\n\\n for dname, dset in data_out.items():\\n if dname in output:\\n del output[dname]\\n output.create_dataset(dname, data=dset)\\n\\n output.attrs['version'] = __level3_version__\\n output['cal_factors'].attrs['source'] = self.cal_source\\n output['cal_factors'].attrs['calibrator_obsid'] = self.nearest_calibrator\\n\\n output.close()\\n \\n if self.level3 in data.keys():\\n del data[self.level3]\\n data[self.level3] = h5py.ExternalLink(self.outfile,'/')\",\n \"def writeout(self):\\n out_file = ''.join(['theta_w_t', str(self.t), '.dat'])\\n data_list = [] \\n\\n for i in xrange(self.n_params): \\n data_list.append( self.theta_t[i,:] ) \\n\\n data_list.append(self.w_t)\\n\\n np.savetxt(\\n out_file, \\n (np.vstack(np.array(data_list))).T, \\n delimiter='\\\\t'\\n )\\n\\n return None\",\n \"def save(self, file, name):\\n np.savetxt(os.path.join(file, name), self.matrix, fmt='%f')\",\n \"def dumpCoordinatesToFile(self, coordinate_ids): \\n coordinate_ids_dump_file = open(self.COORDINATES_DUMP_FNAME , 'w')\\n pickle.dump(coordinate_ids, coordinate_ids_dump_file)\\n coordinate_ids_dump_file.close()\",\n \"def __savePreProcessedData(self):\\n np.savetxt(self.X_filename, self.X, delimiter=',')\\n np.savetxt(self.y_filename, self.le.fit_transform(self.y), delimiter=',')\\n #Need to save the label Enconder to inverse transform later\\n joblib.dump(self.le, self.le_filename)\\n\\n print(\\\"Saved X and y\\\")\",\n \"def save(self, path_to_save):\\n data_to_save = []\\n for item in self.data_array:\\n if isinstance(item, Result):\\n data_to_save.append(item.get())\\n\\n np.savetxt(path_to_save+'.txt', data_to_save, fmt='%5s', delimiter=',')\",\n \"def save_to_xyz(self, filename): \\n with open( filename, 'a' ) as F:\\n F = open( filename, 'a' )\\n F.write( '%d\\\\n'%self.num_atoms )\\n F.write( \\\"XYZ\\\\n\\\" )\\n for num,row in enumerate(self.atoms):\\n try:\\n F.write('%s '%self.species[num])\\n except:\\n F.write('X%d '%num)\\n F.write( mat2str( row, \\\"%16.10f\\\" ) )\\n F.write( \\\"\\\\n\\\" )\",\n \"def savealist(alist, filename):\\n out = open(filename, \\\"w\\\")\\n for i in alist:\\n out.write(str(i) + \\\"\\\\n\\\") # if i is numeric\\n out.close()\",\n \"def store(self, filename):\",\n \"def store(obj, filename, suffix = ''):\\n # It is a numpy array\\n if type(obj) == np.ndarray:\\n path,f = writefile(filename, obj_id='numpy_objs', suffix=suffix)\\n json.dump(obj, fp=f, cls=NumpyEncoder,\\n separators=(',', ':'), sort_keys=True, indent=4)\\n print '> saved with JSON to {}'.format(path)\\n else:\\n path, f = writefile(filename, obj_id='other_objs', suffix=suffix)\\n pickle.dump(obj, file=f)\\n print '> saved with dill (pickled) to {}'.format(path)\\n return path\",\n \"def writexyz(self,fname):\\n xyzfile = open(fname + \\\".xyz\\\",\\\"a+\\\")\\n xyzfile.write(str(self.natoms) + \\\"\\\\n\\\\n\\\")\\n for a in self.atoms:\\n \\tcxyz = a.xyz - np.array(self.pbc_correction(a.xyz))\\n\\t\\t\\txyzfile.write(str(a.type) + \\\"\\\\t\\\" + str(cxyz[0]) + \\\"\\\\t\\\" + str(cxyz[1]) + \\\"\\\\t\\\" + str(cxyz[2]) + \\\"\\\\n\\\")\\n xyzfile.close()\",\n \"def save(self, filename, type='CSV'):\\n # Convenient form for saving:\\n save = np.ndarray(shape=(self.Pbrem.shape[0]+1, self.Pbrem.shape[1]), dtype=np.float)\\n save[0,:] = self.time\\n save[1:,:] = self.Pbrem\\n\\n if type == 'CSV':\\n with open(filename, 'wb') as file:\\n np.savetxt(file, save, delimiter=',', header='Time,Total,Fuel,Shell\\\\n')\\n\\n elif type == 'pickle':\\n with open(filename, 'wb') as file:\\n pickle.dump(save, file)\",\n \"def eeg_writeavr(array,tsb,di,file):\\t\\t\\n import shutil as shu\\n f=open(file,'w')\\n firstline = 'Npts= %i TSB= %i DI= %7.5f SB= %7.5f SC= %i NChan= %i\\\\n' %(array.shape[1],tsb,di,1,200,array.shape[0]) \\n chnam = 'Cz FP1 FP2 F3 F4 C3 C4 P3 P4 O1 O2 F7 F8 T7 T8 P7 P8 Fz Pz FC1 FC2 CP1 CP2 FC5 FC6 CP5 CP6 FT9 FT10 TP9 TP10 PO9 PO10\\\\n'\\n f.write(firstline)\\n f.write(chnam)\\n for i in range(array.shape[0]):\\n tmp = array[i,:]\\n f.write(('%7.5f ' * len(tmp)) %tuple(tmp))\\n f.write('\\\\n')\\n \\n f.close()\\n #may want to change this on different machines...\\n src = '/Users/crislanting/Projects/EEG/data/33.elp'\\n dest = file[:-4] + '.elp'\\n shu.copyfile(src,dest)\",\n \"def save_values(self):\\n # TODO: Add self.prefix and extension\\n NetworkTables.saveEntries(self.file.get_filename(), prefix='/vision/' + self.name + '_')\",\n \"def save_per_gene(filename, tn_per_gene, reads_per_gene, aliases_designation):\\n\\n with open(filename, \\\"w\\\") as f:\\n\\n f.write(\\\"Gene name\\\\tNumber of transposons per gene\\\\tNumber of reads per gene\\\\n\\\")\\n\\n for gene in tn_per_gene:\\n tnpergene = tn_per_gene[gene]\\n readpergene = reads_per_gene[gene]\\n if gene in aliases_designation:\\n gene_alias = aliases_designation.get(gene)[0]\\n else:\\n gene_alias = gene\\n f.write(gene_alias + \\\"\\\\t\\\" + str(tnpergene) + \\\"\\\\t\\\" + str(readpergene) + \\\"\\\\n\\\")\",\n \"def save(self, filename):\\n data = {\\\"sizes\\\": self.sizes,\\n \\\"weights\\\": [w.tolist() for w in self.weights],\\n \\\"biases\\\": [b.tolist() for b in self.biases],\\n \\\"cost\\\": str(self.cost.__name__)}\\n f = open(filename, \\\"w\\\")\\n json.dump(data, f)\\n f.close()\",\n \"def save_to_array(arr_name, arr_object):\\n return np.save(arr_name, arr_object)\",\n \"def SaveToFile(self):\\n\\n if len(self.paris) == 0:\\n with open(self.fileLoc, \\\"w\\\") as file:\\n file.write(\\\" \\\")\\n return\\n\\n data = \\\"\\\"\\n for x in self.paris.iterkeys():\\n data += \\\"%\\\" + x + \\\":\\\" + self.paris[x] + \\\"%\\\"\\n \\n data = self.Encrypt(data)\\n\\n with open(self.fileLoc, \\\"w\\\") as file:\\n file.write(data)\",\n \"def save(self):\\n with open(self.slide_coords_file, 'w') as f:\\n json.dump(self.dump(), f)\",\n \"def save_traces(traces, save_dir, file_format=\\\"MSEED\\\"):\\n for event in traces:\\n if config.dir_per_event and len(event) > 0:\\n base_dir_name = event[0][4]\\n if len(event[0]) == 7 and event[0][6] is not None:\\n base_dir_name = event[0][6]\\n dir_name = base_dir_name\\n index = 0\\n while os.path.isdir(save_dir + '/' + dir_name):\\n dir_name = base_dir_name + str(index)\\n index += 1\\n os.mkdir(save_dir + '/' + dir_name)\\n for x in event:\\n try:\\n if config.dir_per_event:\\n file_name = x[1] + '.' + x[3] + '.' + x[5]\\n index = 0\\n while os.path.isfile(save_dir + '/' + dir_name + '/' + file_name):\\n file_name = x[1] + '.' + x[5] + '.' + str(index)\\n index += 1\\n x[0].write(save_dir + '/' + dir_name + '/' + file_name, format=file_format)\\n else:\\n file_name = x[1] + '.' + x[5]\\n index = 0\\n while os.path.isfile(save_dir + '/' + file_name):\\n file_name = x[1] + '.' + x[5] + '.' + str(index)\\n index += 1\\n\\n x[0].write(save_dir + '/' + file_name, format=file_format)\\n except InternalMSEEDError:\\n logging.warning(str(InternalMSEEDError))\\n except OSError:\\n logging.warning(str(OSError))\",\n \"def save_new_joint_angles(self,save_file):\\n with open(directory + save_file, \\\"w\\\") as outfile:\\n writer = csv.writer(outfile)\\n writer.writerow(robot.joint_angles.values())\\n outfile.close()\",\n \"def __saveKnownAtlases(self):\\n\\n if self.__atlasDescs is None:\\n return\\n\\n atlases = []\\n\\n for desc in self.__atlasDescs:\\n atlases.append((desc.atlasID, desc.specPath))\\n\\n atlases = ['{}={}'.format(name, path) for name, path in atlases]\\n atlases = op.pathsep.join(atlases)\\n\\n fslsettings.write('fsl.data.atlases', atlases)\",\n \"def savez(d,file):\\n np.savez(file,row=d.row,col=d.col,data=d.data,shape=d.shape)\",\n \"def save_data(self, speaker_name, data):\\n if not os.path.exists(self.data_dir):\\n os.makedirs(self.data_dir)\\n \\n path = os.path.join(self.data_dir, speaker_name + \\\".pkl\\\")\\n np.array(data).dump(path)\",\n \"def symSave(saveMe,saveFile='symsave'):\\n indices = np.triu_indices_from(saveMe)\\n np.save(saveFile,saveMe[indices])\",\n \"def write_array(uri: str):\\n a1_data = np.reshape(np.arange(1, 26), (5, 5))\\n l1_data = np.arange(5, 0, -1)\\n l2_data = np.arange(-2, 3)\\n l3_data = np.linspace(-1.0, 1.0, 5)\\n with tiledb.open(uri, \\\"w\\\") as array:\\n array[:] = {\\\"a1\\\": a1_data, \\\"l1\\\": l1_data, \\\"l2\\\": l2_data, \\\"l3\\\": l3_data}\",\n \"def write_data_to_file(pos, fps, data_file):\\n xs = []\\n for x,y in pos:\\n xs.append(x)\\n with open(data_file,'wb') as f:\\n np.save(f,pos)\\n np.save(f,xs)\\n np.save(f,fps)\",\n \"def saveeigenvaluestest(eigenValue, fvalue, lvalue, path):\\n chEigen = []\\n for ii in range(fvalue, lvalue+1):\\n test = eigenValue[ii]\\n chEigen.append(test)\\n np.savetxt(path, chEigen, fmt='%s')\",\n \"def save_chain_to_file(config_dict, samplesOutlet, samplesInlet, samplesFD, logPostList, w_num):\\n outlet_path = f\\\"outputs/{config_dict['dir_name']}/AIES_LWR-outlet-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-walker{w_num}.txt\\\"\\n inlet_path = f\\\"outputs/{config_dict['dir_name']}/AIES_LWR-inlet-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-walker{w_num}.txt\\\"\\n FD_path = f\\\"outputs/{config_dict['dir_name']}/AIES_LWR-FD-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-walker{w_num}.txt\\\"\\n logPostList_path = f\\\"outputs/{config_dict['dir_name']}/AIES_LWR-FD-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-LogPostList.txt\\\"\\n np.savetxt(outlet_path, samplesOutlet)\\n np.savetxt(inlet_path, samplesInlet)\\n np.savetxt(FD_path, samplesFD)\\n np.savetxt(logPostList_path, logPostList)\\n\\n Run_settings = gen_run_setting_str(config_dict)\\n run_settings_path = f\\\"outputs/{config_dict['dir_name']}/run_settings.txt\\\"\\n with open(run_settings_path, 'w') as f:\\n f.write(Run_settings)\\n if config_dict[\\\"save_to_S3\\\"] == True:\\n upload_chain(s3_path=os.path.join(\\\"AIES_LWR\\\", outlet_path), local_path=outlet_path)\\n upload_chain(s3_path=os.path.join(\\\"AIES_LWR\\\", inlet_path), local_path=inlet_path)\\n upload_chain(s3_path=os.path.join(\\\"AIES_LWR\\\", FD_path), local_path=FD_path)\\n upload_chain(s3_path=os.path.join(\\\"AIES_LWR\\\", logPostList_path), local_path=logPostList_path)\\n upload_chain(s3_path=os.path.join(\\\"AIES_LWR\\\", run_settings_path), local_path=run_settings_path)\",\n \"def save(self, filename):\\n np.savez(temp_dir + '/' + filename + '.npz', core_ids=self.core_ids, cx_ids=self.cx_ids)\",\n \"def save_to_array(x, y):\\n\\n with open(settings.data(\\\"x.npy\\\"), \\\"wb\\\") as file:\\n np.save(file, x)\\n\\n with open(settings.data(\\\"y.npy\\\"), \\\"wb\\\") as file:\\n np.save(file, y)\",\n \"def tofile(self, filename:'Union[str, Path]'):\\n\\n with open(filename, mode='w') as file:\\n dims = ','.join(map(str, self._dims))\\n file.write(f'dims={dims}\\\\n')\\n for dim, axes in self.items():\\n if isinstance(axes, dict):\\n axes = ','.join(map(str, axesiter(axes)))\\n file.write(f'axes={axes}\\\\n')\\n else:\\n file.write(f'dim={axes}\\\\n')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7392277","0.6695063","0.6674351","0.644882","0.63625616","0.6278154","0.6215802","0.62093705","0.6171282","0.61635345","0.610858","0.61081475","0.601042","0.60060334","0.6003838","0.59577906","0.59309465","0.59160286","0.59078306","0.5905936","0.5888497","0.5848774","0.5833116","0.583251","0.58303237","0.58272415","0.57939327","0.57899517","0.5766755","0.5747746","0.5745341","0.57306665","0.57226795","0.5713737","0.5694093","0.5677885","0.5667587","0.5663187","0.56494725","0.5634758","0.5631391","0.56260127","0.56247497","0.5622583","0.5612973","0.56120044","0.5609054","0.56087255","0.5599844","0.55977714","0.5596476","0.5594883","0.5593789","0.5593343","0.5586686","0.5586272","0.55833066","0.55712914","0.55676115","0.5563817","0.5561502","0.55531764","0.55510163","0.5549723","0.55333143","0.5526678","0.5526431","0.55194056","0.5516339","0.55117726","0.55096596","0.55040634","0.5502754","0.5502707","0.5502576","0.5499859","0.5498438","0.5493034","0.54916596","0.548627","0.54839766","0.54739606","0.5472565","0.5472398","0.5461665","0.5461593","0.545884","0.54566085","0.5455503","0.5446722","0.5435165","0.54251623","0.5424872","0.542482","0.54222393","0.54194015","0.54113114","0.54112715","0.54110336","0.5408912"],"string":"[\n \"0.7392277\",\n \"0.6695063\",\n \"0.6674351\",\n \"0.644882\",\n \"0.63625616\",\n \"0.6278154\",\n \"0.6215802\",\n \"0.62093705\",\n \"0.6171282\",\n \"0.61635345\",\n \"0.610858\",\n \"0.61081475\",\n \"0.601042\",\n \"0.60060334\",\n \"0.6003838\",\n \"0.59577906\",\n \"0.59309465\",\n \"0.59160286\",\n \"0.59078306\",\n \"0.5905936\",\n \"0.5888497\",\n \"0.5848774\",\n \"0.5833116\",\n \"0.583251\",\n \"0.58303237\",\n \"0.58272415\",\n \"0.57939327\",\n \"0.57899517\",\n \"0.5766755\",\n \"0.5747746\",\n \"0.5745341\",\n \"0.57306665\",\n \"0.57226795\",\n \"0.5713737\",\n \"0.5694093\",\n \"0.5677885\",\n \"0.5667587\",\n \"0.5663187\",\n \"0.56494725\",\n \"0.5634758\",\n \"0.5631391\",\n \"0.56260127\",\n \"0.56247497\",\n \"0.5622583\",\n \"0.5612973\",\n \"0.56120044\",\n \"0.5609054\",\n \"0.56087255\",\n \"0.5599844\",\n \"0.55977714\",\n \"0.5596476\",\n \"0.5594883\",\n \"0.5593789\",\n \"0.5593343\",\n \"0.5586686\",\n \"0.5586272\",\n \"0.55833066\",\n \"0.55712914\",\n \"0.55676115\",\n \"0.5563817\",\n \"0.5561502\",\n \"0.55531764\",\n \"0.55510163\",\n \"0.5549723\",\n \"0.55333143\",\n \"0.5526678\",\n \"0.5526431\",\n \"0.55194056\",\n \"0.5516339\",\n \"0.55117726\",\n \"0.55096596\",\n \"0.55040634\",\n \"0.5502754\",\n \"0.5502707\",\n \"0.5502576\",\n \"0.5499859\",\n \"0.5498438\",\n \"0.5493034\",\n \"0.54916596\",\n \"0.548627\",\n \"0.54839766\",\n \"0.54739606\",\n \"0.5472565\",\n \"0.5472398\",\n \"0.5461665\",\n \"0.5461593\",\n \"0.545884\",\n \"0.54566085\",\n \"0.5455503\",\n \"0.5446722\",\n \"0.5435165\",\n \"0.54251623\",\n \"0.5424872\",\n \"0.542482\",\n \"0.54222393\",\n \"0.54194015\",\n \"0.54113114\",\n \"0.54112715\",\n \"0.54110336\",\n \"0.5408912\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7149724"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":93196,"cells":{"query":{"kind":"string","value":"Convention for loading according to saving function above."},"document":{"kind":"string","value":"def get_lists_from_file(filename):\n import numpy as np\n\n elev_arrays = np.load(file=filename)\n\n return list(elev_arrays[0]), list(elev_arrays[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 load(self):\n pass","def load(self):\n pass","def load(self):\n pass","def load(self):\n pass","def load(self):","def _load(self):\n raise NotImplementedError()","async def load(cls, save_file, *args, **kwargs):\n raise NotImplementedError()","def _post_load(self):\n pass","def load(self):\n return","def load(self):\n\n raise NotImplementedError","def postLoad(self):\n pass","def _load(self) -> None:\n self.record = self._saved_record\n self.counter = self._saved_counter\n self.current_objects = self._saved_objects","def load(self):\n raise NotImplementedError","def load(self):\n raise NotImplementedError","def load(self):\n self._really_load()","def set_load(self, load):\n self.load= load","def _load(self) -> dict:\n raise NotImplementedError()","def load(self):\n raise NotImplementedError()","def load(self):\n raise NotImplementedError()","def load(self, which):\n\t\tpath = os.path.join(self.storagedir, which)\n\t\tprint(\"Loading from\", path)\n\t\twith open(path, \"rb\") as handle:\n\t\t\tsetattr(self, which, _pickle.load(handle))","def load(self,filename=None): # return True\r\n pass","def load(path_to_model):\n pass","def load_model(self) -> Any:","def load(self, *args, **kwargs):\n pass","def load_obj(saved_name):\n with open( saved_name + '.pkl', 'rb') as f:\n return pickle.load(f)","def load(self, filename):\n pass","def load_data(self):","def force_load(self):\n pass","def load(self):\n return True","def load_model(self, filename):\r\n pass","def load(\n self,\n modelLoadPath\n ):\n pass","def load(self):\n self.word2vec, self.img2sentence, self.word_freq, self.num_words, self.word2idx, self.idx2word = pickle.load(open(self.save_file, 'rb'))","def load(self):\n return None","def _load_training_data(self):\n self._save_training_data()","def load(self):\n try:\n if self.model.is_cuda:\n self.model.load_state_dict(torch.load(os.path.join(self.save_path, \"save_point.pth\")))\n else:\n self.model.load_state_dict(torch.load(os.path.join(self.save_path, \\\n \"save_point.pth\"), map_location=\"cpu\"))\n except:\n sys.exit(\"Unable to load previous model\")","def load_model(self):\n if self.save_path is not None:\n if isfile(self.save_path):\n self.model.load_state_dict(load(self.save_path))\n else:\n raise ValueError(\"Cannot find model save file: \" + self.save_path)","def load_(self):\n path = os.path.join(os.path.dirname(self.arch_handler.dicomdir_path), self.SAVE_NAME)\n if not os.path.isfile(path):\n print(\"No history to load\")\n return\n with open(path, \"r\") as infile:\n data = json.load(infile)\n self.load(data['history'])\n self._edited = False","def _load_disk(self):","def _load_disk(self):","def load_model(self, path):\n pass","def load(path):\n pass","def load_model(self):\n pass","def _load_model(self, loc):\n\n # If not a string, return input\n if not (isinstance(loc, str) or isinstance(loc, unicode)):\n return loc\n\n # If location is in S3, copy to local, then unpickle \n to_delete = False\n if \"s3\" in loc:\n tmp_loc = \"{0}/tmp_file_{1}.obj\".format(tmpdir, random.randint(1,1000))\n s3 = boto3.client('s3')\n bucket = loc.split(\"/\")[2]\n key = \"/\".join(loc.split(\"/\")[3:])\n with open(tmp_loc, \"wb\") as data:\n s3.download_fileobj(bucket, key, data)\n loc = tmp_loc\n to_delete = True\n with open(loc, \"rb\") as f:\n model = pickle.load(f)\n if to_delete:\n os.remove(tmp_loc)\n return model","def load(self):\n self._load()","def _load_disk(self):\r\n pass","def loading_strategy(self):\n try:\n if not self.file_allowed():\n raise Exception('File type {} is not allowed'.format(self.get_ext()))\n\n with open(self._file_path, 'r') as outfile:\n content = outfile.read()\n\n if self.is_json() or self.is_template():\n return json.loads(content)\n\n if self.is_yaml():\n if self._yaml_replacements:\n for key, value in self._yaml_replacements.iteritems():\n content = content.replace(key, value)\n\n return yaml.load(content)\n else:\n return content\n\n except Exception as e:\n Oprint.err(e)\n else:\n raise Exception('File type {} is not allowed'.format(self.get_ext()))","def beforeSave(self):","def load_data(self) -> None:","def _load(self, load_dict):\n self._data_ = load_dict","def loadGame(self, save_name: str, save_location: str) -> None:\n self.save_location = (\n f\"{save_location}/{save_name}\"\n if save_name is not None and save_location is not None\n else f\"{DEFAULT_SAVE_LOCATION}/{DEFAULT_SAVE_NAME}\"\n )\n\n save_data_as_string = \"\"\n # Check to see if that save file exists, if not populate it with default data so that the game can start\n if not os.path.exists(self.save_location):\n with open(SAVE_TEMPLATE, \"r\") as File:\n save_data_as_string = File.read()\n\n with open(self.save_location, \"w\") as File:\n File.write(save_data_as_string)\n else:\n with open(self.save_location, \"r\") as File:\n save_data_as_string = File.read()\n\n # Now load the data into the object as a dictionary\n return json.loads(save_data_as_string)","def load(self, path):\n pass","def load(self, path):\n pass","def loadModel(self, savePath=\"DataStore/SavedModels/Forecasters/\",\n date=False):\n savePath = self.getProjectRoot() + savePath\n modelName = self.__class__.__name__\n savePath += modelName\n if not date:\n if len(os.listdir(savePath)) == 0:\n message = \"no saved models present\"\n raise Exception(message)\n latestSave = sorted(os.listdir(savePath),\n key=lambda x: self.getDatetime(x))[-1]\n savePath = \"{}/{}\".format(savePath, latestSave)\n self.loadAll(savePath)\n elif isinstance(date, str):\n allSaves = os.listdir(savePath)\n if date not in allSaves:\n # Raising exception as directory not present in savePath\n message = \"{} not in specified location {}\".format(date,\n savePath)\n raise Exception(message)\n else:\n self.loadAll(\"{}/{}\".format(savePath, date))","def load(self):\n raise NotImplementedError(\"Subclass does not implement this method\") # pragma: no cover","def test_save_reload(self):\n base = BaseModel()\n idd = base.id\n base.name = \"betty\"\n base.save()\n storage.reload()\n key = \"BaseModel.{}\".format(idd)\n objs = storage.all()[key]\n self.assertTrue(hasattr(objs, \"name\"))\n self.assertTrue(objs.name == \"betty\")\n self.assertTrue(os.path.exists('file.json'))","def __load_model(self):\n loaded = load(self.__file_name)\n self.__model = loaded['model']\n self.__meta_data = loaded['metadata']\n self.__is_ready = True","def load(self, filename):\n\n return super().load(filename=filename)","def _save_constructor(self, id, filename):\n pass","def load(self,fname=None):\r\n if fname == None:\r\n fname = \"school_%s.save\" % self.name_full\r\n fname = fname.replace(\"'\", \"\")\r\n fname = fname.replace(\". \", \"_\")\r\n fname = fname.replace(\" \", \"_\")\r\n fname = fname.replace(\"'\", \"\")\r\n thisdir = os.getcwd()\r\n tempdir = \"TEMP\"\r\n\r\n if os.path.isdir(os.path.join(thisdir, \"TEMP\")):\r\n tempdir = os.path.join(thisdir, \"TEMP\")\r\n elif os.path.isdir(os.path.join(thisdir, \"..\", \"TEMP\")):\r\n tempdir = os.path.join(thisdir, \"..\", \"TEMP\")\r\n\r\n if os.path.isdir(tempdir):\r\n os.chdir(tempdir)\r\n\r\n if os.path.isfile(fname):\r\n infile = open(fname, \"rb\")\r\n #self = pickle.load(infile)\r\n if self.VERBOSE > 0:\r\n print \"\\tOpened file '%s' OK...\" % fname\r\n temp_school = School()\r\n temp_school = pickle.load(infile)\r\n #self = pickle.load(infile)\r\n #temp_school = pickle.load(fname)\r\n #temp_school.load(infile)\r\n infile.close()\r\n\r\n for prop in temp_school.__dict__.keys():\r\n if self.VERBOSE > 0:\r\n print(\"loading '%s'...\" % prop), \r\n self.__dict__[prop] = temp_school.__dict__[prop]\r\n if self.VERBOSE > 0:\r\n print \"\\t...OK\"\r\n\r\n else:\r\n print \"ERROR: CAN'T FIND SAVE FILE '%s'!\" % fname\r\n os.chdir(thisdir)\r\n return -1\r\n\r\n #rebuild the Font object we couldn't pickle\r\n if self.sign_font_name != None:\r\n if os.path.isdir(os.path.join(\"..\", \"fonts\")):\r\n if self.sign_font_size != None:\r\n if GRAPHICSMODE == \"PIL\":\r\n from PIL import ImageFont\r\n self.sign_font = ImageFont.truetype(os.path.join(\"..\", \"fonts\", self.sign_font_name), self.sign_font_size, encoding='unic')\r\n elif GRAPHICSMODE == \"PyGame\":\r\n self.sign_font = pygame.font.Font(os.path.join(\"..\", \"fonts\", self.sign_font_name), self.sign_font_size)\r\n elif os.path.isdir(\"fonts\"):\r\n if self.sign_font_size != None:\r\n if GRAPHICSMODE == \"PIL\":\r\n from PIL import ImageFont\r\n self.sign_font = ImageFont.truetype(os.path.join(\"fonts\", self.sign_font_name), self.sign_font_size, encoding='unic')\r\n elif GRAPHICSMODE == \"PyGame\":\r\n self.sign_font = pygame.font.Font(os.path.join(\"fonts\", self.sign_font_name), self.sign_font_size)\r\n\r\n #rebuild the self.badge image that we couldn't pickle\r\n if self.badge != None:\r\n badge_fname = self.badge\r\n if os.path.isfile(badge_fname):\r\n if GRAPHICSMODE == \"PyGame\":\r\n pygame.image.load(self.badge,badge_fname)\r\n elif GRAPHICSMODE == \"PIL\":\r\n self.badge = PilImage.open(badge_fname)\r\n\r\n #rebuild the self.sign image that we couldn't pickle\r\n if self.sign != None:\r\n sign_fname = self.sign\r\n if os.path.isfile(sign_fname):\r\n if GRAPHICSMODE == \"PyGame\":\r\n pygame.image.load(self.sign,sign_fname)\r\n elif GRAPHICSMODE == \"PIL\":\r\n self.badge = PilImage.open(sign_fname)\r\n\r\n os.chdir(thisdir)\r\n return None","def load(self, p):\n return","def save():","def canLoad(self):\n #xxx should be corrected to work on all subclass hierarchy\n return 'load' in self.__class__.__dict__","def load(self):\r\n self.read(self.filename)","def save():\n pass","def load(self, *args, **kwargs) -> Any:\n pass","def _load(self):\n self.logger.debug(\"Loading from persistence\")\n # load whole item from persistence\n data = self._persistence.load(self.id(), default={})\n if not data:\n return\n\n try:\n self.persistence_deserialize(data)\n except NotImplementedError:\n # allow backwards compatibility or persisted_values way\n for persisted_var in self.persisted_values():\n if persisted_var in data:\n self.logger.debug(\"Loaded value {} for attribute {}\".format(\n data[persisted_var], persisted_var))\n # Set the loaded value to the attribute on this class\n setattr(self, persisted_var, data[persisted_var])\n except:\n # log exception while loading and let it continue\n self.logger.exception(\n \"Failed to deserialize block with data: {}\".format(data))","def _load(self, dataset):\n raise NotImplementedError('Loader {} does not support loading datasets.'.format(self.type()))","def load_checkpoint(self, model):\n print(f\"load model {self.save_model_path}\")\n model.load_state_dict(torch.load(self.save_model_path))","def reload(self):\n\n fn = self[\"~filename\"]\n saved = {}\n for key in self:\n if key in MIGRATE: saved[key] = self[key]\n self.clear()\n self[\"~filename\"] = fn\n self.__init__(fn)\n self.update(saved)","def save_data(self):\n pass","def load(self):\n return self._load","def preload(self):\n # load the objects\n for otype, fname in self.TYPE2NAME.items():\n if fname:\n path = os.path.join(self.anodir, fname + \".gz\")\n if os.path.isfile(path):\n with gzip.open(path, \"rt\") as handler:\n for line in handler:\n omap = json.loads(line)\n cls = self.TYPE2CLASS[otype]\n item = cls.from_map(omap, self)\n self.caches[otype][item.id] = item","def before_save(self):","def reload(self):\n from models.base_model import BaseModel\n from models.user import User\n from models.amenity import Amenity\n from models.city import City\n from models.place import Place\n from models.review import Review\n from models.state import State\n dict_reload = {}\n try:\n with open(FileStorage.__file_path) as file:\n dict_reload = json.load(file)\n for key, value in dict_reload.items():\n obj = value[\"__class__\"]\n self.__objects[key] = locals()[obj](**value)\n except:\n pass","def save_model(cls, vocab, path, filename):\n return super().save_model(vocab, path, filename)","def load(self, file_id):\n pass","def post_load(self, data):\n return data","def __getattribute__(self, attrname):\n\n if 'load' in attrname or 'save' in attrname:\n return getattr(self._smodel, attrname)\n else:\n return super(ModelMGPU, self).__getattribute__(attrname)","def save(self):\r\n try:\r\n self.process_save()\r\n except InputError as ex:\r\n print(ex)\r\n self.save()\r\n except KeyError:\r\n print(\"No saved data to save/load. Please save some data before loading in data.\")\r\n self.menu_page()","def save(self, filename):\n\t\tif (self.isLoaded()):\n\t\t\tself.loader.save(filename)","def save(self,fn):\n fn = fn if fn[-4:] == \".pkl\" else fn+\".pkl\"\n with open(fn,\"wb+\") as f:\n pickle.dump(self,f)\n log(\"Saved reader to {}\".format(fn))","def load(self):\n super(YacoFile, self).load(self._filename)","def load_class(self):\n if not os.path.exists(self.savefile):\n self.save_class()\n\n with open(self.savefile, \"r\") as f:\n data = json.load(f)\n for key, value in data.items():\n # set every dict key to an atribute of the class\n setattr(self, key, value) # self.key = value","def load(self):\n if os.path.isfile(self.save_filename):\n data = cloudpickle.load(open(self.save_filename, \"rb\"))\n (\n self.Joints,\n self.Links,\n self.joint_syms,\n self.global_syms,\n self.name,\n self.sym_prefix,\n ) = data\n return True\n return False","def init_saver(self):\n self.saver = tf.train.Saver(max_to_keep=self.config.max_to_keep, save_relative_paths=True)","def init_saver(self):\n self.saver = tf.train.Saver(max_to_keep=self.config.max_to_keep, save_relative_paths=True)","def reload(self):\n if file_exist(self.__file_path):\n with open(self.__file_path, \"r\", encoding=\"UTF-8\") as file:\n data = read_data(file)\n for key, value in data.items():\n instance = BaseModel(**value)\n FileStorage.__objects[key] = instance","def save(self):\n pass","def save(self):\n pass","def save(self):\n pass","def save(self):\n pass","def save(self):\n pass","def _save_helper(self, filepath, data_dict):\n # Set Default filepath\n if filepath is None:\n filepath = \"profile-{}.pkl\".format(\n datetime.now().strftime(\"%d-%b-%Y-%H:%M:%S.%f\"))\n\n # Remove data labelers as they can't be pickled\n data_labelers = self._remove_data_labelers()\n\n # add profiler class to data_dict\n data_dict['profiler_class'] = self.__class__.__name__\n\n # Pickle and save profile to disk\n with open(filepath, \"wb\") as outfile:\n pickle.dump(data_dict, outfile)\n\n # Restore all data labelers\n self._restore_data_labelers(data_labelers)","def get_load(self):\n return str(self.load)","def load_checkpoint(model, save_path):\n model.load_state_dict(torch.load(save_path))","def _load_state(self):\n \n if os.path.isfile(self.histFile):\n with open(self.histFile,'rb') as hf:\n oldFile = hf.read()\n \n if os.path.isfile(oldFile):\n self.dbFile.Value = oldFile","def load(self, func):\n self._init = func.__name__","def __init__(self):\n self.load()","def test_load_save_model():\n model = BERTopic(language=\"Dutch\", embedding_model=None)\n model.save(\"test\")\n loaded_model = BERTopic.load(\"test\")\n assert type(model) == type(loaded_model)\n assert model.language == loaded_model.language\n assert model.embedding_model == loaded_model.embedding_model\n assert model.top_n_words == loaded_model.top_n_words","def load_model(self, **params):\n \t# file_name = params['name']\n # return pickle.load(gzip.open(file_name, 'rb'))","def save (self):\n pass"],"string":"[\n \"def load(self):\\n pass\",\n \"def load(self):\\n pass\",\n \"def load(self):\\n pass\",\n \"def load(self):\\n pass\",\n \"def load(self):\",\n \"def _load(self):\\n raise NotImplementedError()\",\n \"async def load(cls, save_file, *args, **kwargs):\\n raise NotImplementedError()\",\n \"def _post_load(self):\\n pass\",\n \"def load(self):\\n return\",\n \"def load(self):\\n\\n raise NotImplementedError\",\n \"def postLoad(self):\\n pass\",\n \"def _load(self) -> None:\\n self.record = self._saved_record\\n self.counter = self._saved_counter\\n self.current_objects = self._saved_objects\",\n \"def load(self):\\n raise NotImplementedError\",\n \"def load(self):\\n raise NotImplementedError\",\n \"def load(self):\\n self._really_load()\",\n \"def set_load(self, load):\\n self.load= load\",\n \"def _load(self) -> dict:\\n raise NotImplementedError()\",\n \"def load(self):\\n raise NotImplementedError()\",\n \"def load(self):\\n raise NotImplementedError()\",\n \"def load(self, which):\\n\\t\\tpath = os.path.join(self.storagedir, which)\\n\\t\\tprint(\\\"Loading from\\\", path)\\n\\t\\twith open(path, \\\"rb\\\") as handle:\\n\\t\\t\\tsetattr(self, which, _pickle.load(handle))\",\n \"def load(self,filename=None): # return True\\r\\n pass\",\n \"def load(path_to_model):\\n pass\",\n \"def load_model(self) -> Any:\",\n \"def load(self, *args, **kwargs):\\n pass\",\n \"def load_obj(saved_name):\\n with open( saved_name + '.pkl', 'rb') as f:\\n return pickle.load(f)\",\n \"def load(self, filename):\\n pass\",\n \"def load_data(self):\",\n \"def force_load(self):\\n pass\",\n \"def load(self):\\n return True\",\n \"def load_model(self, filename):\\r\\n pass\",\n \"def load(\\n self,\\n modelLoadPath\\n ):\\n pass\",\n \"def load(self):\\n self.word2vec, self.img2sentence, self.word_freq, self.num_words, self.word2idx, self.idx2word = pickle.load(open(self.save_file, 'rb'))\",\n \"def load(self):\\n return None\",\n \"def _load_training_data(self):\\n self._save_training_data()\",\n \"def load(self):\\n try:\\n if self.model.is_cuda:\\n self.model.load_state_dict(torch.load(os.path.join(self.save_path, \\\"save_point.pth\\\")))\\n else:\\n self.model.load_state_dict(torch.load(os.path.join(self.save_path, \\\\\\n \\\"save_point.pth\\\"), map_location=\\\"cpu\\\"))\\n except:\\n sys.exit(\\\"Unable to load previous model\\\")\",\n \"def load_model(self):\\n if self.save_path is not None:\\n if isfile(self.save_path):\\n self.model.load_state_dict(load(self.save_path))\\n else:\\n raise ValueError(\\\"Cannot find model save file: \\\" + self.save_path)\",\n \"def load_(self):\\n path = os.path.join(os.path.dirname(self.arch_handler.dicomdir_path), self.SAVE_NAME)\\n if not os.path.isfile(path):\\n print(\\\"No history to load\\\")\\n return\\n with open(path, \\\"r\\\") as infile:\\n data = json.load(infile)\\n self.load(data['history'])\\n self._edited = False\",\n \"def _load_disk(self):\",\n \"def _load_disk(self):\",\n \"def load_model(self, path):\\n pass\",\n \"def load(path):\\n pass\",\n \"def load_model(self):\\n pass\",\n \"def _load_model(self, loc):\\n\\n # If not a string, return input\\n if not (isinstance(loc, str) or isinstance(loc, unicode)):\\n return loc\\n\\n # If location is in S3, copy to local, then unpickle \\n to_delete = False\\n if \\\"s3\\\" in loc:\\n tmp_loc = \\\"{0}/tmp_file_{1}.obj\\\".format(tmpdir, random.randint(1,1000))\\n s3 = boto3.client('s3')\\n bucket = loc.split(\\\"/\\\")[2]\\n key = \\\"/\\\".join(loc.split(\\\"/\\\")[3:])\\n with open(tmp_loc, \\\"wb\\\") as data:\\n s3.download_fileobj(bucket, key, data)\\n loc = tmp_loc\\n to_delete = True\\n with open(loc, \\\"rb\\\") as f:\\n model = pickle.load(f)\\n if to_delete:\\n os.remove(tmp_loc)\\n return model\",\n \"def load(self):\\n self._load()\",\n \"def _load_disk(self):\\r\\n pass\",\n \"def loading_strategy(self):\\n try:\\n if not self.file_allowed():\\n raise Exception('File type {} is not allowed'.format(self.get_ext()))\\n\\n with open(self._file_path, 'r') as outfile:\\n content = outfile.read()\\n\\n if self.is_json() or self.is_template():\\n return json.loads(content)\\n\\n if self.is_yaml():\\n if self._yaml_replacements:\\n for key, value in self._yaml_replacements.iteritems():\\n content = content.replace(key, value)\\n\\n return yaml.load(content)\\n else:\\n return content\\n\\n except Exception as e:\\n Oprint.err(e)\\n else:\\n raise Exception('File type {} is not allowed'.format(self.get_ext()))\",\n \"def beforeSave(self):\",\n \"def load_data(self) -> None:\",\n \"def _load(self, load_dict):\\n self._data_ = load_dict\",\n \"def loadGame(self, save_name: str, save_location: str) -> None:\\n self.save_location = (\\n f\\\"{save_location}/{save_name}\\\"\\n if save_name is not None and save_location is not None\\n else f\\\"{DEFAULT_SAVE_LOCATION}/{DEFAULT_SAVE_NAME}\\\"\\n )\\n\\n save_data_as_string = \\\"\\\"\\n # Check to see if that save file exists, if not populate it with default data so that the game can start\\n if not os.path.exists(self.save_location):\\n with open(SAVE_TEMPLATE, \\\"r\\\") as File:\\n save_data_as_string = File.read()\\n\\n with open(self.save_location, \\\"w\\\") as File:\\n File.write(save_data_as_string)\\n else:\\n with open(self.save_location, \\\"r\\\") as File:\\n save_data_as_string = File.read()\\n\\n # Now load the data into the object as a dictionary\\n return json.loads(save_data_as_string)\",\n \"def load(self, path):\\n pass\",\n \"def load(self, path):\\n pass\",\n \"def loadModel(self, savePath=\\\"DataStore/SavedModels/Forecasters/\\\",\\n date=False):\\n savePath = self.getProjectRoot() + savePath\\n modelName = self.__class__.__name__\\n savePath += modelName\\n if not date:\\n if len(os.listdir(savePath)) == 0:\\n message = \\\"no saved models present\\\"\\n raise Exception(message)\\n latestSave = sorted(os.listdir(savePath),\\n key=lambda x: self.getDatetime(x))[-1]\\n savePath = \\\"{}/{}\\\".format(savePath, latestSave)\\n self.loadAll(savePath)\\n elif isinstance(date, str):\\n allSaves = os.listdir(savePath)\\n if date not in allSaves:\\n # Raising exception as directory not present in savePath\\n message = \\\"{} not in specified location {}\\\".format(date,\\n savePath)\\n raise Exception(message)\\n else:\\n self.loadAll(\\\"{}/{}\\\".format(savePath, date))\",\n \"def load(self):\\n raise NotImplementedError(\\\"Subclass does not implement this method\\\") # pragma: no cover\",\n \"def test_save_reload(self):\\n base = BaseModel()\\n idd = base.id\\n base.name = \\\"betty\\\"\\n base.save()\\n storage.reload()\\n key = \\\"BaseModel.{}\\\".format(idd)\\n objs = storage.all()[key]\\n self.assertTrue(hasattr(objs, \\\"name\\\"))\\n self.assertTrue(objs.name == \\\"betty\\\")\\n self.assertTrue(os.path.exists('file.json'))\",\n \"def __load_model(self):\\n loaded = load(self.__file_name)\\n self.__model = loaded['model']\\n self.__meta_data = loaded['metadata']\\n self.__is_ready = True\",\n \"def load(self, filename):\\n\\n return super().load(filename=filename)\",\n \"def _save_constructor(self, id, filename):\\n pass\",\n \"def load(self,fname=None):\\r\\n if fname == None:\\r\\n fname = \\\"school_%s.save\\\" % self.name_full\\r\\n fname = fname.replace(\\\"'\\\", \\\"\\\")\\r\\n fname = fname.replace(\\\". \\\", \\\"_\\\")\\r\\n fname = fname.replace(\\\" \\\", \\\"_\\\")\\r\\n fname = fname.replace(\\\"'\\\", \\\"\\\")\\r\\n thisdir = os.getcwd()\\r\\n tempdir = \\\"TEMP\\\"\\r\\n\\r\\n if os.path.isdir(os.path.join(thisdir, \\\"TEMP\\\")):\\r\\n tempdir = os.path.join(thisdir, \\\"TEMP\\\")\\r\\n elif os.path.isdir(os.path.join(thisdir, \\\"..\\\", \\\"TEMP\\\")):\\r\\n tempdir = os.path.join(thisdir, \\\"..\\\", \\\"TEMP\\\")\\r\\n\\r\\n if os.path.isdir(tempdir):\\r\\n os.chdir(tempdir)\\r\\n\\r\\n if os.path.isfile(fname):\\r\\n infile = open(fname, \\\"rb\\\")\\r\\n #self = pickle.load(infile)\\r\\n if self.VERBOSE > 0:\\r\\n print \\\"\\\\tOpened file '%s' OK...\\\" % fname\\r\\n temp_school = School()\\r\\n temp_school = pickle.load(infile)\\r\\n #self = pickle.load(infile)\\r\\n #temp_school = pickle.load(fname)\\r\\n #temp_school.load(infile)\\r\\n infile.close()\\r\\n\\r\\n for prop in temp_school.__dict__.keys():\\r\\n if self.VERBOSE > 0:\\r\\n print(\\\"loading '%s'...\\\" % prop), \\r\\n self.__dict__[prop] = temp_school.__dict__[prop]\\r\\n if self.VERBOSE > 0:\\r\\n print \\\"\\\\t...OK\\\"\\r\\n\\r\\n else:\\r\\n print \\\"ERROR: CAN'T FIND SAVE FILE '%s'!\\\" % fname\\r\\n os.chdir(thisdir)\\r\\n return -1\\r\\n\\r\\n #rebuild the Font object we couldn't pickle\\r\\n if self.sign_font_name != None:\\r\\n if os.path.isdir(os.path.join(\\\"..\\\", \\\"fonts\\\")):\\r\\n if self.sign_font_size != None:\\r\\n if GRAPHICSMODE == \\\"PIL\\\":\\r\\n from PIL import ImageFont\\r\\n self.sign_font = ImageFont.truetype(os.path.join(\\\"..\\\", \\\"fonts\\\", self.sign_font_name), self.sign_font_size, encoding='unic')\\r\\n elif GRAPHICSMODE == \\\"PyGame\\\":\\r\\n self.sign_font = pygame.font.Font(os.path.join(\\\"..\\\", \\\"fonts\\\", self.sign_font_name), self.sign_font_size)\\r\\n elif os.path.isdir(\\\"fonts\\\"):\\r\\n if self.sign_font_size != None:\\r\\n if GRAPHICSMODE == \\\"PIL\\\":\\r\\n from PIL import ImageFont\\r\\n self.sign_font = ImageFont.truetype(os.path.join(\\\"fonts\\\", self.sign_font_name), self.sign_font_size, encoding='unic')\\r\\n elif GRAPHICSMODE == \\\"PyGame\\\":\\r\\n self.sign_font = pygame.font.Font(os.path.join(\\\"fonts\\\", self.sign_font_name), self.sign_font_size)\\r\\n\\r\\n #rebuild the self.badge image that we couldn't pickle\\r\\n if self.badge != None:\\r\\n badge_fname = self.badge\\r\\n if os.path.isfile(badge_fname):\\r\\n if GRAPHICSMODE == \\\"PyGame\\\":\\r\\n pygame.image.load(self.badge,badge_fname)\\r\\n elif GRAPHICSMODE == \\\"PIL\\\":\\r\\n self.badge = PilImage.open(badge_fname)\\r\\n\\r\\n #rebuild the self.sign image that we couldn't pickle\\r\\n if self.sign != None:\\r\\n sign_fname = self.sign\\r\\n if os.path.isfile(sign_fname):\\r\\n if GRAPHICSMODE == \\\"PyGame\\\":\\r\\n pygame.image.load(self.sign,sign_fname)\\r\\n elif GRAPHICSMODE == \\\"PIL\\\":\\r\\n self.badge = PilImage.open(sign_fname)\\r\\n\\r\\n os.chdir(thisdir)\\r\\n return None\",\n \"def load(self, p):\\n return\",\n \"def save():\",\n \"def canLoad(self):\\n #xxx should be corrected to work on all subclass hierarchy\\n return 'load' in self.__class__.__dict__\",\n \"def load(self):\\r\\n self.read(self.filename)\",\n \"def save():\\n pass\",\n \"def load(self, *args, **kwargs) -> Any:\\n pass\",\n \"def _load(self):\\n self.logger.debug(\\\"Loading from persistence\\\")\\n # load whole item from persistence\\n data = self._persistence.load(self.id(), default={})\\n if not data:\\n return\\n\\n try:\\n self.persistence_deserialize(data)\\n except NotImplementedError:\\n # allow backwards compatibility or persisted_values way\\n for persisted_var in self.persisted_values():\\n if persisted_var in data:\\n self.logger.debug(\\\"Loaded value {} for attribute {}\\\".format(\\n data[persisted_var], persisted_var))\\n # Set the loaded value to the attribute on this class\\n setattr(self, persisted_var, data[persisted_var])\\n except:\\n # log exception while loading and let it continue\\n self.logger.exception(\\n \\\"Failed to deserialize block with data: {}\\\".format(data))\",\n \"def _load(self, dataset):\\n raise NotImplementedError('Loader {} does not support loading datasets.'.format(self.type()))\",\n \"def load_checkpoint(self, model):\\n print(f\\\"load model {self.save_model_path}\\\")\\n model.load_state_dict(torch.load(self.save_model_path))\",\n \"def reload(self):\\n\\n fn = self[\\\"~filename\\\"]\\n saved = {}\\n for key in self:\\n if key in MIGRATE: saved[key] = self[key]\\n self.clear()\\n self[\\\"~filename\\\"] = fn\\n self.__init__(fn)\\n self.update(saved)\",\n \"def save_data(self):\\n pass\",\n \"def load(self):\\n return self._load\",\n \"def preload(self):\\n # load the objects\\n for otype, fname in self.TYPE2NAME.items():\\n if fname:\\n path = os.path.join(self.anodir, fname + \\\".gz\\\")\\n if os.path.isfile(path):\\n with gzip.open(path, \\\"rt\\\") as handler:\\n for line in handler:\\n omap = json.loads(line)\\n cls = self.TYPE2CLASS[otype]\\n item = cls.from_map(omap, self)\\n self.caches[otype][item.id] = item\",\n \"def before_save(self):\",\n \"def reload(self):\\n from models.base_model import BaseModel\\n from models.user import User\\n from models.amenity import Amenity\\n from models.city import City\\n from models.place import Place\\n from models.review import Review\\n from models.state import State\\n dict_reload = {}\\n try:\\n with open(FileStorage.__file_path) as file:\\n dict_reload = json.load(file)\\n for key, value in dict_reload.items():\\n obj = value[\\\"__class__\\\"]\\n self.__objects[key] = locals()[obj](**value)\\n except:\\n pass\",\n \"def save_model(cls, vocab, path, filename):\\n return super().save_model(vocab, path, filename)\",\n \"def load(self, file_id):\\n pass\",\n \"def post_load(self, data):\\n return data\",\n \"def __getattribute__(self, attrname):\\n\\n if 'load' in attrname or 'save' in attrname:\\n return getattr(self._smodel, attrname)\\n else:\\n return super(ModelMGPU, self).__getattribute__(attrname)\",\n \"def save(self):\\r\\n try:\\r\\n self.process_save()\\r\\n except InputError as ex:\\r\\n print(ex)\\r\\n self.save()\\r\\n except KeyError:\\r\\n print(\\\"No saved data to save/load. Please save some data before loading in data.\\\")\\r\\n self.menu_page()\",\n \"def save(self, filename):\\n\\t\\tif (self.isLoaded()):\\n\\t\\t\\tself.loader.save(filename)\",\n \"def save(self,fn):\\n fn = fn if fn[-4:] == \\\".pkl\\\" else fn+\\\".pkl\\\"\\n with open(fn,\\\"wb+\\\") as f:\\n pickle.dump(self,f)\\n log(\\\"Saved reader to {}\\\".format(fn))\",\n \"def load(self):\\n super(YacoFile, self).load(self._filename)\",\n \"def load_class(self):\\n if not os.path.exists(self.savefile):\\n self.save_class()\\n\\n with open(self.savefile, \\\"r\\\") as f:\\n data = json.load(f)\\n for key, value in data.items():\\n # set every dict key to an atribute of the class\\n setattr(self, key, value) # self.key = value\",\n \"def load(self):\\n if os.path.isfile(self.save_filename):\\n data = cloudpickle.load(open(self.save_filename, \\\"rb\\\"))\\n (\\n self.Joints,\\n self.Links,\\n self.joint_syms,\\n self.global_syms,\\n self.name,\\n self.sym_prefix,\\n ) = data\\n return True\\n return False\",\n \"def init_saver(self):\\n self.saver = tf.train.Saver(max_to_keep=self.config.max_to_keep, save_relative_paths=True)\",\n \"def init_saver(self):\\n self.saver = tf.train.Saver(max_to_keep=self.config.max_to_keep, save_relative_paths=True)\",\n \"def reload(self):\\n if file_exist(self.__file_path):\\n with open(self.__file_path, \\\"r\\\", encoding=\\\"UTF-8\\\") as file:\\n data = read_data(file)\\n for key, value in data.items():\\n instance = BaseModel(**value)\\n FileStorage.__objects[key] = instance\",\n \"def save(self):\\n pass\",\n \"def save(self):\\n pass\",\n \"def save(self):\\n pass\",\n \"def save(self):\\n pass\",\n \"def save(self):\\n pass\",\n \"def _save_helper(self, filepath, data_dict):\\n # Set Default filepath\\n if filepath is None:\\n filepath = \\\"profile-{}.pkl\\\".format(\\n datetime.now().strftime(\\\"%d-%b-%Y-%H:%M:%S.%f\\\"))\\n\\n # Remove data labelers as they can't be pickled\\n data_labelers = self._remove_data_labelers()\\n\\n # add profiler class to data_dict\\n data_dict['profiler_class'] = self.__class__.__name__\\n\\n # Pickle and save profile to disk\\n with open(filepath, \\\"wb\\\") as outfile:\\n pickle.dump(data_dict, outfile)\\n\\n # Restore all data labelers\\n self._restore_data_labelers(data_labelers)\",\n \"def get_load(self):\\n return str(self.load)\",\n \"def load_checkpoint(model, save_path):\\n model.load_state_dict(torch.load(save_path))\",\n \"def _load_state(self):\\n \\n if os.path.isfile(self.histFile):\\n with open(self.histFile,'rb') as hf:\\n oldFile = hf.read()\\n \\n if os.path.isfile(oldFile):\\n self.dbFile.Value = oldFile\",\n \"def load(self, func):\\n self._init = func.__name__\",\n \"def __init__(self):\\n self.load()\",\n \"def test_load_save_model():\\n model = BERTopic(language=\\\"Dutch\\\", embedding_model=None)\\n model.save(\\\"test\\\")\\n loaded_model = BERTopic.load(\\\"test\\\")\\n assert type(model) == type(loaded_model)\\n assert model.language == loaded_model.language\\n assert model.embedding_model == loaded_model.embedding_model\\n assert model.top_n_words == loaded_model.top_n_words\",\n \"def load_model(self, **params):\\n \\t# file_name = params['name']\\n # return pickle.load(gzip.open(file_name, 'rb'))\",\n \"def save (self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6482302","0.6482302","0.6482302","0.6482302","0.63209206","0.62857485","0.62781924","0.6270234","0.62581646","0.62424845","0.6232893","0.61957574","0.6152661","0.6152661","0.6097419","0.60608494","0.60358715","0.602136","0.602136","0.60017306","0.59976506","0.5986563","0.5984795","0.59689856","0.5957335","0.5927296","0.59092927","0.59046793","0.588093","0.58700716","0.58671993","0.58517355","0.5848846","0.5834442","0.5790076","0.576695","0.5766641","0.57456195","0.57456195","0.5743499","0.57429117","0.5740082","0.57253027","0.5720052","0.571922","0.57116944","0.5708988","0.570306","0.5694367","0.5688699","0.5683592","0.5683592","0.56701183","0.5669877","0.5663425","0.5651275","0.5644595","0.5620986","0.56116164","0.5588232","0.55838937","0.55817276","0.5577792","0.5574143","0.55672514","0.55453134","0.5543661","0.5539502","0.55267906","0.5520004","0.55183506","0.5516794","0.549383","0.54928017","0.5488995","0.54889244","0.5485954","0.547822","0.5473483","0.5471921","0.5469976","0.5461789","0.5459617","0.54468745","0.5434219","0.5434219","0.54128087","0.54121715","0.54121715","0.54121715","0.54121715","0.54121715","0.53988445","0.5396172","0.53942436","0.5380375","0.53803086","0.53800094","0.5379672","0.5374252","0.5371853"],"string":"[\n \"0.6482302\",\n \"0.6482302\",\n \"0.6482302\",\n \"0.6482302\",\n \"0.63209206\",\n \"0.62857485\",\n \"0.62781924\",\n \"0.6270234\",\n \"0.62581646\",\n \"0.62424845\",\n \"0.6232893\",\n \"0.61957574\",\n \"0.6152661\",\n \"0.6152661\",\n \"0.6097419\",\n \"0.60608494\",\n \"0.60358715\",\n \"0.602136\",\n \"0.602136\",\n \"0.60017306\",\n \"0.59976506\",\n \"0.5986563\",\n \"0.5984795\",\n \"0.59689856\",\n \"0.5957335\",\n \"0.5927296\",\n \"0.59092927\",\n \"0.59046793\",\n \"0.588093\",\n \"0.58700716\",\n \"0.58671993\",\n \"0.58517355\",\n \"0.5848846\",\n \"0.5834442\",\n \"0.5790076\",\n \"0.576695\",\n \"0.5766641\",\n \"0.57456195\",\n \"0.57456195\",\n \"0.5743499\",\n \"0.57429117\",\n \"0.5740082\",\n \"0.57253027\",\n \"0.5720052\",\n \"0.571922\",\n \"0.57116944\",\n \"0.5708988\",\n \"0.570306\",\n \"0.5694367\",\n \"0.5688699\",\n \"0.5683592\",\n \"0.5683592\",\n \"0.56701183\",\n \"0.5669877\",\n \"0.5663425\",\n \"0.5651275\",\n \"0.5644595\",\n \"0.5620986\",\n \"0.56116164\",\n \"0.5588232\",\n \"0.55838937\",\n \"0.55817276\",\n \"0.5577792\",\n \"0.5574143\",\n \"0.55672514\",\n \"0.55453134\",\n \"0.5543661\",\n \"0.5539502\",\n \"0.55267906\",\n \"0.5520004\",\n \"0.55183506\",\n \"0.5516794\",\n \"0.549383\",\n \"0.54928017\",\n \"0.5488995\",\n \"0.54889244\",\n \"0.5485954\",\n \"0.547822\",\n \"0.5473483\",\n \"0.5471921\",\n \"0.5469976\",\n \"0.5461789\",\n \"0.5459617\",\n \"0.54468745\",\n \"0.5434219\",\n \"0.5434219\",\n \"0.54128087\",\n \"0.54121715\",\n \"0.54121715\",\n \"0.54121715\",\n \"0.54121715\",\n \"0.54121715\",\n \"0.53988445\",\n \"0.5396172\",\n \"0.53942436\",\n \"0.5380375\",\n \"0.53803086\",\n \"0.53800094\",\n \"0.5379672\",\n \"0.5374252\",\n \"0.5371853\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93197,"cells":{"query":{"kind":"string","value":"Writing a csv file of the keywordspecified lists."},"document":{"kind":"string","value":"def write_output_csv(filename, **kwargs):\n import csv\n import time\n\n intermediate = kwargs.pop(\"intermediate\", False)\n\n keys = sorted(kwargs.keys())\n num_vars = len(keys)\n\n if intermediate:\n full_filename = filename + \"_interm\"\n else:\n dot_index = filename.rfind('.')\n if dot_index != -1:\n full_filename = (filename[:dot_index]\n + time.strftime(\"%Y-%m-%d-%H.%M.%S\")\n + filename[dot_index:])\n else:\n full_filename = filename + time.strftime(\"%Y-%m-%d-%H.%M.%S\")\n\n # add current time to filename as an identifier\n with open(full_filename, 'w', newline='') as csvfile:\n\n writer = csv.writer(csvfile)\n\n # write header\n writer.writerow(keys)\n\n num_entries = len(kwargs[keys[0]])\n for i in range(num_entries):\n writer.writerow(kwargs[keys[j]][i] for j in range(num_vars))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def write_csv(self, key_list, word_list):\n # Write out data\n out_data = []\n # Match filtered indexes to words\n for i in key_list.index:\n subset = word_list[word_list['key'] == i]\n # Add to aggregate list\n out_data.append(subset['word'].tolist())\n # Dump list to headerless CSV\n with open(self.output, 'w') as f:\n writer = csv.writer(f)\n writer.writerows(out_data)\n return len(out_data)","def write_csv(list_file, path):\n\n\twith open(path, 'w') as f:\n\t\twriter = csv.writer(f, delimiter=',')\n\t\tfor i in list_file:\n\t\t\twriter.writerow(i)","def writeCSV(path,aList):\n\twith open(path,'wb') as w:\n\t\ta = csv.writer(w, delimiter = ',')\n\t\ta.writerows(aList)\n\tw.close()","def generate_csv(lists, output_file):\n if os.path.isfile(output_file):\n with open(output_file, 'a') as file:\n dataset = tablib.Dataset()\n for l in lists:\n dataset.append([l['Original ASIN'], l['Associated ASIN'], l['Title'], l['Price'], l['Currency Code'], l['Relationship']])\n file.write(dataset.csv)\n else:\n with open(output_file, 'w+') as fp:\n dataset = tablib.Dataset(headers=['Original ASIN', 'Associated ASIN', 'Title', 'Price', 'Currency Code', 'Relationship'])\n for l in lists:\n dataset.append([l['Original ASIN'], l['Associated ASIN'], l['Title'], l['Price'], l['Currency Code'], l['Relationship']])\n fp.writelines(dataset.csv)","def write_csv(self, stock_list):\n\n with open(self.outfile, 'w') as outfile:\n writer = csv.writer(outfile, delimiter=',',\n quoting=csv.QUOTE_MINIMAL)\n for symbol, values in stock_list.items():\n # Need to find a better way to handle this...\n writer.writerow([values['symbol'], values['name']])","def csv_file(data,output_dir,filename,order = [],head = True):\n with open(output_dir + filename + '.csv', 'w') as f:\n write = csv.writer(f)\n write.writerows(manip.dic_to_list(data,order,head),)\n return None","def write_csv(fname, olist):\n ofile = open(fname, \"wb\")\n writer = csv.writer(ofile, delimiter=',', quotechar='\"',\n quoting=csv.QUOTE_ALL)\n writer.writerows(olist)","def write_csv_file (metadata_list, csv_file, append) :\n try :\n with open (csv_file, 'a' if append else 'w' , newline='') as file :\n writer = csv.DictWriter(file, fieldnames=MetadataEntity.get_fieldnames())\n if not append: writer.writeheader()\n for e in metadata_list :\n writer.writerow(e.get_values())\n file.close()\n except :\n print ('ERROR: writing csv file: ' + csv_file)\n return False\n return True","def makeCSV(self,file_name, data, topList):\n file_name = file_name+\".csv\"\n w = csv.writer(open(file_name, \"w\"))\n w.writerow(topList)\n for key, val in data.items():\n row = list(val)\n row.insert(0,key)\n w.writerow(row)","def writeCSV(list, filename):\n with open(filename, \"w\") as file:\n for row in list:\n for i in range(len(row)):\n file.write(str(row[i]))\n if i != len(row) - 1:\n file.write(\",\")\n else:\n file.write(\"\\n\")\n return","def save_csv(filename, save_list):\n with open(filename, mode='w') as csv:\n csv.writelines([','.join(item) + '\\n' for item in save_list])","def write_csv(row_list,out_name,*header_strings : str):\n with open(out_name,'w',newline='') as result_file:\n wr = csv.writer(result_file, delimiter='\\t')\n if header_strings:\n wr.writerow([name for name in header_strings])\n if type(row_list[0]) is list:\n wr.writerows(row_list)\n else:\n for row in row_list:\n wr.writerow([row])","def save_csv(outfile, cities):\n writer = csv.writer(outfile)\n writer.writerow(['Name'])\n for row in cities:\n writer.writerow([row])","def export_corpus_csv(corpus,path, delimiter = ',', trans_delimiter = '.'):\n word = corpus.random_word()\n header = sorted(word.descriptors)\n with open(path, encoding='utf-8', mode='w') as f:\n print(delimiter.join(header), file=f)\n for key in corpus.iter_sort():\n print(delimiter.join(make_safe(getattr(key, value),trans_delimiter) for value in header), file=f)","def writeItemsToCSV(self, fileName, itemList):\n\t\twith open(fileName, 'w') as csvFile:\n\t\t csvWriter = csv.writer(csvFile, delimiter=',')\n\t\t # Column titles\n\t\t csvWriter.writerow([\"Brandname\",\"Productname\",\"Colors\",\"Sizes\",\"Description\",\"Materials\",\"Maintenance\",\"RegularPrice\",\"CurrentPrice\"])\n\t\t for item in itemList:\n\t\t csvWriter.writerow(list(item))","def save_csv(outputfile):\n with open(outputfile, 'w', newline='') as outfile:\n writer = csv.writer(outfile)\n writer.writerow(DATA_KEYS)\n\n # Add data to csv-file\n for data in data_list:\n writer.writerow(data)","def save_reviews_to_csv(language, review_list, dataset):\n with open('reviews_'+dataset+'_'+language+'.csv', 'w') as csvfile:\n fieldnames = review_list[0].__dict__.keys()\n writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\n\n writer.writeheader()\n for review in review_list:\n writer.writerow(review.__dict__)","def write_csv(csv_list, out_csv_path):\n with open(out_csv_path, 'w', newline='') as csv_file:\n csv_writer = csv.writer(csv_file)\n for row in csv_list:\n csv_writer.writerow(row)","def generate_csv(type, json_list, columns_list):\n with open(\"data/\" + type + \"_\" + time.strftime(\"%Y-%m-%d_%H:%M:%S\") +\n \".csv\", 'a+') as f:\n csv_file = csv.DictWriter(f, fieldnames=columns_list,\n extrasaction=\"ignore\")\n csv_file.writeheader()\n for item in json_list:\n csv_file.writerow(item)\n print(\"\\nCSV file saved as data/\" + type + \"_\" +\n time.strftime(\"%Y-%m-%d_%H:%M:%S\") + \".csv\")","def write(self, args):\n\t\tnewcsvfile = self.filename[:len(self.filename)-4] + \"NEW.csv\" #clever naming MIGHT NEED TO CHANGE THIS LATER/OVERWRITE OLD FILE?\n\t\twith open(newcsvfile, 'wb') as f:\n\t\t\twriter = csv.writer(f)\n\t\t\twriter.writerows(self.all_likes)","def tdl_to_csv(filename, list_of_strings, delim='\\t'):\n header = list_of_strings[0].split(delim)\n data = [ dict(zip(header, line.split(delim))) for line in list_of_strings[1:] ]\n data = [OrderedDict(zip(header,header))] + data\n o = csv.DictWriter(open(filename, 'w'), header)\n o.writerows(data)","def save(filename, data, keys):\n with open(filename,'w') as fd:\n csv_out = csv.writer(fd, delimiter=',', quotechar='\"')\n csv_out.writerow(keys)\n for row in zip( *[data[k] for k in keys] ):\n csv_out.writerow(row)","def List_to_CSV(OutFname, DataList):\n with open(OutFname, 'w') as myfile:\n wr = csv.writer(myfile, delimiter=',')\n wr.writerows(line for line in DataList)","def write_relevance_tocsv(relevance, corpus):\n csv_filename = config.CORPUS[corpus]['relevance_file']\n print('writing relevance')\n print(relevance)\n with open(csv_filename, 'w') as file:\n csv.writer(file).writerows((k,) + v for k, v in relevance.items())","def csv_writer(filepath, seqs):\n with open(filepath, 'w') as f:\n f.write('\\n'.join([','.join(\n ['\"{}\"'.format(r) \n if (' ' in r) or (',' in r) else r\n for r in s])\n for s in seqs]))","def write_csv(file_names: list, csv_file_path: str):\n with open(csv_file_path, mode='w') as csv_file:\n writer = csv.writer(csv_file)\n writer.writerows(enumerate(file_names))","def outputFunc(filename, resultList):\n #assert len(parks) == 3\n \n f = open(filename, 'wt')\n \n try:\n writer = csv.writer(f)\n for i in range(len(resultList)):\n print resultList[0]\n writer.writerow(resultList[i])\n \n finally:\n f.close()","def persist_list_to_csv(liste, nom_fichier):\n with open(nom_fichier, 'w') as f:\n for elem in liste :\n f.write(\"{}\\n\".format(elem))","def writeCSV():\n final_list = get_final_list()\n path_to_csv_File = 'system_metrics.csv'\n\n csv_file = open(path_to_csv_File, 'w+', newline='', encoding=\"utf8\")\n csv_file_writer = csv.writer(csv_file, delimiter=',')\n\n csv_file_writer.writerow(['Subscription', 'Resource', 'MetricType',\n 'Timestamp', 'Unit', 'Minimum', 'Maximum', 'Average'])\n\n for item in final_list:\n csv_file_writer.writerow([item['subscription'], item['resource'], item['metricType'], item['timestamp'],\n item['unit'], item['minimum'], item['maximum'], item['average']])\n\n print('Output written successfully!!')","def csv_file_creator(path, list_of_jobs):\n with open(path, \"wb\") as out_file:\n writer = UnicodeWriter(out_file, delimiter=',')\n for row in list_of_jobs:\n writer.writerow(row)","def write_output_file(ad_models):\n\n with open('output-data-utf8.csv', 'w', newline='', encoding='UTF-8') as output_file:\n csv_writer = csv.writer(output_file, delimiter=',')\n for ad in ad_models:\n csv_writer.writerow((ad.date.strftime('%Y/%m/%d'), ad.country_code, ad.impression, ad.clicks))","def outputFunc(filename, parks,roading,private):\n #assert len(parks) == 3\n \n f = open(filename, 'wt')\n \n try:\n writer = csv.writer(f)\n writer.writerow(days)\n writer.writerow(parks)\n writer.writerow(roading)\n writer.writerow(private)\n finally:\n f.close()","def generate_csv(filename='', datafile='queryData.txt', keywords=mainKeywords):\n\n fulltitle = os.path.join(os.getcwd(), 'results', 'searchWoKResults', filename + 'MaterialsKeySearchFull.csv')\n contitle = os.path.join(os.getcwd(), 'results', 'searchWoKResults', filename + 'MaterialsKeySearchCondensed.csv')\n datatitle = os.path.join(os.getcwd(), 'results', 'searchWoKResults', filename + datafile)\n\n with open(fulltitle, 'wt') as csvFull, open(contitle, 'wt') as csvCon, open(datatitle, 'rt') as data:\n fwriter = csv.writer(csvFull, delimiter=',', quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n cwriter = csv.writer(csvCon, delimiter=',', quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n querydata = json.load(data)\n\n conheader = ['Material', 'Publications', 'Crystal System', 'Space Group', 'Calculated Band Gap']\n for n in keywords:\n conheader.append(n)\n cwriter.writerow(conheader)\n\n linenum = 0\n\n print('GETTING KEYWORD LIST:')\n print('Searching for ' + str(keywords) + '\\n')\n\n for searchData in querydata:\n print('Searching through ' + searchData[0]['material'] + ' data')\n\n keylist = searchWoKTools.getkeylist(searchData, keywords)\n\n print('Generating clouds')\n wc = searchWoKTools.generateabstractwc(searchData)\n imgpath = os.path.join(os.getcwd(), 'results', 'searchWoKResults', filename, searchData[0]['material'] + '.png')\n wc.to_file(imgpath)\n\n print('Writing CSV')\n fwriter.writerow([searchData[0]['material'],\n str(searchData[0]['numResults']) + ' publications',\n searchData[0]['crystalsystem'],\n searchData[0]['spacegroup'] + ' spacegroup',\n searchData[0]['bandgap'] + ' band gap',\n searchData[0]['searchURL'],\n '=HYPERLINK(\"' + imgpath + '\",\"Word Cloud\")'])\n linenum += 1\n\n conline = [\n '=HYPERLINK(\"[' + fulltitle + ']' + filename + 'MaterialsKeySearchFull' + '!A' + str(linenum) + '\",\"' +\n searchData[0]['material'] + '\")',\n\n str(searchData[0]['numResults']),\n searchData[0]['crystalsystem'],\n searchData[0]['spacegroup'],\n searchData[0]['bandgap']]\n\n fwriter.writerow([])\n linenum += 1\n\n for key in keylist.keys():\n keyrow = []\n conkeynum = 0\n for n in range(len(keylist[key])):\n if keylist[key][n] != 0:\n cellstring = '=HYPERLINK(\"' + searchData[1][n]['DOIlink'] + '\",\"' + key + '(' + str(\n keylist[key][n]) + ')\")'\n keyrow.append(cellstring)\n conkeynum += 1\n if keyrow:\n fwriter.writerow(keyrow)\n linenum += 1\n if conkeynum != 0:\n constring = '=HYPERLINK(\"[' + fulltitle + ']' + filename + 'MaterialsKeySearchFull' + '!A' + str(\n linenum) + '\",\"' + str(conkeynum) + '\")'\n conline.append(constring)\n else:\n conline.append('')\n\n cwriter.writerow(conline)\n\n fwriter.writerow([])\n fwriter.writerow([])\n linenum += 2\n\n return","def write_csv(self, outfile, collapse_orders=False, show_age=False):\r\n # Write header row\r\n outfile.write(self.get_csv_header(collapse_orders, show_age).encode())\r\n\r\n # Write content\r\n for x in self.records:\r\n x.write_csv(outfile, collapse_orders, show_age)","def write_csv(self, filelike):\r\n items = self.rows()\r\n writer = unicodecsv.writer(filelike, encoding=\"utf-8\")\r\n writer.writerow(self.header())\r\n for item in items:\r\n writer.writerow(item)","def write_list(outputfilename, list):\r\n try:\r\n with open(outputfilename, 'w', newline='', encoding='utf-8') as outfile:\r\n itemwriter = csv.writer(outfile, delimiter=\",\")\r\n for item in list:\r\n itemwriter.writerow(item)\r\n except:\r\n input(\"File still open! Please close and press enter to continue\")\r\n with open(outputfilename, 'w', newline='', encoding='utf-8') as outfile:\r\n itemwriter = csv.writer(outfile, delimiter=\",\")\r\n for item in list:\r\n itemwriter.writerow(item)","def write_to_csv(list_of_rows, file_name):\n with open(file_name, 'w') as f:\n writer = csv.writer(f)\n for row in list_of_rows:\n if None in row:\n continue\n writer.writerow(row)\n \n f.close()","def save_to_csv(list_return, name, fieldnames):\n os.makedirs(os.path.dirname(name + '.csv'), exist_ok=True)\n with open(name + '.csv', 'w') as csvfile:\n csvfile.write(','.join(map(str, field_names)))\n csvfile.write('\\n')\n write = csv.writer(csvfile, delimiter=',')\n for x in range(0, len(list_return)):\n write.writerow(list_return[x])","def writeToMonthCsv(news_dict):\n\n for k in news_dict:\n output_f = open(k + \".csv\", \"wb\")\n writer = csv.writer(output_f)\n writer.writerow([news_dict[k].replace(\",\", \"\").encode(\"utf-8\")])\n output_f.close()","def write_to_csv(self, data_points):\n keys = data_points[0].keys()\n with open(self.report_path, 'w') as output_file:\n dict_writer = csv.DictWriter(output_file, keys)\n dict_writer.writeheader()\n dict_writer.writerows(data_points)","def csv_writelist(file, oldfile, chlst, num):\n import csv\n writelist = checkdifferences(oldfile, chlst, num)\n print('before', writelist)\n with open('{}.csv'.format(file), 'w', newline='') as csvwrite:\n writer = csv.writer(csvwrite, delimiter=';')\n try:\n for eachrow in writelist:\n writer.writerow(eachrow)\n except:\n if TypeError:\n print('Typeerror')\n csvwrite.close()","def write_file(self, filename):\n\n with open(filename, 'w', newline = '') as csvfile:\n langwriter = csv.writer(csvfile, delimiter=' ',\n quotechar='|', quoting=csv.QUOTE_MINIMAL)\n for key in self.features:\n value = self.features[key]\n l = []\n for val in value:\n l.append(str(val))\n langwriter.writerow([l])\n return","def writetoCSV(self, fileName):\n\n with open(fileName, 'w') as writeFile:\n writeFile.write(\"ID,Fx,Fy,Fz\\n\")\n for fstnr in F:\n writeFile.write(str(fstnr.ID))\n for i in fstnr.force:\n writeFile.write(',' + str(i))\n writeFile.write('\\n')","def export(tako_list, filename):\n for tak in tako_list:\n tak = tak[0]\n l1 = [tak.ident, \"a\"]\n for gen in tak.genome.weightchr_a:\n l1.append(gen.ident)\n l1.append(gen.weight)\n l1.append(gen.mut_rate)\n l1.append(gen.dom)\n f = os.path.join(\"Data\", (filename[:-4] + \" gene data.csv\"))\n with open(f, 'a', newline=\"\") as csvfile:\n writ = csv.writer(csvfile)\n writ.writerow(l1)\n if len(tak.genome.weightchr_b) != 0:\n l2 = [tak.ident, \"b\"]\n for gen in tak.genome.weightchr_b:\n l2.append(gen.ident)\n l2.append(gen.weight)\n l2.append(gen.mut_rate)\n l2.append(gen.dom) \n writ.writerow(l2)","def save_to_file_csv(cls, list_objs):\n l = []\n if list_objs is not None:\n for item in list_objs:\n l.append(item.to_dictionary())\n with open(\"%s.csv\" % cls.__name__, mode='w') as f:\n f.write(Base.to_json_string(l))","def outputapidata_csv(filename, data, headers=None):\n with open(filename,'w',encoding='utf-8',newline = \"\", ) as f:\n if headers:\n writer = csv.DictWriter(f,fieldnames = headers)\n writer.writeheader()\n else:\n writer = csv.DictWriter(f)\n writer.writerows(out)","def write_csv_label(labels, csv_file):\n with open(csv_file, 'w') as f:\n writer = csv.writer(f)\n for key, value in labels.items():\n writer.writerow([key, value])","def gp_file(data,filename,output_dir='',order = [],head = False):\n f = open(output_dir + filename + '.csv', 'w')\n f.write(str(len(order)-1) + '\\n')\n write = csv.writer(f)\n write.writerows(manip.dic_to_list(data,order,head),)\n f.closed\n\n return None","def create_csv(self):\n try:\n # Convert List of Lists to DataFrame and write it to a CSV\n pd.DataFrame(self.data, columns=self.header) \\\n .to_csv(os.path.join(self.file_path, self.file_name), index=False)\n self.successful_run = True\n except:\n # TODO create Exception Handling\n raise","def csv_save_list(list_data, path, lineterminator='\\n', encoding=None):\n with open(path, 'w') as f:\n writer = csv.writer(f, lineterminator=lineterminator)\n for item in list_data:\n if encoding is not None:\n writer.writerow([item.encode(encoding)])\n else:\n writer.writerow([item])","def CSVWriter (iterable, outLoc, header=\"\", ):\n if not iterable:\n print (\"nothing to write\")\n return 0\n\n out = open(outLoc, 'w')\n\n if header:\n out.write(header+'\\n')\n\n #Only works if iterable is a nested list\n for member in iterable:\n for item in member:\n out.write(str(item)+',')\n out.write('\\n')\n\n print(\"write to \"+outLoc+\" successful.\")\n return 1","def write_into_csv(self, loc_details=[], itype='atm', mode='w'): \n \n if itype==\"brc\":\n csvfile_name = self.branch_file\n headers = self.branch_headers\n else:\n csvfile_name = self.atm_file\n headers = self.atm_headers\n\n with open(csvfile_name, mode, newline='') as csvfile:\n locwriter = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_ALL)\n if mode=='w':\n locwriter.writerow(headers) \n\n for loc in loc_details:\n locwriter.writerow(loc)","def _write_csv(self):\n\n # add the label to the header\n if self.input_data.get_value(InputType.TIME_PERIOD) == 'all':\n self.header.append('Date')\n else:\n self.header.append('sample id')\n\n key_list = []\n\n for i, cube in enumerate(self.cube_list):\n if self.input_data.get_value(InputType.TIME_PERIOD) == 'all':\n self._write_sample_with_date(cube, i, key_list)\n else:\n self._write_sample(cube, i, key_list)\n\n output_data_file_path = self._get_full_file_name()\n self._write_data_dict(output_data_file_path, key_list)\n\n return [output_data_file_path]","def save_double_list(list1, list2, filename):\r\n the_file = open(filename, \"wb\")\r\n try:\r\n writer = csv.writer(the_file)\r\n if len(list1)!=len(list2):\r\n raise Exception(\"Saving a double list : The list have not the same length !\")\r\n for i in range(len(list1)):\r\n writer.writerow( (list1[i], list2[i]) ) \r\n finally:\r\n the_file.close()","def add_to_csv(file_name, single_list):\n final_list = read_csv(file_name)\n writer = csv.writer(open(file_name, 'wb'), delimiter=',',quoting=csv.QUOTE_MINIMAL)\n final_list.append(single_list)\n for x in final_list:\n writer.writerow(x)","def write_to_file(self, results):\n with open(self.outputFilename, \"w\") as csvFile:\n csvWriter = csv.writer(csvFile, delimiter=',') \n title_row = ('asset_id', 'component_id', 'latitude', 'longitude', 'installation_date', 'commissioning_date', 'street_name', 'cabinet_id', 'nominal_wattage', 'current_time', 'current_LogValue', 'current_IsLogValueOff') \n csvWriter.writerow(title_row)\n for record in results:\n csvWriter.writerow(record)","def write_to_csv(self, verbose: bool = False) -> None: \n Path(self.csv_dir).mkdir(exist_ok=True)\n with open(f\"{self.csv_dir}/train.csv\", \"wt\", encoding=\"utf-8\", newline=\"\") as train_file:\n with open(f\"{self.csv_dir}/test.csv\", \"wt\", encoding=\"utf-8\", newline=\"\") as test_file:\n csv_header = (\"phone\", \"phone_class_index\", \"f1\", \"f2\", \"f3\", \"f4\", \"f5\")\n train_csvwriter = csv.writer(train_file)\n test_csvwriter = csv.writer(test_file)\n train_csvwriter.writerow(csv_header)\n test_csvwriter.writerow(csv_header)\n for vowels_and_formants, wav_path, category in self:\n if verbose:\n print(f\"File: {wav_path} (category: {category})\")\n writer = train_csvwriter if category == \"TRAIN\" else test_csvwriter\n for vowel_and_formants in vowels_and_formants:\n phone, formants = vowel_and_formants\n row = (phone, ipa_class_index[phone]) + tuple(formants)\n writer.writerow(row)\n if verbose:\n print(row)","def writeToCsv(news_dict, f_name):\n\n f_data = open(f_name, \"wb\")\n writer = csv.writer(f_data)\n for k in news_dict:\n writer.writerow([k, news_dict[k].replace(\",\", \"\")])\n f_data.close()","def generate_csv(self, output_file):\n try: # We are going to \"try\" something\n csv_file = open(output_file, 'w+') # open \"output_file\" as a writable file and return a handle called \"csv_file\"\n except OSError as err: # If something goes wrong with the open, we catch the exception\n fatal(\"{0}\".format(err), -1) # exit with something other than 0 so the shell knows something went wrong\n \n writer = csv.writer(csv_file) # create a CSV writing object that's pointing at our open file handle\n\n writer.writerow([\"Question\",\"Answers\"]) # Let's write the top row\n for k in self.questions.keys(): # Let's walk down the directory by key\n # write the \"key\" (which is the question) and then let's take the list of answers and create a comma delmited list.\n # this is likely totally wrong since you could have an answer in it that also has a comma...\n writer.writerow([k, \",\".join(self.questions[k].answers)]) # insert a key (which is the question) and then let's take the array of \n\n csv_file.close() # close the csv_file file handle","def _export_csv(x, y, export_to):\r\n\r\n with open(export_to, 'w', newline='') as e:\r\n writer = csv.writer(e, delimiter=',')\r\n for i in range (0, len(x)):\r\n writer.writerow([x[i], y[i]])","def write_csv(self, filename: str, author_data: list):\n split_file = filename.split('/')\n new_filename = \"\"\n for index, component in enumerate(split_file):\n if index == len(split_file) - 1:\n break\n new_filename += component + \"/\"\n new_filename += \"results_\" + split_file[-1]\n with open(new_filename, 'w') as csvfile:\n result_writer = csv.writer(csvfile)\n result_writer.writerow(self._csv_headings)\n for author in author_data:\n result_writer.writerow(self.author_data_to_str(author))\n csvfile.close()","def write_csv(error_list, user_list):\n\n with open('error_log.csv', 'w', newline='') as csv_file:\n writer = csv.writer(csv_file)\n writer.writerow(['ERROR', 'COUNT'])\n for value in error_list:\n writer.writerow(value)\n\n with open('user_statistics.csv', 'w', newline='') as csv_file:\n fields = ['USER', 'ERROR', 'INFO']\n writer = csv.DictWriter(csv_file, fields)\n writer.writeheader()\n for key, value in user_list:\n row = {'USER': key}\n row.update(value)\n writer.writerow(row)","def csvwrite(inlist, stringify=False):\n out_list = []\n for entry in inlist:\n if stringify:\n new_entry = []\n for val in entry:\n if not isinstance(val, basestring):\n val = str(val)\n new_entry.append(val)\n entry = new_entry\n this_line = ', '.join([elem_quote(val) for val in entry])\n out_list.append(this_line)\n return out_list","def save_to_file_csv(cls, list_objs):\n with open(cls.__name__ + \".csv\", \"w\", newline='') as f:\n if cls.__name__ == \"Rectangle\":\n fieldnames = ['id', 'width', 'height', 'x', 'y']\n elif cls.__name__ == \"Square\":\n fieldnames = ['id', 'size', 'x', 'y']\n writer = csv.DictWriter(f, fieldnames=fieldnames)\n writer.writeheader()\n if list_objs is not None:\n for model in list_objs:\n writer.writerow(model.to_dictionary())","def save_list_of_list(data, path, lineterminator='\\n', encoding=None):\n with open(path, 'w') as f:\n writer = csv.writer(f, lineterminator=lineterminator)\n if encoding is not None:\n data = [[item.encoding(encoding) for item in items]\n for items in data]\n writer.writerows(data)","def to_csv(list_dicts, file_name):\n # We assume that all the dictionaries have the same keys\n fieldnames = list_dicts[0].keys()\n\n with open(file_name, 'w') as output_file:\n dict_writer = csv.DictWriter(output_file, fieldnames)\n dict_writer.writeheader()\n dict_writer.writerows(list_dicts)","def write_to_csv(agents, filename):\n log.info(\"Writing CSV file '%s'...\" % filename)\n with open(filename, 'w', newline='') as csvfile:\n writer = csv.DictWriter(csvfile, fieldnames=place_detail_keys)\n writer.writeheader()\n writer.writerows(agents)","def save_csv(filename, rows):\n with open(filename, 'w', newline='', encoding='utf-8') as f:\n writer = csv.writer(f)\n writer.writerow([\n 'title', 'runtime', 'genre(s)', 'director(s)', 'writer(s)',\n 'actor(s)', 'rating(s)', 'number of rating(s)'\n ])\n\n writer.writerows(rows)","def writeCSV(filename, separator, data):\n \n filetowrite = open(filename, \"w\")\n values = []\n i = 0 #Count the number of objects already written\n for item in data:\n filetowrite.write(item)\n i += 1\n if i < len(data.keys()):\n filetowrite.write(separator)\n values.append(data[item])\n filetowrite.write(\"\\n\")\n i = 0\n for value in values:\n filetowrite.write(str(value))\n i += 1\n if i < len(values):\n filetowrite.write(separator)\n \n filetowrite.close()","def test_csv_writes(self):\n counter = testdata.get_counter()\n csvfile = testdata.create_csv({\n \"foo\": counter,\n \"bar\": testdata.get_words,\n })\n\n for row in csvfile:\n for k in [\"foo\", \"bar\"]:\n self.assertTrue(k in row)\n self.assertTrue(row[k])","def write_csv(image_names, image_classes, filename):\n with open(filename, 'w', newline='') as file:\n writer = csv.writer(file)\n writer.writerow(['filename', 'label'])\n writer.writerows(zip(image_names, image_classes))","def save_to_file_csv(cls, list_objs):\n f_name = cls.__name__ + \".csv\"\n with open(f_name, 'w', newline='') as f:\n if list_objs is None or list_objs == []:\n f.write(\"[]\")\n\n else:\n if cls.__name__ == 'Rectangle':\n h = ['id', 'width', 'height', 'x', 'y']\n else:\n h = ['id', 'size', 'x', 'y']\n ncsv = csv.DictWriter(f, fieldnames=h)\n for obj in list_objs:\n ncsv.writerow(obj.to_dictionary())","def __create_csv(self):\n with open(self.__csv_file_name, 'w', newline='', encoding='utf-8') as csv_file:\n writer = csv.DictWriter(csv_file, fieldnames=self.__csv_fields, delimiter=';')\n writer.writeheader()","def csv_writer(data, path):\n\twith open(path, \"wb\") as csv_file:\n\t\twriter= csv.writer(csv_file, delimiter=',')\n\t\twriter.writerows(data)","def write(l, path, columns):\n \n file = open(path, 'w', newline = '', encoding = 'utf-8')\n writer = csv.writer(file, delimiter = '\\t', quotechar = '', quoting = csv.QUOTE_NONE)\n row = []\n for col in columns:\n row.append(col)\n writer.writerow(row)\n for entry in l:\n row = []\n for col in columns:\n row.append(entry[col])\n writer.writerow(row)\n file.close()","def write_CSV_data(fname, names, npts, nvar, append, data):\n \n if append > 0:\n f = open(fname,'a')\n else:\n f = open(fname,'w')\n for nm in names:\n f.write(nm+',')\n f.write('\\n')\n for j in range(npts):\n for n in range(nvar):\n f.write('%10.4e, ' % data.value(j,n))\n f.write('\\n')\n f.close()","def write_csv(outputfile, delimiter, newline, qchar, encoding, header, rows):\n with open(outputfile, 'w', newline=newline, encoding=encoding) as csvfile:\n writer = csv.writer(csvfile, delimiter=delimiter,\n quotechar=qchar, quoting=csv.QUOTE_MINIMAL)\n writer.writerow(header)\n for row in rows:\n writer.writerow(row)","def write_to_csv(list_of_emails):\n import csv\n # use newline='' to prevent double-spaced rows\n with open('emails.csv', 'w', newline='') as outFile:\n outWriter = csv.writer(outFile)\n charNum = outWriter.writerow(['email'])\n for i in list_of_emails:\n charNum = outWriter.writerow([i])\n outFile.close()","def save_csv(outfile, movies):\n writer = csv.writer(outfile)\n writer.writerow(['Title', 'Rating', 'Year', 'Actors', 'Runtime'])\n for movie in movies:\n writer.writerow(movie)\n\n # ADD SOME CODE OF YOURSELF HERE TO WRITE THE MOVIES TO DISK","def output_to_file(utilist, filepath=\"demo.csv\"):\n os.makedirs(os.path.dirname(filepath), exist_ok=True)\n with open(filepath, \"a\") as f:\n f.write(utilist + \"\\n\")","def to_csv(header, rows):\r\n with open('result.csv', 'w') as result:\r\n result_writer = csv.writer(result, delimiter=';')\r\n result_writer.writerow(header)\r\n result_writer.writerows(rows)","def csv_writer(file_path, data):\n with open(file_path, \"a+\") as f:\n #writer = csv.writer(f, delimiter=',')\n writer = csv.writer(f, lineterminator='\\n')\n writer.writerows(data)\n f.close()","def writecsvfile(filename, columnnames, data):\n with open(filename, 'w', newline='') as csv_file:\n writer = csv.writer(csv_file, delimiter=',')\n writer.writerow(columnnames) # header row\n for row in data:\n writer.writerow(row[:])","def save_csv(outfile, movies):\n fieldnames = ['title', 'rating', 'year', 'actors', 'runtime']\n with open('movies.csv', 'w') as outfile:\n writer = csv.DictWriter(outfile, fieldnames=fieldnames)\n writer.writeheader()\n for line in movies:\n writer.writerow(line)\n\n\n # ADD SOME CODE OF YOURSELF HERE TO WRITE THE MOVIES TO DISK","def generate_csv(table, header):\n with open(\"%s.csv\" % header, \"w\") as csvfile:\n for i in range(len(table)):\n for j in range(len(table[i])):\n if j != len(table[i])-1:\n tmp = table[i][j] + \",\"\n else:\n tmp = table[i][j] + \"\\n\"\n csvfile.write(tmp)","def exportFoldFile(vectors, authors, fileName):\n with open(fileName, \"w\") as fFile:\n for idv, vec in enumerate(vectors):\n [fFile.write(str(val)+',') for val in vec]\n fFile.write(authors[idv] + '\\n')","def store_csv(self):\n\n with open(self.filepath.with_suffix(\".csv\"), 'w',\n newline='') as csvfile:\n fieldnames = ['counter', 'timestamp', 'acceleration']\n writer = DictWriter(csvfile, fieldnames=fieldnames)\n\n writer.writeheader()\n writer.writerows(self.values)","def column_output(self, output_fname, list_2d):\n\t\toutf = open(output_fname, 'w')\n\t\twriter = csv.writer(outf, delimiter='\\t')\n\t\tfor list in list_2d:\n\t\t\twriter.writerow(list)\n\t\tdel writer\n\t\toutf.close()","def WriteToCSV(datalist):\n\n\tglobal csv_success\n\t# Define header\n\theader = ['time', 'accx', 'accy', 'accz', 'gx', 'gy', 'gz', 'mx', 'my', 'mz']\n\n\t# Define our filename\n#\tts = time.time()\n\ttimestamp = time.strftime(\"%Y%m%d_\")\n\n\tfilename = str(timestamp+ \"log.csv\")\n\n\t# Handling to open our file if it exists or create new one\n\tif exists(filename):\n\t\t# try: \n\t\tf = csv.writer(open(filename,\"a\"),lineterminator='\\n')\n\t\t\t# break\n\t\t# except:\n\telse:\n\t\tf = csv.writer(open(filename,\"a+\"),lineterminator='\\n')\n\t\t# Write our header line out if this is a new file\n\t\tf.writerow(header)\n\t\t\n\n\n\t\n\tf.writerow([ datalist['time'], datalist['acc'][0],datalist['acc'][1],datalist['acc'][2],datalist['gyro'][0],datalist['gyro'][1],datalist['gyro'][2],datalist['mag'][0],datalist['mag'][1],datalist['mag'][2] ])\n\t\n\t\n\tcsv_success = True\n\treturn csv_success","def make_csv(file_of_data):\n with open(file_of_data, 'w') as f:\n writer = csv.writer(f)\n header = (\"Counter\", \"Date/time\", \"Latitude\", \"Longitude\", \"Temperature\", \"Humidity\")\n writer.writerow(header)","def save_to_file_csv(cls, list_objs):\n list_dictionaries = []\n if list_objs is None or list_objs == []:\n string_dictionary = \"[]\"\n else:\n for _obj_dict in list_objs:\n list_dictionaries.append(_obj_dict.to_dictionary())\n string_dictionary = Base.to_json_string(list_dictionaries)\n with open(cls.__name__ + \".csv\", \"w\") as _file:\n _file.write(string_dictionary)\n _file.close()","def write_results(results):\n with RESULTS_PATH.open(\"w\") as writer:\n csvwriter = csv.writer(writer)\n csvwriter.writerows(results)","def write_csv(elongation, file_name):\n e = elongation\n\n with open(file_name, 'w') as f:\n f.write(f\"\"\"\\\nBreak Load, {e.break_load()}\nBreak Strength, {e.break_strength()}\nBreak Elongation, {e.break_elongation()}\nYield Load, {e.yield_load()}\nYield Strength, {e.yield_strength()}\nYield Elongation, {e.yield_elongation()}\nGauge Length, {e.gauge_length}\nSample Width, {e.sample_width}\nSample Thickness, {e.sample_thickness}\n\nPoints\n %, N\"\"\")\n for x, y in zip(e.xs, e.ys):\n f.write(f'\\n{x:>8.4f}, {y:>8.4f}')","def outTxt(data, outPath, fileName):\n\n with open(outPath+fileName, \"wb\") as f:\n f.write(\"index,link,name,rating,review,price,category,neighborhood,address,phone,feedback\\n\")\n for record in data:\n f.write(\"%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s\\n\" % \\\n (record[0],record[1],record[2],record[3],record[4],record[5],record[6],\\\n record[7],record[8],record[9],record[10]))","def __create_output_csv(self, df, score_list, elapsed_list):\n df['Similar']=score_list\n df['Elapsed']=elapsed_list\n df.to_csv('Output.csv',index=False)\n return df","def write(lst):\n # TODO","def save_csv_file(votes: dict) -> None:\r\n with open(\"votingList.csv\", \"w\", newline=\"\") as csvfile:\r\n writer = csv.writer(csvfile)\r\n writer.writerow([\"First Name\", \"Last Name\", \"Vote\"])\r\n for vote in votes.keys():\r\n entry = votes[vote]\r\n fst, snd = vote.split()\r\n writer.writerow([fst, snd, entry])","def write_csv(estimates: ListOfDicts, output_csv: str) -> None:\n with open(output_csv, \"w\") as f:\n writer = csv.DictWriter(f, fieldnames=estimates[0].keys())\n writer.writeheader()\n for row in estimates:\n writer.writerow(row)\n logging.info(f\"Wrote estimates as {output_csv}\")","def write_csv(data):\n\n with open('data.csv', 'w') as file:\n writer = csv.DictWriter(file, fieldnames=data[0].keys())\n writer.writeheader()\n for row in data:\n writer.writerow(row)","def create_csv_submission(ids, y_pred, name):\n with open(name, 'w') as csvfile:\n fieldnames = ['Id', 'Prediction']\n writer = csv.DictWriter(csvfile, delimiter=\",\", fieldnames=fieldnames)\n writer.writeheader()\n for r1, r2 in zip(ids, y_pred):\n writer.writerow({'Id':r1,'Prediction':round(r2)})"],"string":"[\n \"def write_csv(self, key_list, word_list):\\n # Write out data\\n out_data = []\\n # Match filtered indexes to words\\n for i in key_list.index:\\n subset = word_list[word_list['key'] == i]\\n # Add to aggregate list\\n out_data.append(subset['word'].tolist())\\n # Dump list to headerless CSV\\n with open(self.output, 'w') as f:\\n writer = csv.writer(f)\\n writer.writerows(out_data)\\n return len(out_data)\",\n \"def write_csv(list_file, path):\\n\\n\\twith open(path, 'w') as f:\\n\\t\\twriter = csv.writer(f, delimiter=',')\\n\\t\\tfor i in list_file:\\n\\t\\t\\twriter.writerow(i)\",\n \"def writeCSV(path,aList):\\n\\twith open(path,'wb') as w:\\n\\t\\ta = csv.writer(w, delimiter = ',')\\n\\t\\ta.writerows(aList)\\n\\tw.close()\",\n \"def generate_csv(lists, output_file):\\n if os.path.isfile(output_file):\\n with open(output_file, 'a') as file:\\n dataset = tablib.Dataset()\\n for l in lists:\\n dataset.append([l['Original ASIN'], l['Associated ASIN'], l['Title'], l['Price'], l['Currency Code'], l['Relationship']])\\n file.write(dataset.csv)\\n else:\\n with open(output_file, 'w+') as fp:\\n dataset = tablib.Dataset(headers=['Original ASIN', 'Associated ASIN', 'Title', 'Price', 'Currency Code', 'Relationship'])\\n for l in lists:\\n dataset.append([l['Original ASIN'], l['Associated ASIN'], l['Title'], l['Price'], l['Currency Code'], l['Relationship']])\\n fp.writelines(dataset.csv)\",\n \"def write_csv(self, stock_list):\\n\\n with open(self.outfile, 'w') as outfile:\\n writer = csv.writer(outfile, delimiter=',',\\n quoting=csv.QUOTE_MINIMAL)\\n for symbol, values in stock_list.items():\\n # Need to find a better way to handle this...\\n writer.writerow([values['symbol'], values['name']])\",\n \"def csv_file(data,output_dir,filename,order = [],head = True):\\n with open(output_dir + filename + '.csv', 'w') as f:\\n write = csv.writer(f)\\n write.writerows(manip.dic_to_list(data,order,head),)\\n return None\",\n \"def write_csv(fname, olist):\\n ofile = open(fname, \\\"wb\\\")\\n writer = csv.writer(ofile, delimiter=',', quotechar='\\\"',\\n quoting=csv.QUOTE_ALL)\\n writer.writerows(olist)\",\n \"def write_csv_file (metadata_list, csv_file, append) :\\n try :\\n with open (csv_file, 'a' if append else 'w' , newline='') as file :\\n writer = csv.DictWriter(file, fieldnames=MetadataEntity.get_fieldnames())\\n if not append: writer.writeheader()\\n for e in metadata_list :\\n writer.writerow(e.get_values())\\n file.close()\\n except :\\n print ('ERROR: writing csv file: ' + csv_file)\\n return False\\n return True\",\n \"def makeCSV(self,file_name, data, topList):\\n file_name = file_name+\\\".csv\\\"\\n w = csv.writer(open(file_name, \\\"w\\\"))\\n w.writerow(topList)\\n for key, val in data.items():\\n row = list(val)\\n row.insert(0,key)\\n w.writerow(row)\",\n \"def writeCSV(list, filename):\\n with open(filename, \\\"w\\\") as file:\\n for row in list:\\n for i in range(len(row)):\\n file.write(str(row[i]))\\n if i != len(row) - 1:\\n file.write(\\\",\\\")\\n else:\\n file.write(\\\"\\\\n\\\")\\n return\",\n \"def save_csv(filename, save_list):\\n with open(filename, mode='w') as csv:\\n csv.writelines([','.join(item) + '\\\\n' for item in save_list])\",\n \"def write_csv(row_list,out_name,*header_strings : str):\\n with open(out_name,'w',newline='') as result_file:\\n wr = csv.writer(result_file, delimiter='\\\\t')\\n if header_strings:\\n wr.writerow([name for name in header_strings])\\n if type(row_list[0]) is list:\\n wr.writerows(row_list)\\n else:\\n for row in row_list:\\n wr.writerow([row])\",\n \"def save_csv(outfile, cities):\\n writer = csv.writer(outfile)\\n writer.writerow(['Name'])\\n for row in cities:\\n writer.writerow([row])\",\n \"def export_corpus_csv(corpus,path, delimiter = ',', trans_delimiter = '.'):\\n word = corpus.random_word()\\n header = sorted(word.descriptors)\\n with open(path, encoding='utf-8', mode='w') as f:\\n print(delimiter.join(header), file=f)\\n for key in corpus.iter_sort():\\n print(delimiter.join(make_safe(getattr(key, value),trans_delimiter) for value in header), file=f)\",\n \"def writeItemsToCSV(self, fileName, itemList):\\n\\t\\twith open(fileName, 'w') as csvFile:\\n\\t\\t csvWriter = csv.writer(csvFile, delimiter=',')\\n\\t\\t # Column titles\\n\\t\\t csvWriter.writerow([\\\"Brandname\\\",\\\"Productname\\\",\\\"Colors\\\",\\\"Sizes\\\",\\\"Description\\\",\\\"Materials\\\",\\\"Maintenance\\\",\\\"RegularPrice\\\",\\\"CurrentPrice\\\"])\\n\\t\\t for item in itemList:\\n\\t\\t csvWriter.writerow(list(item))\",\n \"def save_csv(outputfile):\\n with open(outputfile, 'w', newline='') as outfile:\\n writer = csv.writer(outfile)\\n writer.writerow(DATA_KEYS)\\n\\n # Add data to csv-file\\n for data in data_list:\\n writer.writerow(data)\",\n \"def save_reviews_to_csv(language, review_list, dataset):\\n with open('reviews_'+dataset+'_'+language+'.csv', 'w') as csvfile:\\n fieldnames = review_list[0].__dict__.keys()\\n writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\\n\\n writer.writeheader()\\n for review in review_list:\\n writer.writerow(review.__dict__)\",\n \"def write_csv(csv_list, out_csv_path):\\n with open(out_csv_path, 'w', newline='') as csv_file:\\n csv_writer = csv.writer(csv_file)\\n for row in csv_list:\\n csv_writer.writerow(row)\",\n \"def generate_csv(type, json_list, columns_list):\\n with open(\\\"data/\\\" + type + \\\"_\\\" + time.strftime(\\\"%Y-%m-%d_%H:%M:%S\\\") +\\n \\\".csv\\\", 'a+') as f:\\n csv_file = csv.DictWriter(f, fieldnames=columns_list,\\n extrasaction=\\\"ignore\\\")\\n csv_file.writeheader()\\n for item in json_list:\\n csv_file.writerow(item)\\n print(\\\"\\\\nCSV file saved as data/\\\" + type + \\\"_\\\" +\\n time.strftime(\\\"%Y-%m-%d_%H:%M:%S\\\") + \\\".csv\\\")\",\n \"def write(self, args):\\n\\t\\tnewcsvfile = self.filename[:len(self.filename)-4] + \\\"NEW.csv\\\" #clever naming MIGHT NEED TO CHANGE THIS LATER/OVERWRITE OLD FILE?\\n\\t\\twith open(newcsvfile, 'wb') as f:\\n\\t\\t\\twriter = csv.writer(f)\\n\\t\\t\\twriter.writerows(self.all_likes)\",\n \"def tdl_to_csv(filename, list_of_strings, delim='\\\\t'):\\n header = list_of_strings[0].split(delim)\\n data = [ dict(zip(header, line.split(delim))) for line in list_of_strings[1:] ]\\n data = [OrderedDict(zip(header,header))] + data\\n o = csv.DictWriter(open(filename, 'w'), header)\\n o.writerows(data)\",\n \"def save(filename, data, keys):\\n with open(filename,'w') as fd:\\n csv_out = csv.writer(fd, delimiter=',', quotechar='\\\"')\\n csv_out.writerow(keys)\\n for row in zip( *[data[k] for k in keys] ):\\n csv_out.writerow(row)\",\n \"def List_to_CSV(OutFname, DataList):\\n with open(OutFname, 'w') as myfile:\\n wr = csv.writer(myfile, delimiter=',')\\n wr.writerows(line for line in DataList)\",\n \"def write_relevance_tocsv(relevance, corpus):\\n csv_filename = config.CORPUS[corpus]['relevance_file']\\n print('writing relevance')\\n print(relevance)\\n with open(csv_filename, 'w') as file:\\n csv.writer(file).writerows((k,) + v for k, v in relevance.items())\",\n \"def csv_writer(filepath, seqs):\\n with open(filepath, 'w') as f:\\n f.write('\\\\n'.join([','.join(\\n ['\\\"{}\\\"'.format(r) \\n if (' ' in r) or (',' in r) else r\\n for r in s])\\n for s in seqs]))\",\n \"def write_csv(file_names: list, csv_file_path: str):\\n with open(csv_file_path, mode='w') as csv_file:\\n writer = csv.writer(csv_file)\\n writer.writerows(enumerate(file_names))\",\n \"def outputFunc(filename, resultList):\\n #assert len(parks) == 3\\n \\n f = open(filename, 'wt')\\n \\n try:\\n writer = csv.writer(f)\\n for i in range(len(resultList)):\\n print resultList[0]\\n writer.writerow(resultList[i])\\n \\n finally:\\n f.close()\",\n \"def persist_list_to_csv(liste, nom_fichier):\\n with open(nom_fichier, 'w') as f:\\n for elem in liste :\\n f.write(\\\"{}\\\\n\\\".format(elem))\",\n \"def writeCSV():\\n final_list = get_final_list()\\n path_to_csv_File = 'system_metrics.csv'\\n\\n csv_file = open(path_to_csv_File, 'w+', newline='', encoding=\\\"utf8\\\")\\n csv_file_writer = csv.writer(csv_file, delimiter=',')\\n\\n csv_file_writer.writerow(['Subscription', 'Resource', 'MetricType',\\n 'Timestamp', 'Unit', 'Minimum', 'Maximum', 'Average'])\\n\\n for item in final_list:\\n csv_file_writer.writerow([item['subscription'], item['resource'], item['metricType'], item['timestamp'],\\n item['unit'], item['minimum'], item['maximum'], item['average']])\\n\\n print('Output written successfully!!')\",\n \"def csv_file_creator(path, list_of_jobs):\\n with open(path, \\\"wb\\\") as out_file:\\n writer = UnicodeWriter(out_file, delimiter=',')\\n for row in list_of_jobs:\\n writer.writerow(row)\",\n \"def write_output_file(ad_models):\\n\\n with open('output-data-utf8.csv', 'w', newline='', encoding='UTF-8') as output_file:\\n csv_writer = csv.writer(output_file, delimiter=',')\\n for ad in ad_models:\\n csv_writer.writerow((ad.date.strftime('%Y/%m/%d'), ad.country_code, ad.impression, ad.clicks))\",\n \"def outputFunc(filename, parks,roading,private):\\n #assert len(parks) == 3\\n \\n f = open(filename, 'wt')\\n \\n try:\\n writer = csv.writer(f)\\n writer.writerow(days)\\n writer.writerow(parks)\\n writer.writerow(roading)\\n writer.writerow(private)\\n finally:\\n f.close()\",\n \"def generate_csv(filename='', datafile='queryData.txt', keywords=mainKeywords):\\n\\n fulltitle = os.path.join(os.getcwd(), 'results', 'searchWoKResults', filename + 'MaterialsKeySearchFull.csv')\\n contitle = os.path.join(os.getcwd(), 'results', 'searchWoKResults', filename + 'MaterialsKeySearchCondensed.csv')\\n datatitle = os.path.join(os.getcwd(), 'results', 'searchWoKResults', filename + datafile)\\n\\n with open(fulltitle, 'wt') as csvFull, open(contitle, 'wt') as csvCon, open(datatitle, 'rt') as data:\\n fwriter = csv.writer(csvFull, delimiter=',', quotechar='\\\"', quoting=csv.QUOTE_MINIMAL)\\n cwriter = csv.writer(csvCon, delimiter=',', quotechar='\\\"', quoting=csv.QUOTE_MINIMAL)\\n querydata = json.load(data)\\n\\n conheader = ['Material', 'Publications', 'Crystal System', 'Space Group', 'Calculated Band Gap']\\n for n in keywords:\\n conheader.append(n)\\n cwriter.writerow(conheader)\\n\\n linenum = 0\\n\\n print('GETTING KEYWORD LIST:')\\n print('Searching for ' + str(keywords) + '\\\\n')\\n\\n for searchData in querydata:\\n print('Searching through ' + searchData[0]['material'] + ' data')\\n\\n keylist = searchWoKTools.getkeylist(searchData, keywords)\\n\\n print('Generating clouds')\\n wc = searchWoKTools.generateabstractwc(searchData)\\n imgpath = os.path.join(os.getcwd(), 'results', 'searchWoKResults', filename, searchData[0]['material'] + '.png')\\n wc.to_file(imgpath)\\n\\n print('Writing CSV')\\n fwriter.writerow([searchData[0]['material'],\\n str(searchData[0]['numResults']) + ' publications',\\n searchData[0]['crystalsystem'],\\n searchData[0]['spacegroup'] + ' spacegroup',\\n searchData[0]['bandgap'] + ' band gap',\\n searchData[0]['searchURL'],\\n '=HYPERLINK(\\\"' + imgpath + '\\\",\\\"Word Cloud\\\")'])\\n linenum += 1\\n\\n conline = [\\n '=HYPERLINK(\\\"[' + fulltitle + ']' + filename + 'MaterialsKeySearchFull' + '!A' + str(linenum) + '\\\",\\\"' +\\n searchData[0]['material'] + '\\\")',\\n\\n str(searchData[0]['numResults']),\\n searchData[0]['crystalsystem'],\\n searchData[0]['spacegroup'],\\n searchData[0]['bandgap']]\\n\\n fwriter.writerow([])\\n linenum += 1\\n\\n for key in keylist.keys():\\n keyrow = []\\n conkeynum = 0\\n for n in range(len(keylist[key])):\\n if keylist[key][n] != 0:\\n cellstring = '=HYPERLINK(\\\"' + searchData[1][n]['DOIlink'] + '\\\",\\\"' + key + '(' + str(\\n keylist[key][n]) + ')\\\")'\\n keyrow.append(cellstring)\\n conkeynum += 1\\n if keyrow:\\n fwriter.writerow(keyrow)\\n linenum += 1\\n if conkeynum != 0:\\n constring = '=HYPERLINK(\\\"[' + fulltitle + ']' + filename + 'MaterialsKeySearchFull' + '!A' + str(\\n linenum) + '\\\",\\\"' + str(conkeynum) + '\\\")'\\n conline.append(constring)\\n else:\\n conline.append('')\\n\\n cwriter.writerow(conline)\\n\\n fwriter.writerow([])\\n fwriter.writerow([])\\n linenum += 2\\n\\n return\",\n \"def write_csv(self, outfile, collapse_orders=False, show_age=False):\\r\\n # Write header row\\r\\n outfile.write(self.get_csv_header(collapse_orders, show_age).encode())\\r\\n\\r\\n # Write content\\r\\n for x in self.records:\\r\\n x.write_csv(outfile, collapse_orders, show_age)\",\n \"def write_csv(self, filelike):\\r\\n items = self.rows()\\r\\n writer = unicodecsv.writer(filelike, encoding=\\\"utf-8\\\")\\r\\n writer.writerow(self.header())\\r\\n for item in items:\\r\\n writer.writerow(item)\",\n \"def write_list(outputfilename, list):\\r\\n try:\\r\\n with open(outputfilename, 'w', newline='', encoding='utf-8') as outfile:\\r\\n itemwriter = csv.writer(outfile, delimiter=\\\",\\\")\\r\\n for item in list:\\r\\n itemwriter.writerow(item)\\r\\n except:\\r\\n input(\\\"File still open! Please close and press enter to continue\\\")\\r\\n with open(outputfilename, 'w', newline='', encoding='utf-8') as outfile:\\r\\n itemwriter = csv.writer(outfile, delimiter=\\\",\\\")\\r\\n for item in list:\\r\\n itemwriter.writerow(item)\",\n \"def write_to_csv(list_of_rows, file_name):\\n with open(file_name, 'w') as f:\\n writer = csv.writer(f)\\n for row in list_of_rows:\\n if None in row:\\n continue\\n writer.writerow(row)\\n \\n f.close()\",\n \"def save_to_csv(list_return, name, fieldnames):\\n os.makedirs(os.path.dirname(name + '.csv'), exist_ok=True)\\n with open(name + '.csv', 'w') as csvfile:\\n csvfile.write(','.join(map(str, field_names)))\\n csvfile.write('\\\\n')\\n write = csv.writer(csvfile, delimiter=',')\\n for x in range(0, len(list_return)):\\n write.writerow(list_return[x])\",\n \"def writeToMonthCsv(news_dict):\\n\\n for k in news_dict:\\n output_f = open(k + \\\".csv\\\", \\\"wb\\\")\\n writer = csv.writer(output_f)\\n writer.writerow([news_dict[k].replace(\\\",\\\", \\\"\\\").encode(\\\"utf-8\\\")])\\n output_f.close()\",\n \"def write_to_csv(self, data_points):\\n keys = data_points[0].keys()\\n with open(self.report_path, 'w') as output_file:\\n dict_writer = csv.DictWriter(output_file, keys)\\n dict_writer.writeheader()\\n dict_writer.writerows(data_points)\",\n \"def csv_writelist(file, oldfile, chlst, num):\\n import csv\\n writelist = checkdifferences(oldfile, chlst, num)\\n print('before', writelist)\\n with open('{}.csv'.format(file), 'w', newline='') as csvwrite:\\n writer = csv.writer(csvwrite, delimiter=';')\\n try:\\n for eachrow in writelist:\\n writer.writerow(eachrow)\\n except:\\n if TypeError:\\n print('Typeerror')\\n csvwrite.close()\",\n \"def write_file(self, filename):\\n\\n with open(filename, 'w', newline = '') as csvfile:\\n langwriter = csv.writer(csvfile, delimiter=' ',\\n quotechar='|', quoting=csv.QUOTE_MINIMAL)\\n for key in self.features:\\n value = self.features[key]\\n l = []\\n for val in value:\\n l.append(str(val))\\n langwriter.writerow([l])\\n return\",\n \"def writetoCSV(self, fileName):\\n\\n with open(fileName, 'w') as writeFile:\\n writeFile.write(\\\"ID,Fx,Fy,Fz\\\\n\\\")\\n for fstnr in F:\\n writeFile.write(str(fstnr.ID))\\n for i in fstnr.force:\\n writeFile.write(',' + str(i))\\n writeFile.write('\\\\n')\",\n \"def export(tako_list, filename):\\n for tak in tako_list:\\n tak = tak[0]\\n l1 = [tak.ident, \\\"a\\\"]\\n for gen in tak.genome.weightchr_a:\\n l1.append(gen.ident)\\n l1.append(gen.weight)\\n l1.append(gen.mut_rate)\\n l1.append(gen.dom)\\n f = os.path.join(\\\"Data\\\", (filename[:-4] + \\\" gene data.csv\\\"))\\n with open(f, 'a', newline=\\\"\\\") as csvfile:\\n writ = csv.writer(csvfile)\\n writ.writerow(l1)\\n if len(tak.genome.weightchr_b) != 0:\\n l2 = [tak.ident, \\\"b\\\"]\\n for gen in tak.genome.weightchr_b:\\n l2.append(gen.ident)\\n l2.append(gen.weight)\\n l2.append(gen.mut_rate)\\n l2.append(gen.dom) \\n writ.writerow(l2)\",\n \"def save_to_file_csv(cls, list_objs):\\n l = []\\n if list_objs is not None:\\n for item in list_objs:\\n l.append(item.to_dictionary())\\n with open(\\\"%s.csv\\\" % cls.__name__, mode='w') as f:\\n f.write(Base.to_json_string(l))\",\n \"def outputapidata_csv(filename, data, headers=None):\\n with open(filename,'w',encoding='utf-8',newline = \\\"\\\", ) as f:\\n if headers:\\n writer = csv.DictWriter(f,fieldnames = headers)\\n writer.writeheader()\\n else:\\n writer = csv.DictWriter(f)\\n writer.writerows(out)\",\n \"def write_csv_label(labels, csv_file):\\n with open(csv_file, 'w') as f:\\n writer = csv.writer(f)\\n for key, value in labels.items():\\n writer.writerow([key, value])\",\n \"def gp_file(data,filename,output_dir='',order = [],head = False):\\n f = open(output_dir + filename + '.csv', 'w')\\n f.write(str(len(order)-1) + '\\\\n')\\n write = csv.writer(f)\\n write.writerows(manip.dic_to_list(data,order,head),)\\n f.closed\\n\\n return None\",\n \"def create_csv(self):\\n try:\\n # Convert List of Lists to DataFrame and write it to a CSV\\n pd.DataFrame(self.data, columns=self.header) \\\\\\n .to_csv(os.path.join(self.file_path, self.file_name), index=False)\\n self.successful_run = True\\n except:\\n # TODO create Exception Handling\\n raise\",\n \"def csv_save_list(list_data, path, lineterminator='\\\\n', encoding=None):\\n with open(path, 'w') as f:\\n writer = csv.writer(f, lineterminator=lineterminator)\\n for item in list_data:\\n if encoding is not None:\\n writer.writerow([item.encode(encoding)])\\n else:\\n writer.writerow([item])\",\n \"def CSVWriter (iterable, outLoc, header=\\\"\\\", ):\\n if not iterable:\\n print (\\\"nothing to write\\\")\\n return 0\\n\\n out = open(outLoc, 'w')\\n\\n if header:\\n out.write(header+'\\\\n')\\n\\n #Only works if iterable is a nested list\\n for member in iterable:\\n for item in member:\\n out.write(str(item)+',')\\n out.write('\\\\n')\\n\\n print(\\\"write to \\\"+outLoc+\\\" successful.\\\")\\n return 1\",\n \"def write_into_csv(self, loc_details=[], itype='atm', mode='w'): \\n \\n if itype==\\\"brc\\\":\\n csvfile_name = self.branch_file\\n headers = self.branch_headers\\n else:\\n csvfile_name = self.atm_file\\n headers = self.atm_headers\\n\\n with open(csvfile_name, mode, newline='') as csvfile:\\n locwriter = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_ALL)\\n if mode=='w':\\n locwriter.writerow(headers) \\n\\n for loc in loc_details:\\n locwriter.writerow(loc)\",\n \"def _write_csv(self):\\n\\n # add the label to the header\\n if self.input_data.get_value(InputType.TIME_PERIOD) == 'all':\\n self.header.append('Date')\\n else:\\n self.header.append('sample id')\\n\\n key_list = []\\n\\n for i, cube in enumerate(self.cube_list):\\n if self.input_data.get_value(InputType.TIME_PERIOD) == 'all':\\n self._write_sample_with_date(cube, i, key_list)\\n else:\\n self._write_sample(cube, i, key_list)\\n\\n output_data_file_path = self._get_full_file_name()\\n self._write_data_dict(output_data_file_path, key_list)\\n\\n return [output_data_file_path]\",\n \"def save_double_list(list1, list2, filename):\\r\\n the_file = open(filename, \\\"wb\\\")\\r\\n try:\\r\\n writer = csv.writer(the_file)\\r\\n if len(list1)!=len(list2):\\r\\n raise Exception(\\\"Saving a double list : The list have not the same length !\\\")\\r\\n for i in range(len(list1)):\\r\\n writer.writerow( (list1[i], list2[i]) ) \\r\\n finally:\\r\\n the_file.close()\",\n \"def add_to_csv(file_name, single_list):\\n final_list = read_csv(file_name)\\n writer = csv.writer(open(file_name, 'wb'), delimiter=',',quoting=csv.QUOTE_MINIMAL)\\n final_list.append(single_list)\\n for x in final_list:\\n writer.writerow(x)\",\n \"def write_to_file(self, results):\\n with open(self.outputFilename, \\\"w\\\") as csvFile:\\n csvWriter = csv.writer(csvFile, delimiter=',') \\n title_row = ('asset_id', 'component_id', 'latitude', 'longitude', 'installation_date', 'commissioning_date', 'street_name', 'cabinet_id', 'nominal_wattage', 'current_time', 'current_LogValue', 'current_IsLogValueOff') \\n csvWriter.writerow(title_row)\\n for record in results:\\n csvWriter.writerow(record)\",\n \"def write_to_csv(self, verbose: bool = False) -> None: \\n Path(self.csv_dir).mkdir(exist_ok=True)\\n with open(f\\\"{self.csv_dir}/train.csv\\\", \\\"wt\\\", encoding=\\\"utf-8\\\", newline=\\\"\\\") as train_file:\\n with open(f\\\"{self.csv_dir}/test.csv\\\", \\\"wt\\\", encoding=\\\"utf-8\\\", newline=\\\"\\\") as test_file:\\n csv_header = (\\\"phone\\\", \\\"phone_class_index\\\", \\\"f1\\\", \\\"f2\\\", \\\"f3\\\", \\\"f4\\\", \\\"f5\\\")\\n train_csvwriter = csv.writer(train_file)\\n test_csvwriter = csv.writer(test_file)\\n train_csvwriter.writerow(csv_header)\\n test_csvwriter.writerow(csv_header)\\n for vowels_and_formants, wav_path, category in self:\\n if verbose:\\n print(f\\\"File: {wav_path} (category: {category})\\\")\\n writer = train_csvwriter if category == \\\"TRAIN\\\" else test_csvwriter\\n for vowel_and_formants in vowels_and_formants:\\n phone, formants = vowel_and_formants\\n row = (phone, ipa_class_index[phone]) + tuple(formants)\\n writer.writerow(row)\\n if verbose:\\n print(row)\",\n \"def writeToCsv(news_dict, f_name):\\n\\n f_data = open(f_name, \\\"wb\\\")\\n writer = csv.writer(f_data)\\n for k in news_dict:\\n writer.writerow([k, news_dict[k].replace(\\\",\\\", \\\"\\\")])\\n f_data.close()\",\n \"def generate_csv(self, output_file):\\n try: # We are going to \\\"try\\\" something\\n csv_file = open(output_file, 'w+') # open \\\"output_file\\\" as a writable file and return a handle called \\\"csv_file\\\"\\n except OSError as err: # If something goes wrong with the open, we catch the exception\\n fatal(\\\"{0}\\\".format(err), -1) # exit with something other than 0 so the shell knows something went wrong\\n \\n writer = csv.writer(csv_file) # create a CSV writing object that's pointing at our open file handle\\n\\n writer.writerow([\\\"Question\\\",\\\"Answers\\\"]) # Let's write the top row\\n for k in self.questions.keys(): # Let's walk down the directory by key\\n # write the \\\"key\\\" (which is the question) and then let's take the list of answers and create a comma delmited list.\\n # this is likely totally wrong since you could have an answer in it that also has a comma...\\n writer.writerow([k, \\\",\\\".join(self.questions[k].answers)]) # insert a key (which is the question) and then let's take the array of \\n\\n csv_file.close() # close the csv_file file handle\",\n \"def _export_csv(x, y, export_to):\\r\\n\\r\\n with open(export_to, 'w', newline='') as e:\\r\\n writer = csv.writer(e, delimiter=',')\\r\\n for i in range (0, len(x)):\\r\\n writer.writerow([x[i], y[i]])\",\n \"def write_csv(self, filename: str, author_data: list):\\n split_file = filename.split('/')\\n new_filename = \\\"\\\"\\n for index, component in enumerate(split_file):\\n if index == len(split_file) - 1:\\n break\\n new_filename += component + \\\"/\\\"\\n new_filename += \\\"results_\\\" + split_file[-1]\\n with open(new_filename, 'w') as csvfile:\\n result_writer = csv.writer(csvfile)\\n result_writer.writerow(self._csv_headings)\\n for author in author_data:\\n result_writer.writerow(self.author_data_to_str(author))\\n csvfile.close()\",\n \"def write_csv(error_list, user_list):\\n\\n with open('error_log.csv', 'w', newline='') as csv_file:\\n writer = csv.writer(csv_file)\\n writer.writerow(['ERROR', 'COUNT'])\\n for value in error_list:\\n writer.writerow(value)\\n\\n with open('user_statistics.csv', 'w', newline='') as csv_file:\\n fields = ['USER', 'ERROR', 'INFO']\\n writer = csv.DictWriter(csv_file, fields)\\n writer.writeheader()\\n for key, value in user_list:\\n row = {'USER': key}\\n row.update(value)\\n writer.writerow(row)\",\n \"def csvwrite(inlist, stringify=False):\\n out_list = []\\n for entry in inlist:\\n if stringify:\\n new_entry = []\\n for val in entry:\\n if not isinstance(val, basestring):\\n val = str(val)\\n new_entry.append(val)\\n entry = new_entry\\n this_line = ', '.join([elem_quote(val) for val in entry])\\n out_list.append(this_line)\\n return out_list\",\n \"def save_to_file_csv(cls, list_objs):\\n with open(cls.__name__ + \\\".csv\\\", \\\"w\\\", newline='') as f:\\n if cls.__name__ == \\\"Rectangle\\\":\\n fieldnames = ['id', 'width', 'height', 'x', 'y']\\n elif cls.__name__ == \\\"Square\\\":\\n fieldnames = ['id', 'size', 'x', 'y']\\n writer = csv.DictWriter(f, fieldnames=fieldnames)\\n writer.writeheader()\\n if list_objs is not None:\\n for model in list_objs:\\n writer.writerow(model.to_dictionary())\",\n \"def save_list_of_list(data, path, lineterminator='\\\\n', encoding=None):\\n with open(path, 'w') as f:\\n writer = csv.writer(f, lineterminator=lineterminator)\\n if encoding is not None:\\n data = [[item.encoding(encoding) for item in items]\\n for items in data]\\n writer.writerows(data)\",\n \"def to_csv(list_dicts, file_name):\\n # We assume that all the dictionaries have the same keys\\n fieldnames = list_dicts[0].keys()\\n\\n with open(file_name, 'w') as output_file:\\n dict_writer = csv.DictWriter(output_file, fieldnames)\\n dict_writer.writeheader()\\n dict_writer.writerows(list_dicts)\",\n \"def write_to_csv(agents, filename):\\n log.info(\\\"Writing CSV file '%s'...\\\" % filename)\\n with open(filename, 'w', newline='') as csvfile:\\n writer = csv.DictWriter(csvfile, fieldnames=place_detail_keys)\\n writer.writeheader()\\n writer.writerows(agents)\",\n \"def save_csv(filename, rows):\\n with open(filename, 'w', newline='', encoding='utf-8') as f:\\n writer = csv.writer(f)\\n writer.writerow([\\n 'title', 'runtime', 'genre(s)', 'director(s)', 'writer(s)',\\n 'actor(s)', 'rating(s)', 'number of rating(s)'\\n ])\\n\\n writer.writerows(rows)\",\n \"def writeCSV(filename, separator, data):\\n \\n filetowrite = open(filename, \\\"w\\\")\\n values = []\\n i = 0 #Count the number of objects already written\\n for item in data:\\n filetowrite.write(item)\\n i += 1\\n if i < len(data.keys()):\\n filetowrite.write(separator)\\n values.append(data[item])\\n filetowrite.write(\\\"\\\\n\\\")\\n i = 0\\n for value in values:\\n filetowrite.write(str(value))\\n i += 1\\n if i < len(values):\\n filetowrite.write(separator)\\n \\n filetowrite.close()\",\n \"def test_csv_writes(self):\\n counter = testdata.get_counter()\\n csvfile = testdata.create_csv({\\n \\\"foo\\\": counter,\\n \\\"bar\\\": testdata.get_words,\\n })\\n\\n for row in csvfile:\\n for k in [\\\"foo\\\", \\\"bar\\\"]:\\n self.assertTrue(k in row)\\n self.assertTrue(row[k])\",\n \"def write_csv(image_names, image_classes, filename):\\n with open(filename, 'w', newline='') as file:\\n writer = csv.writer(file)\\n writer.writerow(['filename', 'label'])\\n writer.writerows(zip(image_names, image_classes))\",\n \"def save_to_file_csv(cls, list_objs):\\n f_name = cls.__name__ + \\\".csv\\\"\\n with open(f_name, 'w', newline='') as f:\\n if list_objs is None or list_objs == []:\\n f.write(\\\"[]\\\")\\n\\n else:\\n if cls.__name__ == 'Rectangle':\\n h = ['id', 'width', 'height', 'x', 'y']\\n else:\\n h = ['id', 'size', 'x', 'y']\\n ncsv = csv.DictWriter(f, fieldnames=h)\\n for obj in list_objs:\\n ncsv.writerow(obj.to_dictionary())\",\n \"def __create_csv(self):\\n with open(self.__csv_file_name, 'w', newline='', encoding='utf-8') as csv_file:\\n writer = csv.DictWriter(csv_file, fieldnames=self.__csv_fields, delimiter=';')\\n writer.writeheader()\",\n \"def csv_writer(data, path):\\n\\twith open(path, \\\"wb\\\") as csv_file:\\n\\t\\twriter= csv.writer(csv_file, delimiter=',')\\n\\t\\twriter.writerows(data)\",\n \"def write(l, path, columns):\\n \\n file = open(path, 'w', newline = '', encoding = 'utf-8')\\n writer = csv.writer(file, delimiter = '\\\\t', quotechar = '', quoting = csv.QUOTE_NONE)\\n row = []\\n for col in columns:\\n row.append(col)\\n writer.writerow(row)\\n for entry in l:\\n row = []\\n for col in columns:\\n row.append(entry[col])\\n writer.writerow(row)\\n file.close()\",\n \"def write_CSV_data(fname, names, npts, nvar, append, data):\\n \\n if append > 0:\\n f = open(fname,'a')\\n else:\\n f = open(fname,'w')\\n for nm in names:\\n f.write(nm+',')\\n f.write('\\\\n')\\n for j in range(npts):\\n for n in range(nvar):\\n f.write('%10.4e, ' % data.value(j,n))\\n f.write('\\\\n')\\n f.close()\",\n \"def write_csv(outputfile, delimiter, newline, qchar, encoding, header, rows):\\n with open(outputfile, 'w', newline=newline, encoding=encoding) as csvfile:\\n writer = csv.writer(csvfile, delimiter=delimiter,\\n quotechar=qchar, quoting=csv.QUOTE_MINIMAL)\\n writer.writerow(header)\\n for row in rows:\\n writer.writerow(row)\",\n \"def write_to_csv(list_of_emails):\\n import csv\\n # use newline='' to prevent double-spaced rows\\n with open('emails.csv', 'w', newline='') as outFile:\\n outWriter = csv.writer(outFile)\\n charNum = outWriter.writerow(['email'])\\n for i in list_of_emails:\\n charNum = outWriter.writerow([i])\\n outFile.close()\",\n \"def save_csv(outfile, movies):\\n writer = csv.writer(outfile)\\n writer.writerow(['Title', 'Rating', 'Year', 'Actors', 'Runtime'])\\n for movie in movies:\\n writer.writerow(movie)\\n\\n # ADD SOME CODE OF YOURSELF HERE TO WRITE THE MOVIES TO DISK\",\n \"def output_to_file(utilist, filepath=\\\"demo.csv\\\"):\\n os.makedirs(os.path.dirname(filepath), exist_ok=True)\\n with open(filepath, \\\"a\\\") as f:\\n f.write(utilist + \\\"\\\\n\\\")\",\n \"def to_csv(header, rows):\\r\\n with open('result.csv', 'w') as result:\\r\\n result_writer = csv.writer(result, delimiter=';')\\r\\n result_writer.writerow(header)\\r\\n result_writer.writerows(rows)\",\n \"def csv_writer(file_path, data):\\n with open(file_path, \\\"a+\\\") as f:\\n #writer = csv.writer(f, delimiter=',')\\n writer = csv.writer(f, lineterminator='\\\\n')\\n writer.writerows(data)\\n f.close()\",\n \"def writecsvfile(filename, columnnames, data):\\n with open(filename, 'w', newline='') as csv_file:\\n writer = csv.writer(csv_file, delimiter=',')\\n writer.writerow(columnnames) # header row\\n for row in data:\\n writer.writerow(row[:])\",\n \"def save_csv(outfile, movies):\\n fieldnames = ['title', 'rating', 'year', 'actors', 'runtime']\\n with open('movies.csv', 'w') as outfile:\\n writer = csv.DictWriter(outfile, fieldnames=fieldnames)\\n writer.writeheader()\\n for line in movies:\\n writer.writerow(line)\\n\\n\\n # ADD SOME CODE OF YOURSELF HERE TO WRITE THE MOVIES TO DISK\",\n \"def generate_csv(table, header):\\n with open(\\\"%s.csv\\\" % header, \\\"w\\\") as csvfile:\\n for i in range(len(table)):\\n for j in range(len(table[i])):\\n if j != len(table[i])-1:\\n tmp = table[i][j] + \\\",\\\"\\n else:\\n tmp = table[i][j] + \\\"\\\\n\\\"\\n csvfile.write(tmp)\",\n \"def exportFoldFile(vectors, authors, fileName):\\n with open(fileName, \\\"w\\\") as fFile:\\n for idv, vec in enumerate(vectors):\\n [fFile.write(str(val)+',') for val in vec]\\n fFile.write(authors[idv] + '\\\\n')\",\n \"def store_csv(self):\\n\\n with open(self.filepath.with_suffix(\\\".csv\\\"), 'w',\\n newline='') as csvfile:\\n fieldnames = ['counter', 'timestamp', 'acceleration']\\n writer = DictWriter(csvfile, fieldnames=fieldnames)\\n\\n writer.writeheader()\\n writer.writerows(self.values)\",\n \"def column_output(self, output_fname, list_2d):\\n\\t\\toutf = open(output_fname, 'w')\\n\\t\\twriter = csv.writer(outf, delimiter='\\\\t')\\n\\t\\tfor list in list_2d:\\n\\t\\t\\twriter.writerow(list)\\n\\t\\tdel writer\\n\\t\\toutf.close()\",\n \"def WriteToCSV(datalist):\\n\\n\\tglobal csv_success\\n\\t# Define header\\n\\theader = ['time', 'accx', 'accy', 'accz', 'gx', 'gy', 'gz', 'mx', 'my', 'mz']\\n\\n\\t# Define our filename\\n#\\tts = time.time()\\n\\ttimestamp = time.strftime(\\\"%Y%m%d_\\\")\\n\\n\\tfilename = str(timestamp+ \\\"log.csv\\\")\\n\\n\\t# Handling to open our file if it exists or create new one\\n\\tif exists(filename):\\n\\t\\t# try: \\n\\t\\tf = csv.writer(open(filename,\\\"a\\\"),lineterminator='\\\\n')\\n\\t\\t\\t# break\\n\\t\\t# except:\\n\\telse:\\n\\t\\tf = csv.writer(open(filename,\\\"a+\\\"),lineterminator='\\\\n')\\n\\t\\t# Write our header line out if this is a new file\\n\\t\\tf.writerow(header)\\n\\t\\t\\n\\n\\n\\t\\n\\tf.writerow([ datalist['time'], datalist['acc'][0],datalist['acc'][1],datalist['acc'][2],datalist['gyro'][0],datalist['gyro'][1],datalist['gyro'][2],datalist['mag'][0],datalist['mag'][1],datalist['mag'][2] ])\\n\\t\\n\\t\\n\\tcsv_success = True\\n\\treturn csv_success\",\n \"def make_csv(file_of_data):\\n with open(file_of_data, 'w') as f:\\n writer = csv.writer(f)\\n header = (\\\"Counter\\\", \\\"Date/time\\\", \\\"Latitude\\\", \\\"Longitude\\\", \\\"Temperature\\\", \\\"Humidity\\\")\\n writer.writerow(header)\",\n \"def save_to_file_csv(cls, list_objs):\\n list_dictionaries = []\\n if list_objs is None or list_objs == []:\\n string_dictionary = \\\"[]\\\"\\n else:\\n for _obj_dict in list_objs:\\n list_dictionaries.append(_obj_dict.to_dictionary())\\n string_dictionary = Base.to_json_string(list_dictionaries)\\n with open(cls.__name__ + \\\".csv\\\", \\\"w\\\") as _file:\\n _file.write(string_dictionary)\\n _file.close()\",\n \"def write_results(results):\\n with RESULTS_PATH.open(\\\"w\\\") as writer:\\n csvwriter = csv.writer(writer)\\n csvwriter.writerows(results)\",\n \"def write_csv(elongation, file_name):\\n e = elongation\\n\\n with open(file_name, 'w') as f:\\n f.write(f\\\"\\\"\\\"\\\\\\nBreak Load, {e.break_load()}\\nBreak Strength, {e.break_strength()}\\nBreak Elongation, {e.break_elongation()}\\nYield Load, {e.yield_load()}\\nYield Strength, {e.yield_strength()}\\nYield Elongation, {e.yield_elongation()}\\nGauge Length, {e.gauge_length}\\nSample Width, {e.sample_width}\\nSample Thickness, {e.sample_thickness}\\n\\nPoints\\n %, N\\\"\\\"\\\")\\n for x, y in zip(e.xs, e.ys):\\n f.write(f'\\\\n{x:>8.4f}, {y:>8.4f}')\",\n \"def outTxt(data, outPath, fileName):\\n\\n with open(outPath+fileName, \\\"wb\\\") as f:\\n f.write(\\\"index,link,name,rating,review,price,category,neighborhood,address,phone,feedback\\\\n\\\")\\n for record in data:\\n f.write(\\\"%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s\\\\n\\\" % \\\\\\n (record[0],record[1],record[2],record[3],record[4],record[5],record[6],\\\\\\n record[7],record[8],record[9],record[10]))\",\n \"def __create_output_csv(self, df, score_list, elapsed_list):\\n df['Similar']=score_list\\n df['Elapsed']=elapsed_list\\n df.to_csv('Output.csv',index=False)\\n return df\",\n \"def write(lst):\\n # TODO\",\n \"def save_csv_file(votes: dict) -> None:\\r\\n with open(\\\"votingList.csv\\\", \\\"w\\\", newline=\\\"\\\") as csvfile:\\r\\n writer = csv.writer(csvfile)\\r\\n writer.writerow([\\\"First Name\\\", \\\"Last Name\\\", \\\"Vote\\\"])\\r\\n for vote in votes.keys():\\r\\n entry = votes[vote]\\r\\n fst, snd = vote.split()\\r\\n writer.writerow([fst, snd, entry])\",\n \"def write_csv(estimates: ListOfDicts, output_csv: str) -> None:\\n with open(output_csv, \\\"w\\\") as f:\\n writer = csv.DictWriter(f, fieldnames=estimates[0].keys())\\n writer.writeheader()\\n for row in estimates:\\n writer.writerow(row)\\n logging.info(f\\\"Wrote estimates as {output_csv}\\\")\",\n \"def write_csv(data):\\n\\n with open('data.csv', 'w') as file:\\n writer = csv.DictWriter(file, fieldnames=data[0].keys())\\n writer.writeheader()\\n for row in data:\\n writer.writerow(row)\",\n \"def create_csv_submission(ids, y_pred, name):\\n with open(name, 'w') as csvfile:\\n fieldnames = ['Id', 'Prediction']\\n writer = csv.DictWriter(csvfile, delimiter=\\\",\\\", fieldnames=fieldnames)\\n writer.writeheader()\\n for r1, r2 in zip(ids, y_pred):\\n writer.writerow({'Id':r1,'Prediction':round(r2)})\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7690983","0.7156317","0.70057595","0.699873","0.69436884","0.6937405","0.68834347","0.6880354","0.6851179","0.6808864","0.6744166","0.6703595","0.6695695","0.6665467","0.66601634","0.66530514","0.6650442","0.66289073","0.66165644","0.6579203","0.6561281","0.65514296","0.6549551","0.65430886","0.6529098","0.64969635","0.64810455","0.64790416","0.64682955","0.64658505","0.6455045","0.64440084","0.643926","0.64283395","0.64189655","0.6415715","0.64144015","0.6410667","0.64051896","0.6389428","0.63850933","0.63798654","0.63796455","0.63693315","0.633865","0.63323367","0.6330359","0.63181984","0.631159","0.63069874","0.6278467","0.6278411","0.6274695","0.62543607","0.6251943","0.6240057","0.6236478","0.62359583","0.6235956","0.62273216","0.6220908","0.6207746","0.62030095","0.6197256","0.61956304","0.6192436","0.6187564","0.6182528","0.6179462","0.61790466","0.61758196","0.6173121","0.61631775","0.61613905","0.6155686","0.6145079","0.6141037","0.6140751","0.61342067","0.6134198","0.61325234","0.61284596","0.6124273","0.61177754","0.6109992","0.6102544","0.60952085","0.6091573","0.6090022","0.60888743","0.6086576","0.6075574","0.6070402","0.6066408","0.6064904","0.60633075","0.60545224","0.60536593","0.60499984","0.60467386"],"string":"[\n \"0.7690983\",\n \"0.7156317\",\n \"0.70057595\",\n \"0.699873\",\n \"0.69436884\",\n \"0.6937405\",\n \"0.68834347\",\n \"0.6880354\",\n \"0.6851179\",\n \"0.6808864\",\n \"0.6744166\",\n \"0.6703595\",\n \"0.6695695\",\n \"0.6665467\",\n \"0.66601634\",\n \"0.66530514\",\n \"0.6650442\",\n \"0.66289073\",\n \"0.66165644\",\n \"0.6579203\",\n \"0.6561281\",\n \"0.65514296\",\n \"0.6549551\",\n \"0.65430886\",\n \"0.6529098\",\n \"0.64969635\",\n \"0.64810455\",\n \"0.64790416\",\n \"0.64682955\",\n \"0.64658505\",\n \"0.6455045\",\n \"0.64440084\",\n \"0.643926\",\n \"0.64283395\",\n \"0.64189655\",\n \"0.6415715\",\n \"0.64144015\",\n \"0.6410667\",\n \"0.64051896\",\n \"0.6389428\",\n \"0.63850933\",\n \"0.63798654\",\n \"0.63796455\",\n \"0.63693315\",\n \"0.633865\",\n \"0.63323367\",\n \"0.6330359\",\n \"0.63181984\",\n \"0.631159\",\n \"0.63069874\",\n \"0.6278467\",\n \"0.6278411\",\n \"0.6274695\",\n \"0.62543607\",\n \"0.6251943\",\n \"0.6240057\",\n \"0.6236478\",\n \"0.62359583\",\n \"0.6235956\",\n \"0.62273216\",\n \"0.6220908\",\n \"0.6207746\",\n \"0.62030095\",\n \"0.6197256\",\n \"0.61956304\",\n \"0.6192436\",\n \"0.6187564\",\n \"0.6182528\",\n \"0.6179462\",\n \"0.61790466\",\n \"0.61758196\",\n \"0.6173121\",\n \"0.61631775\",\n \"0.61613905\",\n \"0.6155686\",\n \"0.6145079\",\n \"0.6141037\",\n \"0.6140751\",\n \"0.61342067\",\n \"0.6134198\",\n \"0.61325234\",\n \"0.61284596\",\n \"0.6124273\",\n \"0.61177754\",\n \"0.6109992\",\n \"0.6102544\",\n \"0.60952085\",\n \"0.6091573\",\n \"0.6090022\",\n \"0.60888743\",\n \"0.6086576\",\n \"0.6075574\",\n \"0.6070402\",\n \"0.6066408\",\n \"0.6064904\",\n \"0.60633075\",\n \"0.60545224\",\n \"0.60536593\",\n \"0.60499984\",\n \"0.60467386\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6339406"},"document_rank":{"kind":"string","value":"44"}}},{"rowIdx":93198,"cells":{"query":{"kind":"string","value":"Generate a bunch of input JSON files from a template and a bunch of elevation files"},"document":{"kind":"string","value":"def generate_input_files(elevation_folder_path, template_input_file_path):\n import pathlib\n json_dict = get_inputs_from_file(template_input_file_path)\n\n path_to_match = pathlib.Path(elevation_folder_path)\n\n for heightfile in path_to_match.glob(\"*.npy\"):\n dot_index = str(heightfile).rfind('.')\n filename_base = str(heightfile)[:dot_index]\n opt_output_filename = filename_base + \".out\"\n opt_input_filename = filename_base + \".json\"\n\n localdict = json_dict.copy()\n\n localdict[\"output_file\"] = opt_output_filename\n localdict[\"elevation_file\"] = str(heightfile)\n\n dump_json_dict(out_dict=localdict, filename=opt_input_filename)"},"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_main():\n for template in templates:\n main([\"-g\", template])\n\n # One at a time\n for xyz_file in example_xyz_files:\n main([template, xyz_file])\n\n # All at once\n main([template] + list(example_xyz_files))\n\n # Allow use of template in the parent directory\n with cd(\"data\"):\n main([\"../pnictogen/repo/ADF.in\", \"water-dimer.xyz\"])","def extract_json_to_files(input_dir,output_dir):\n files={}\n files['train']='train-v1.1.json'\n files['dev']='dev-v1.1.json'\n\n for file in files:\n filename=os.path.join(input_dir,files[file])\n with open(filename,'r',encoding='utf-8') as data_file:\n examples = []\n dataset=json.load(data_file)\n count_total=total_exs(dataset)\n count_mapping_problem=0\n count_token_problem=0\n count_ansspan_problem=0\n count_examples=0\n for article_id in tqdm(range(len(dataset['data'])), desc=\"Preprocessing {}\".format(file)):\n article_paragraph=dataset['data'][article_id]['paragraphs']\n for paragraph_id in range(len(article_paragraph)):\n context=article_paragraph[paragraph_id]['context']\n context=context.replace(\"''\",'\"').replace(\"``\",'\"')\n context = context.replace('\\u3000', ' ').replace('\\u202f',' ').replace('\\u2009', ' ')#.replace(\"'\",\"'\")\n context=context.replace('\\-',' ')\n context_tokens=tokenize_sequence(context)\n context=context.lower()\n qas=article_paragraph[paragraph_id]['qas']\n charloc2wordloc=get_char_word_loc_mapping(context, context_tokens)\n if charloc2wordloc is None:\n count_mapping_problem+=len(qas)\n continue\n for qa in qas:\n question=qa['question'].lower()\n question_tokens=tokenize_sequence(question)\n\n ans_text=qa['answers'][0]['text'].lower()\n ans_text=ans_text.replace('\\u3000', ' ').replace('\\u202f', ' ').replace('\\u2009', ' ')\n ans_start_loc=qa['answers'][0]['answer_start']\n if qa['id'] in ['5706baed2eaba6190074aca5','57269c73708984140094cbb5','57269c73708984140094cbb7','572a11661d04691400779721','572a11661d04691400779722','572a11661d04691400779723','572a11661d04691400779724','572a11661d04691400779725','572a2cfc1d0469140077981b','572a3a453f37b319004787e9','572a84d3f75d5e190021fb3c']:\n ans_start_loc+=1\n if qa['id'] in ['572a5df77a1753140016aedf','572a5df77a1753140016aee0','572a84d3f75d5e190021fb38','572a84d3f75d5e190021fb39','572a84d3f75d5e190021fb3a','572a84d3f75d5e190021fb3b','572a85df111d821400f38bad','572a85df111d821400f38bae','572a85df111d821400f38baf','572a85df111d821400f38bb0']:\n ans_start_loc+=2\n if qa['id'] in ['572a5df77a1753140016aee1','572a5df77a1753140016aee2']:\n ans_start_loc+=3\n if qa['id'] in ['57286bf84b864d19001649d6','57286bf84b864d19001649d5']:\n ans_start_loc-=1\n if qa['id'] in ['5726bee5f1498d1400e8e9f3','5726bee5f1498d1400e8e9f4']:\n ans_start_loc-=2\n ans_end_loc=ans_start_loc+len(ans_text)\n\n if context[ans_start_loc:ans_end_loc]!=ans_text:\n count_ansspan_problem+=1\n continue\n ans_start_wordloc = charloc2wordloc[ans_start_loc][1] # answer start word loc\n ans_end_wordloc = charloc2wordloc[ans_end_loc-1][1] # answer end word loc\n assert ans_start_wordloc <= ans_end_wordloc\n\n ans_tokens = context_tokens[ans_start_wordloc:ans_end_wordloc + 1]\n if \"\".join(ans_tokens) != \"\".join(ans_text.split()):\n count_token_problem += 1\n #print(ans_text)\n #print(ans_tokens)\n continue # skip this question/answer pair\n examples.append((' '.join(context_tokens),' '.join(question_tokens),' '.join(ans_tokens),' '.join([str(ans_start_wordloc),str(ans_end_wordloc)])))\n print(\"Number of (context, question, answer) triples discarded due to char -> token mapping problems: \", count_mapping_problem)\n print(\"Number of (context, question, answer) triples discarded because character-based answer span is unaligned with tokenization: \",count_token_problem)\n print(\"Number of (context, question, answer) triples discarded due character span alignment problems (usually Unicode problems): \",count_ansspan_problem)\n print(\"Processed %i examples of total %i\\n\" % (len(examples), len(examples)+count_mapping_problem+count_token_problem+count_ansspan_problem))\n indices = list(range(len(examples)))\n np.random.shuffle(indices)\n with open(os.path.join(output_dir,file+'.context'),'w',encoding='utf-8') as context_file, \\\n open(os.path.join(output_dir,file+'.question'),'w',encoding='utf-8') as question_file, \\\n open(os.path.join(output_dir,file+'.answer'),'w',encoding='utf-8') as answer_file, \\\n open(os.path.join(output_dir,file+'.span'),'w',encoding='utf-8') as span_file:\n for i in indices:\n (context,question,answer,span)=examples[i]\n context_file.write(context+'\\n')\n question_file.write(question+'\\n')\n answer_file.write(answer+'\\n')\n span_file.write(span+'\\n')","def main():\n for db_csv_export in current_dir.glob(\"template*.csv\"):\n data_projects = load_projects(db_csv_export)\n json_path = db_csv_export.with_suffix(\".json\")\n with open(json_path, \"w\") as fh:\n json.dump(data_projects, fh, indent=2)","def main(gtfs_file, input_json_file):\n\n with open(input_json_file) as jsonfile:\n input_json = json.load(jsonfile)\n\n gtfs_feed = mzgtfs.feed.Feed(filename=gtfs_file)\n\n for fare_id, rules_attributes in input_json.iteritems():\n add_fare_id(gtfs_feed, fare_id, rules_attributes)\n\n files = ['fare_attributes.txt', 'fare_rules.txt']\n gtfs_feed.write('fare_attributes.txt', gtfs_feed.fares())\n gtfs_feed.write('fare_rules.txt', gtfs_feed.fare_rules())\n\n gtfs_feed.make_zip('output.zip', files=files, clone=gtfs_file)\n shutil.move('output.zip', gtfs_file)\n\n util.delete_temp_files(files)","def run(self):\n if not os.path.exists(self.output_folder):\n os.makedirs(self.output_folder)\n for entry in glob.glob(os.path.join(self.data_folder, self.data_expression)):\n f = open(entry)\n text = json.loads(f.read())\n f.close()\n self.create_page_objects(text)","def get_templates(instrument=''):\n import os, json\n template_path = os.path.dirname(__file__)\n template_names = [fn\n for fn in os.listdir(template_path)\n if fn.endswith(\".json\") and fn.startswith(instrument)]\n templates = dict([(tn[len(instrument)+1:-5],\n json.loads(open(os.path.join(template_path, tn), 'r').read()))\n for tn in template_names])\n return templates","def preprocess_template(template_file: str) -> None:\n LOGGER.info(\"Processing template %s\", template_file)\n\n with DFReader(open(template_file, \"rb\")) as reader:\n level = reader.read_level()\n\n doors = {}\n keys_needed: Dict[int, int] = collections.Counter()\n for eid, (_, _, entity) in level.entities.items():\n if not isinstance(entity, LevelDoor):\n continue\n\n doors[eid] = {\n \"level\": entity.file_name.decode(),\n \"door\": entity.door_set,\n }\n keys_needed[DOOR_INFO[entity.door_set][1]] += 1\n\n for door_data in doors.values():\n key_type = DOOR_INFO[door_data[\"door\"]][1]\n while key_type < 3 and keys_needed[key_type + 1] == 0:\n key_type += 1\n door_data[\"key_get\"] = key_type\n\n with open(template_file + \".json\", \"w\") as fout:\n json.dump(\n {\"doors\": doors},\n fout,\n )","def main(filename):\n with open(filename) as json_file:\n data = json.load(json_file)\n\n course_dict = {}\n course_dict['course_id'] = str(os.path.split(filename.strip('/'))[-1])\n course_dict['blocks'] = build_course_map(data)\n\n filename = '%s' % course_dict['course_id']\n filepath = os.path.join('../input/', filename)\n\n with open(filepath, 'w') as outfile:\n json.dump(course_dict, outfile, indent=4)","def regenerate_json_file():\n \n # filepaths used in generating json data...\n dir_export = f\"C:\\\\Users\\\\{os.getlogin()}\\\\Downloads\"\n list_name = 'my-favourite-films.csv'\n json_output_filename = 'reviews_web_data.json'\n path_to_rootreducer = f'D:\\\\Programming-Projects\\\\nathansteele\\\\src\\\\reducers\\\\RootReducer.js';\n path_to_json_output = f'D:\\\\Programming-Projects\\\\nathansteele\\\\src\\\\components\\\\films\\\\{json_output_filename}'\n \n # 1) find letterboxd zip export...\n prefix = 'letterboxd'\n postfix = 'utc.zip'\n zip_file_name = \"\"\n download_folder = sorted(glob.glob(f\"{dir_export}/*.zip\"), key=os.path.getmtime)\n download_folder.reverse() # reversing the list means most recent downloads are first in the list...\n for filepath in download_folder:\n filename = filepath.split('\\\\')[-1]\n if filename.split('-')[0] == prefix and filename.split('-')[-1] == postfix:\n zip_file_name = filename\n print(f\"Found the zip export! -> {zip_file_name}\")\n break\n else:\n continue\n\n path_to_zip_file = f\"{dir_export}\\\\{zip_file_name}\" # path to zip file we downlodaded from letterboxd...\n path_to_extracted_zip = f\"{dir_export}\\\\{zip_file_name[:-4]}\" # path to extracted zip (which we are about to do)...\n\n # 2) extract zip automatically (if not done already)...\n if os.path.exists(path=path_to_zip_file):\n if not os.path.exists(path=path_to_extracted_zip):\n with zipfile.ZipFile(file=path_to_zip_file , mode='r') as z:\n z.extractall(path_to_extracted_zip)\n print(f\"Extract complete! -> {path_to_extracted_zip}\")\n else:\n print(f'Zip file already exists... No need to extract again... -> ({path_to_extracted_zip})')\n else:\n print(f'Zip file could not be found... -> ({path_to_zip_file})')\n\n\n # local version of letterboxd data list\n letterboxd_list = []\n \n # 3) locate the csv file of interest\n if os.path.exists(path_to_extracted_zip): \n # open csv file...\n path_to_list = f'{path_to_extracted_zip}\\\\lists\\\\{list_name}'\n with open(path_to_list, 'r') as f:\n # csv reader object\n csv_reader = csv.reader(f)\n \n # skip header in the csv file...\n rows_to_skip = 5\n for i in range(0, rows_to_skip):\n next(csv_reader)\n \n # 4) iterate over each row (i.e. each film) in csv file...\n for csv_row in csv_reader:\n pos = csv_row[0]\n title = csv_row[1]\n year = csv_row[2]\n letterboxd_url = csv_row[3]\n letterboxd_film_id = letterboxd_url.split('/')[-1]\n genres = []\n directors = []\n duration = 0\n language = \"\"\n imdb_url = \"\"\n imdb_avg_rating = \"\"\n imdb_num_votes = \"\"\n tmdb_url = \"\"\n poster_url = \"\"\n \n # parse data from letterboxd web page... (this takes ~1.21s)\n page = session.get(url=letterboxd_url, verify=False, stream=True)\n soup = BeautifulSoup(page.content, 'html.parser')\n \n # retrieve list of genres...\n div_genres = soup.select_one('#tab-genres')\n for link in div_genres.select('div.text-sluglist a.text-slug[href]'):\n if 'genre' in link['href']:\n genre = link.text.capitalize()\n if genre == 'Science-fiction':\n genre = 'Sci-fi'\n genres.append(genre)\n\n # retrieve duration\n textfooter = soup.select_one('section.col-main > p.text-footer').text\n if 'mins' in textfooter:\n minstext = textfooter.find('mins', 0, len(textfooter))\n duration = textfooter[minstext-5:minstext].strip()\n \n # retrieve the first spoken language\n div_details = soup.select_one('#tab-details')\n for link in div_details.select('div.text-sluglist a.text-slug[href]'):\n if 'language' in link['href']:\n language = link.text.capitalize()\n break\n \n # retrieve IMDB url\n footer = soup.select_one('section.col-main p.text-footer')\n url_buttons = footer.select('a.micro-button')\n for url in url_buttons:\n if 'imdb' in url.text.lower():\n # get IMDB URL\n imdb_url = url['href']\n elif 'tmdb' in url.text.lower():\n # get TMDB URL\n tmdb_url = url['href']\n if len(url_buttons) == 1:\n # if there's only 1 url_button, it's usually the IMDB link that's missing...\n if soup.select_one('#featured-film-header > h1').text == 'xxxHOLiC':\n imdb_url = 'https://www.imdb.com/title/tt16233104/'\n\n # retrieve avg rating on letterboxd\n # page_content_str = page.content.decode('utf-8')\n # letterboxd_avg_rating = soup.select_one('.average-rating')\n\n # Use the OMDB API (https://www.omdbapi.com/) to retrieve some additional data from IMDB website...\n omdb_api_key = '4af56bed' # apparently this expires after 1000 days (today is 07/02/2023, 1000 days from now is 03/11/2025... holy shit!)\n imdb_film_id = imdb_url.split('/')[-2]\n url = f'http://www.omdbapi.com/?i={imdb_film_id}&apikey={omdb_api_key}'\n imdb = requests.get(url=url, verify=False)\n imdb_json = json.loads(imdb.text)\n\n # retrieve avg IMD rating\n imdb_avg_rating = imdb_json['imdbRating']\n \n # retrieve number of votes on IMDB (we remove the comma, because react is fucking stupid and cant sort numbers when they contain commas)\n imdb_num_votes = imdb_json['imdbVotes'].replace(',', '')\n \n # retrieve poster from IMDB\n poster_url = imdb_json['Poster']\n if 'SX300' in poster_url:\n poster_url = poster_url.split('SX300')[0]\n \n # retrieve title from IMDB (because letterboxd parsing is shite!)\n # title = imdb_json['Title']\n \n # retrieve list of directors (because letterboxd parsing is shite!)\n directors = imdb_json['Director'].split(', ')\n \n # id of my review!\n titlev2 = Helpers.simplify_movie_title(title=title)\n review_id = f\"{titlev2}-{letterboxd_film_id}-review\"\n \n \"\"\"\n # iterate over \\\\img\\\\films\\\\\n screenshots = []\n directory_in_str = f'D:\\\\Programming-Projects\\\\nathansteele\\\\src\\\\img\\\\films';\n for subdir, dirs, files in os.walk(directory_in_str):\n for file in files:\n # find the right directory...\n title_from_directory_storing_screenshots = subdir.split('\\\\')[-1]\n titlev3 = Helpers.simplify_movie_title(title=title_from_directory_storing_screenshots)\n if titlev3 == titlev2:\n # get my screenshots...\n if 'screenshot' in file:\n screenshot = os.path.join(subdir, file)\n screenshots.append(screenshot)\n \n # use my custom poster if I put one there...\n if 'custom_poster' in file:\n poster_url = os.path.join(subdir, file)\n \"\"\"\n \n # DEBUGGING....\n print(f\" > {pos}: {title}\")\n #print(f' > Title = ({title})')\n #print(f' > IMDB url = ({imdb_url})')\n #print(f' > Language = ({language})')\n #print(f' > Duration = ({duration})')\n #print(f' > Genres = ({genres})')\n #print(f' > IMDB avg rating = ({imdb_avg_rating})')\n #print(f' > IMDB num votes = ({imdb_num_votes})')\n #print(f' > Poster = ({poster_url})')\n #print(f' > Directors = ({directors})')\n #print(f' > Tags = ({my_tags})')\n \n # append to list...\n letterboxd_list.append({\n 'letterboxdFilmId': letterboxd_film_id,\n 'imdbFilmId': imdb_film_id,\n 'letterboxdUrl': letterboxd_url,\n 'imdbUrl': imdb_url,\n 'posterUrl': poster_url,\n 'position': pos,\n 'title': title,\n 'year': year,\n 'duration': duration,\n 'language': language,\n 'imdbAvgRating': imdb_avg_rating,\n 'imdbNumVotes': imdb_num_votes,\n 'tmdbUrl': tmdb_url,\n 'directors': directors,\n 'genres': genres,\n 'reviewId': review_id\n })\n \n # clear json file first...\n open(path_to_json_output, 'w').close()\n \n # write new content...\n with open(path_to_json_output, 'w') as f:\n json.dump(letterboxd_list, f, indent=4)\n \n print(f'JSON export finished! -> {path_to_json_output}')","def get_template_files(fs, template_type):\n # no template fitting for null runs\n if fs[\"null_run\"]:\n template_type = None\n\n if \"template_type\" in fs:\n if template_type == fs[\"template_type\"]:\n return\n\n fs[\"template_type\"] = template_type\n\n # find all corresponding foreground templates\n if template_type is None:\n fs[\"template_root\"] = None\n fs[\"template_root2\"] = None\n fs[\"template_files\"] = None\n fs[\"template_files2\"] = None\n fs[\"template_noise_root\"] = None\n fs[\"template_noise_root2\"] = None\n fs[\"template_noise_files\"] = None\n fs[\"template_noise_files2\"] = None\n fs[\"num_template\"] = 0\n fs[\"num_template_noise\"] = 0\n else:\n num_template_noise = None\n for hm in [\"1\", \"2\"]:\n suff = \"\" if hm == \"1\" else \"2\"\n troot = os.path.join(\n fs[\"data_root\"],\n \"templates_{}\".format(template_type),\n \"halfmission-{}\".format(hm),\n )\n ### this block is so sims with template type like\n # 353_100_gauss_003 can use ensemble in 353_100_gauss\n tp = template_type.split(\"_\")\n ttype = template_type\n if tp[-1].isdigit():\n if ttype[-7:] not in [\"353_100\", \"217_100\"]:\n ttype = \"_\".join(tp[:-1])\n\n tnroot = os.path.join(\n fs[\"data_root\"],\n \"templates_noise_{}\".format(ttype),\n \"halfmission-{}\".format(hm),\n )\n\n tfiles = []\n tnfiles = []\n for f in fs[\"map_files\"]:\n nfile = f.replace(fs[\"map_root\"], troot)\n if not os.path.exists(nfile):\n raise OSError(\"Missing hm-{} template for {}\".format(hm, f))\n tfiles.append(nfile)\n nfiles = sorted(\n glob.glob(\n f.replace(fs[\"map_root\"], tnroot).replace(\n \".fits\", \"_*.fits\"\n )\n )\n )\n if not len(nfiles):\n raise OSError(\n \"Missing hm-{} template noise for {}\".format(hm, f)\n )\n tnfiles.append(nfiles)\n if num_template_noise is not None:\n if len(nfiles) != num_template_noise:\n raise OSError(\n \"Wrong number of template noise sims. \"\n \"Found {} files, expected {}.\".format(\n len(nfiles), num_template_noise\n )\n )\n\n num_template_noise = len(nfiles)\n\n tfiles = np.asarray(tfiles)\n tnfiles = np.asarray(tnfiles)\n fs[\"template_root{}\".format(suff)] = troot\n fs[\"template_files{}\".format(suff)] = tfiles\n fs[\"template_noise_root{}\".format(suff)] = tnroot\n fs[\"template_noise_files{}\".format(suff)] = tnfiles\n\n fs[\"num_template\"] = len(fs[\"template_files\"])\n fs[\"num_template_noise\"] = num_template_noise\n self.log(\n \"Found {} templates in {}\".format(\n fs[\"num_template\"], fs[\"template_root\"]\n ),\n \"info\",\n )\n self.log(\n \"Found {} template noise files in {}\".format(\n fs[\"num_template_noise\"], fs[\"template_noise_root\"]\n ),\n \"info\",\n )\n self.log(\"Template files: {}\".format(fs[\"template_files\"]), \"debug\")\n\n fields = [\n \"template_type\",\n \"template_root\",\n \"template_root2\",\n \"template_files\",\n \"template_files2\",\n \"template_noise_root\",\n \"template_noise_root2\",\n \"template_noise_files\",\n \"template_noise_files2\",\n \"num_template\",\n \"num_template_noise\",\n ]\n for k in fields:\n setattr(self, k, fs[k])","def create_dicts():\n load_data_for_dict('data/atis/train/seq.in', 'data/atis/voc/vocabulary.json')\n load_data_for_dict('data/atis/valid/seq.in', 'data/atis/voc/vocabulary.json')\n load_data_for_dict('data/atis/test/seq.in', 'data/atis/voc/vocabulary.json') \n load_data_for_dict('data/atis/train/seq.out', 'data/atis/voc/slot_vocabulary.json')","def get_files(template_path, resource_type, skip_customer_resources=False):\n try:\n json_files = []\n for file_path in find_files(template_path, '*.json'):\n folder_list = list(file_path.split(\"/\"))\n if not ('/customer/' in file_path.lower() and skip_customer_resources):\n folder_name = list(folder_list[-1].split('.'))\n file_name = folder_name[-2]\n if resource_type in ['template', 'script', 'policy']:\n if '_ignore' not in file_path and not file_name.startswith('Blueprint_'):\n if folder_list[-2] == file_name:\n json_files.append(file_path)\n else:\n if file_name.startswith('Blueprint_'):\n folder_name = \"Blueprint_%s\" % folder_list[-2]\n if folder_name == file_name:\n json_files.append(file_path)\n else:\n json_file = open(file_path, 'r')\n content = json.dumps(json_file.read()).encode('utf-8')\n json_file.close()\n content = json.loads(content)\n blueprint_details = json.loads(content)\n bp_name = \"Blueprint_%s\" % blueprint_details.get('name')\n if bp_name == file_name:\n json_files.append(file_path)\n return json_files\n except Exception as e:\n sys.stderr.write(e.message)\n exit(1)","def manufacturing_manifest_json(self):\n\n file_name = os.path.join(self.cur_8digit_dir, \"manufacturing.manifest.json\")\n\n with open(file_name) as f_in:\n man_manifest = json.load(f_in)\n\n for component in man_manifest[\"ComponentManufactureList\"]:\n # Get ManufacturingModel (if exists)\n if \"ManufacturingModel\" in component:\n rel_path_from_results = os.path.join(self.cur_8digit_dir, component[\"ManufacturingModel\"])\n if os.path.exists(rel_path_from_results):\n self.files_for_export.append(os.path.join('results', rel_path_from_results))\n\n # Get STEPModel (if exists)\n if \"STEPModel\" in component:\n rel_path_from_results = os.path.join(self.cur_8digit_dir, component[\"STEPModel\"])\n if os.path.exists(rel_path_from_results):\n self.files_for_export.append(os.path.join('results', rel_path_from_results))\n\n # Since this is a PrepareForIFAB folder, gather all *.stp files in ./AP203_E2_SEPERATE_PART_FILES/\n path_to_stp_files = os.path.join(self.cur_8digit_dir,'AP203_E2_SEPERATE_PART_FILES')\n filter_for_stp_files = os.path.join(path_to_stp_files,'*.stp')\n stp_files = glob(filter_for_stp_files)\n for stp_file in stp_files:\n self.files_for_export.append(os.path.join('results',stp_file))\n\n # If there's a TDP tag, \n # add the referred file,\n\t# then crawl that file and gather its file references\n if \"TDP\" in man_manifest:\n tdp_json_path = os.path.join(self.cur_8digit_dir,man_manifest[\"TDP\"])\n self.tdp_json(tdp_json_path)\n self.files_for_export.append(os.path.join('results', tdp_json_path))","def build():\n for root, dirs, files in os.walk(IN_PATH):\n for filename in files:\n if filename.endswith('.csv'):\n with open(os.path.join(IN_PATH, filename), encoding='utf-8') as f:\n reader = csv.reader(f)\n next(reader)\n data = nested_dict()\n web_data = nested_dict()\n for row in reader:\n if row[0].startswith('report.') or row[0].startswith('cardset.'):\n d = data\n elif row[0].startswith('web.'):\n d = web_data\n path = row[0].split('.')\n for i in range(len(path)):\n if i == len(path) - 1:\n d[path[i]] = row[1]\n else:\n d = d[path[i]]\n with open (os.path.join(OUT_PATH, filename.replace('.csv', '.json')), 'w', encoding='utf-8') as fout:\n json.dump({**data, **web_data}, fout)\n with open (os.path.join(WEB_PATH, filename.replace('.csv', '.js')), 'w', encoding='utf-8') as fout:\n fout.write('var STRINGS = {};'.format(json.dumps(web_data)))\n\n with open(os.path.join(IN_PATH, 'en_US.csv'), encoding='utf-8') as f:\n reader = csv.reader(f)\n next(reader)\n data = nested_dict()\n web_data = nested_dict()\n for row in reader:\n path = row[0].split('.')\n if row[0].startswith('report.') or row[0].startswith('cardset.'):\n d = data\n elif row[0].startswith('web.'):\n d = web_data\n\n for i in range(len(path)):\n if i == len(path) - 1:\n d[path[i]] = zz_string(row[1], row[0])\n else:\n d = d[path[i]]\n with open(os.path.join(OUT_PATH, 'zz_ZZ.json'), 'w', encoding='utf-8') as fout:\n json.dump({**data, **web_data}, fout)\n with open(os.path.join(WEB_PATH, 'zz_ZZ.js'), 'w', encoding='utf-8') as fout:\n fout.write('var STRINGS = {};'.format(json.dumps(web_data)))","def load_templates(fwhm=400, line_complexes=True, stars=False,\n full_line_list=None, continuum_list=None,\n fsps_templates=False, alf_template=False):\n \n if stars:\n # templates = glob.glob('%s/templates/Pickles_stars/ext/*dat' %(os.getenv('GRIZLI')))\n # templates = []\n # for t in 'obafgkmrw':\n # templates.extend( glob.glob('%s/templates/Pickles_stars/ext/uk%s*dat' %(os.getenv('THREEDHST'), t)))\n # templates.extend(glob.glob('%s/templates/SPEX/spex-prism-M*txt' %(os.getenv('THREEDHST'))))\n # templates.extend(glob.glob('%s/templates/SPEX/spex-prism-[LT]*txt' %(os.getenv('THREEDHST'))))\n # \n # #templates = glob.glob('/Users/brammer/Downloads/templates/spex*txt')\n # templates = glob.glob('bpgs/*ascii')\n # info = catIO.Table('bpgs/bpgs.info')\n # type = np.array([t[:2] for t in info['type']])\n # templates = []\n # for t in 'OBAFGKM':\n # test = type == '-%s' %(t)\n # so = np.argsort(info['type'][test])\n # templates.extend(info['file'][test][so])\n # \n # temp_list = OrderedDict()\n # for temp in templates:\n # #data = np.loadtxt('bpgs/'+temp, unpack=True)\n # data = np.loadtxt(temp, unpack=True)\n # #data[0] *= 1.e4 # spex\n # scl = np.interp(5500., data[0], data[1])\n # name = os.path.basename(temp)\n # #ix = info['file'] == temp\n # #name='%5s %s' %(info['type'][ix][0][1:], temp.split('.as')[0])\n # print(name)\n # temp_list[name] = utils.SpectrumTemplate(wave=data[0],\n # flux=data[1]/scl)\n \n # np.save('stars_bpgs.npy', [temp_list])\n \n \n # tall = np.load(os.path.join(os.getenv('GRIZLI'), \n # 'templates/stars.npy'))[0]\n # \n # return tall\n # \n # temp_list = OrderedDict()\n # for k in tall:\n # if k.startswith('uk'):\n # temp_list[k] = tall[k]\n # \n # return temp_list\n # \n # for t in 'MLT':\n # for k in tall:\n # if k.startswith('spex-prism-'+t):\n # temp_list[k] = tall[k]\n # \n # return temp_list\n \n #return temp_list\n templates = ['M6.5.txt', 'M8.0.txt', 'L1.0.txt', 'L3.5.txt', 'L6.0.txt', 'T2.0.txt', 'T6.0.txt', 'T7.5.txt']\n templates = ['stars/'+t for t in templates]\n else:\n ## Intermediate and very old\n # templates = ['templates/EAZY_v1.0_lines/eazy_v1.0_sed3_nolines.dat', \n # 'templates/cvd12_t11_solar_Chabrier.extend.skip10.dat'] \n templates = ['eazy_intermediate.dat', \n 'cvd12_t11_solar_Chabrier.dat']\n \n ## Post starburst\n #templates.append('templates/UltraVISTA/eazy_v1.1_sed9.dat')\n templates.append('post_starburst.dat')\n \n ## Very blue continuum\n #templates.append('templates/YoungSB/erb2010_continuum.dat')\n templates.append('erb2010_continuum.dat')\n \n ### Test new templates\n # templates = ['templates/erb2010_continuum.dat',\n # 'templates/fsps/tweak_fsps_temp_kc13_12_006.dat',\n # 'templates/fsps/tweak_fsps_temp_kc13_12_008.dat']\n \n if fsps_templates:\n #templates = ['templates/fsps/tweak_fsps_temp_kc13_12_0{0:02d}.dat'.format(i+1) for i in range(12)]\n templates = ['fsps/fsps_QSF_12_v3_nolines_0{0:02d}.dat'.format(i+1) for i in range(12)]\n #templates = ['fsps/fsps_QSF_7_v3_nolines_0{0:02d}.dat'.format(i+1) for i in range(7)]\n \n \n if alf_template:\n templates.append('alf_SSP.dat')\n \n if continuum_list is not None:\n templates = continuum_list\n \n temp_list = OrderedDict()\n for temp in templates:\n data = np.loadtxt(os.path.join(os.getenv('GRIZLI'), 'templates', temp), unpack=True)\n #scl = np.interp(5500., data[0], data[1])\n scl = 1.\n name = temp #os.path.basename(temp)\n temp_list[name] = SpectrumTemplate(wave=data[0], flux=data[1]/scl,\n name=name)\n \n temp_list[name].name = name\n \n if stars:\n return temp_list\n \n ### Emission lines:\n line_wavelengths, line_ratios = get_line_wavelengths()\n \n if line_complexes:\n #line_list = ['Ha+SII', 'OIII+Hb+Ha', 'OII']\n #line_list = ['Ha+SII', 'OIII+Hb', 'OII']\n line_list = ['Ha+NII+SII+SIII+He', 'OIII+Hb', 'OII+Ne', 'Lya+CIV']\n else:\n if full_line_list is None:\n line_list = DEFAULT_LINE_LIST\n else:\n line_list = full_line_list\n \n #line_list = ['Ha', 'SII']\n \n # Use FSPS grid for lines\n wave_grid = None\n # if fsps_templates:\n # wave_grid = data[0]\n # else:\n # wave_grid = None \n \n for li in line_list:\n scl = line_ratios[li]/np.sum(line_ratios[li])\n for i in range(len(scl)):\n line_i = SpectrumTemplate(wave=wave_grid, \n central_wave=line_wavelengths[li][i], \n flux=None, fwhm=fwhm, velocity=True)\n \n if i == 0:\n line_temp = line_i*scl[i]\n else:\n line_temp = line_temp + line_i*scl[i]\n \n name = 'line {0}'.format(li)\n line_temp.name = name\n temp_list[name] = line_temp\n \n return temp_list","def main(args=None):\n if args is None:\n parser = create_parser()\n args = parser.parse_args()\n\n if args.debug:\n logging.basicConfig(level=logging.DEBUG)\n else:\n logging.basicConfig(level=logging.INFO)\n\n input_module = input_mapping[args.input_reader]\n output_module = output_mapping[args.output_format]\n\n templates = []\n # Load templates from external folder if set.\n if args.template_folder:\n templates += read_templates(os.path.abspath(args.template_folder))\n\n # Load internal templates, if not disabled.\n if not args.exclude_built_in_templates:\n templates += read_templates()\n output = []\n for f in args.input_files:\n res = extract_data(f.name, templates=templates, input_module=input_module)\n if res:\n logger.info(res)\n output.append(res)\n if args.copy:\n filename = args.filename.format(\n date=res['date'].strftime('%Y-%m-%d'),\n invoice_number=res['invoice_number'],\n desc=res['desc'],\n )\n shutil.copyfile(f.name, join(args.copy, filename))\n if args.move:\n filename = args.filename.format(\n date=res['date'].strftime('%Y-%m-%d'),\n invoice_number=res['invoice_number'],\n desc=res['desc'],\n )\n shutil.move(f.name, join(args.move, filename))\n f.close()\n\n if output_module is not None:\n output_module.write_to_file(output, args.output_name, args.output_date_format)","def test_format_map():\n template_filelist = listdir(RTEMPLATE_PATH)\n\n R_files = []\n json_files = []\n for file in template_filelist:\n if '.r' in file:\n file = file.replace('.r', '')\n R_files.append(file)\n elif '.json' in file:\n file = file.replace('.json', '')\n json_files.append(file)\n\n\n for template in R_files:\n template_filepath = path.join(RTEMPLATE_PATH, template + '.r')\n metadata_filepath = path.join(RTEMPLATE_PATH, template + '.json')\n\n with open(template_filepath, 'r') as t_fp:\n r_text = t_fp.read()\n\n try:\n with open(metadata_filepath, 'r') as m_fp:\n metadata = json.load(m_fp)\n except Exception as err:\n print(metadata_filepath)\n raise err\n\n format_dict = {}\n for key in metadata['required_args']:\n format_dict[key] = 'TEST'\n\n ## Actual test: apply `format_map` to r_text#\n try:\n r_text = r_text.format_map(format_dict)\n except Exception as err:\n print(template_filepath)\n raise err","def parse(root_path, output_path, batch_file_paths):\n for file_path in batch_file_paths:\n d, f = split_path(file_path, root_path)\n print(time.ctime(), \"d =\", d, \"; f =\", f)\n if not os.path.exists(os.path.join(OUTPUT_PATH, d)):\n os.makedirs(os.path.join(OUTPUT_PATH, d))\n parsed_files = get_parsed_files(output_path, d)\n if f not in parsed_files:\n with open(file_path) as json_file:\n OUTPUT_FILE_PATH = os.path.join(OUTPUT_PATH, d, f)\n with open(OUTPUT_FILE_PATH, 'w') as writer:\n for num, line in enumerate(json_file):\n json_data = json.loads(line)\n title = json_data['title']\n if json_data['text']:\n definition = json_data['text'][0]['line']\n writer.write(f'{title}\\t{definition}\\n')\n else:\n writer.write(f'{title}\\tNone.\\n')","def main(json_input, output_folder):\n with open(json_input, 'r') as f:\n data = json.loads(f.read())['data']\n\n with open(path.join(output_folder, 'qgeneration.context.txt'), 'w') as context_f, \\\n open(path.join(output_folder, 'qgeneration.context.nojson.txt'), 'w') as context_f_nojson, \\\n open(path.join(output_folder, 'qgeneration.gold.txt'), 'w') as question_f:\n for item in data:\n context_f.write(json.dumps(item['context']) + '\\n')\n context_f_nojson.write(item['context'][:1000] + '\\n')\n question_f.write(json.dumps(item['answer']) + '\\n')\n\n print('DONE')","def generate_files(self, output_dir: str) -> None:\n full_filename = os.path.join(output_dir, self.json_file)\n with open(full_filename, 'w', encoding='utf-8') as output_file:\n json.dump(self.zidb, output_file, indent=2)\n print(file=output_file) # add terminating newline\n logging.info(\"Created %s\", full_filename)","def create_dicts(self):\n \n # remove this string from filename to make output file names more manageable\n pre_output1 = self.file1.replace(\"_Guys121919_CGH_1100_Jul11\", '')\n pre_output2 = self.file2.replace(\"_Guys121919_CGH_1100_Jul11\", '')\n \n # Build the output file name.\n # if prefix is present add it\n if self.out_file_prefix is not None:\n # concatenate prefix, filenames and dyes into output filename file1_file1_dye_file2_file2_dye.txt\n self.outputfilename = self.out_file_prefix+pre_output1.replace(\".txt\", '') + \"_\" + self.file1_dye + \"_\" + pre_output2.replace(\".txt\", '') + \"_\" + self.file2_dye + \".txt\"\n # if no prefix don't add it!\n else:\n # concatenate filenames and dyes into output filename file1_file1_dye_file2_file2_dye.txt\n self.outputfilename = pre_output1.replace(\".txt\", '') + \"_\" + self.file1_dye + \"_\" + pre_output2.replace(\".txt\", '') + \"_\" + self.file2_dye + \".txt\"\n\n # add temp to end of file name to create a temporary output filename\n self.tempoutputfilename = self.outputfilename.replace(\".txt\", '') + \"temp.txt\"\n\n # open temp output file\n self.tempoutputfile = open(self.outputfolder + self.tempoutputfilename, 'w')\n\n \n # open FE files\n file1_open = open(self.chosenfolder + self.file1, 'r')\n file2_open = open(self.chosenfolder + self.file2, 'r')\n\n # open file1 and create a dict of the features.\n for linenumber, line in enumerate(file1_open):\n if linenumber >= 10:\n splitline = line.split('\\t')\n self.file1_dict[int(splitline[1])] = line\n # get n of rows in file1 (take the linenumber of the last line)\n self.file1_len = linenumber\n\n # repeat for features in second file but first writing the feparam and stats to temp file - when pairing with control this ensures the \"header\" comes from the test (file2) not control (file1), NB NEITHER ARE ACCURATE!!!!\n for linenumber, line in enumerate(file2_open):\n if linenumber < 10:\n self.tempoutputfile.write(line)\n # then add all features to a dictionary, with the unique feature number as a key\n if linenumber >= 10:\n splitline = line.split('\\t')\n self.file2_dict[int(splitline[1])] = line\n # get n of rows in file2\n self.file2_len = linenumber\n\n # close files\n file1_open.close()\n file2_open.close()","def test_pnictogen():\n for template in templates:\n template_prefix, extension = os.path.splitext(template)\n for xyz_file in example_xyz_files:\n input_prefix, xyz_file_extension = os.path.splitext(xyz_file)\n\n mol = Atoms(\n cclib.bridge.cclib2openbabel.readfile(xyz_file, xyz_file_extension[1:])\n )\n written_files = pnictogen(mol, input_prefix, template, extension[1:])\n\n assert_equals(type(written_files), list)\n for written_file in written_files:\n assert_equals(type(written_file), str)\n\n written_files2 = pnictogen(mol, input_prefix, template)\n assert_equals(written_files, written_files2)\n\n # Allow use of template in the parent directory\n with cd(\"pnictogen/repo\"):\n mol = Atoms(\n cclib.bridge.cclib2openbabel.readfile(\"../../data/water-dimer.xyz\", \"xyz\")\n )\n written_files = pnictogen(mol, \"../../data/water-dimer\", \"ADF.in\", \"in\")\n\n assert_equals(written_files, [\"../../data/water-dimer.in\"])\n\n main([\"-g\", \"/tmp/hello.world.ORCA.inp\"])\n mol = Atoms(cclib.bridge.cclib2openbabel.readfile(\"data/co.xyz\", \"xyz\"))\n written_files = pnictogen(mol, \"data/co\", \"/tmp/hello.world.ORCA.inp\", foo=\"bar\")\n\n assert_equals(written_files, [\"data/co.inp\"])","def _make_files(self):\n if not self.path.is_dir():\n raise FileNotFoundError(f\"Path {self.path} does not exist.\")\n\n # Make the filepaths\n self.file_points = self.path / \"point.dat\"\n self.file_lines = self.path / \"line.dat\"\n self.file_cadastre = self.path / \"cadastre.dat\"\n self.file_portals = self.path / \"portals.dat\"\n\n with open(self.file_points, \"w\") as f:\n # 2 lines ignored\n header = datetime.datetime.now().strftime(\"Generated: %d/%m/%Y %H:%M\\n\")\n f.write(header)\n self.points_dfs = []\n with open(self.file_lines, \"w\") as f:\n # 5 lines ignored\n header = (\n datetime.datetime.now().strftime(\"Generated: %d/%m/%Y %H:%M\\n\")\n + 3 * \"Generated: \\n\"\n + \"Name,Section,source_group,x1,y1,z1,x2,y2,z2,width,vert. ext.,-,-,\"\n \"emission_rate[kg/h/km],-,-,-,-\\n\"\n )\n f.write(header)\n with open(self.file_cadastre, \"w\") as f:\n # 1 line ignored\n header = \"x,y,z,dx,dy,dz,emission_rate[kg/h],-,-,-,source_group\\n\"\n f.write(header)\n with open(self.file_portals, \"w\") as f:\n # 2 lines ignored\n header = (\n datetime.datetime.now().strftime(\"Generated: %d/%m/%Y %H:%M\\n\")\n + \"x1,y1,x2,y2,z0,z1,emission_rate[kg/h],-,-,-,source_group\\n\"\n )\n f.write(header)\n\n\n # File to save the source groups values\n self.file_source_groups = self.path / \"source_groups.json\"\n with open(self.file_source_groups, \"w\") as f:\n # reverse the dict (items become keys and vice versa)\n reversed_source_groups = {v: k for k, v in self.source_groups.items()}\n json.dump(reversed_source_groups, f, indent=2)","def create_template(api_url, project_id, username, token, update_flag,\n validation_messages, json_files, content_files, scope, csv_flag, input_list):\n try:\n # template loader log folder exists check\n log_path = '/opt/core/cache/tmp/templateloader_logs/'\n if not os.path.exists(log_path):\n os.makedirs(log_path)\n timestamp = datetime.datetime.fromtimestamp(\n time.time()).strftime('%Y%m%d%H%M%S')\n log_filename = 'templateloader_' + timestamp\n my_file = open(log_path + log_filename, \"a\")\n\n # Print and write the log messages\n for message in validation_messages:\n my_file.write(\"%s\\n\" % message)\n\n success_templates = 0\n\n for metadata, content in zip(json_files, content_files):\n # Metadata Read\n json_file = open(metadata, 'r')\n file_name = list(metadata.split(\"/\"))\n file_name = file_name[-1]\n req_body = json.dumps(json_file.read()).encode('utf-8')\n req_body = json.loads(req_body)\n json_file.close()\n\n req_body = json.loads(req_body)\n\n if csv_flag:\n if input_list and req_body.get(\"name\") not in input_list:\n continue\n # Content Read\n if os.path.isfile(content):\n content_datafile = open(content, 'r')\n content_value = json.dumps(content_datafile.read()).encode('utf-8')\n content_value = json.loads(content_value)\n content_datafile.close()\n req_body[\"content_files\"] = dict(content=dict(content=content_value, name=content.split('/')[-1]))\n else:\n req_body[\"content_files\"] = get_content_files(content)\n # Checks for files\n files_directory = os.path.abspath(\n os.path.join(content, os.pardir)) + \"/files\"\n if os.path.exists(files_directory):\n dependencies = list()\n for script_file_path in find_files(files_directory, '*'):\n script_file_name = os.path.basename(script_file_path)\n script_file_obj = open(script_file_path, 'r')\n script_file_value = script_file_obj.read()\n script_file_obj.close()\n dependencies.append({\"content\": script_file_value, \"name\": script_file_name})\n req_body[\"content_files\"][\"files\"] = dependencies\n\n dependencies_directory = os.path.abspath(os.path.join(content, 'modules'))\n if os.path.exists(dependencies_directory):\n dependencies = list()\n for elem in os.listdir(dependencies_directory):\n module_path = os.path.join(dependencies_directory, elem)\n if not os.path.isdir(module_path):\n continue\n dependencies.append({\"type\": \"module\", \"name\": elem,\n \"content_files\": get_content_files(module_path)})\n if dependencies:\n req_body['dependencies'] = dependencies\n if scope != 'default':\n req_body['scope'] = scope\n\n req_body = json.dumps(req_body).encode('utf-8')\n\n url = \"%s%s/%s\" % (api_url, project_id, 'templates')\n http_client = httplib2.Http()\n headers = {\"X-Auth-User\": username, \"X-Auth-Token\": token}\n\n # call the Create Template API\n resp, content = http_client.request(\n url, method=\"POST\", body=req_body, headers=headers)\n content = json.loads(content)\n\n if resp[\"status\"] == \"200\":\n success_templates += 1\n log_msg = \"%s%s%s - %s\" % (file_name[:-5], \" ==> status:\",\n content[\"status\"],\n content[\"message\"])\n sys.stdout.write(\"%s\\n\" % log_msg)\n elif resp[\"status\"] == \"400\" and update_flag:\n template_id = None\n url = \"%s%s/%s\" % (api_url, project_id, 'templates')\n list_resp, list_content = http_client.request(\n url, method=\"GET\", headers=headers)\n list_content = json.loads(list_content)\n if list_resp[\"status\"] == \"200\":\n template_list = list_content['data']['templates']\n for template in template_list:\n if template['name'] == json.loads(req_body)['name']:\n # call the Update Template API\n template_id = template[\"id\"]\n url = \"%s%s/%s/%s\" % (api_url, project_id,\n 'templates', template_id)\n update_resp, update_content = \\\n http_client.request(url, method=\"PUT\",\n body=req_body,\n headers=headers)\n update_content = json.loads(update_content)\n log_msg = \"%s%s%s - %s\" % (\n file_name[:-5], \" ==> status:\",\n update_content[\"status\"],\n update_content[\"message\"])\n sys.stdout.write(\"%s\\n\" % log_msg)\n if update_resp[\"status\"] == \"200\":\n success_templates += 1\n break\n if not template_id:\n temp_url = \"%s%s/%s?is_temp=true\" % (api_url, project_id, 'templates')\n list_temp_resp, list_temp_content = http_client.request(\n temp_url, method=\"GET\", headers=headers)\n list_temp_content = json.loads(list_temp_content)\n if list_temp_resp[\"status\"] == \"200\":\n temp_template_list = list_temp_content['data']['templates']\n for template in temp_template_list:\n if template['name'] == json.loads(req_body)['name']:\n # call the Update Template API\n template_id = template[\"id\"]\n url = \"%s%s/%s/%s\" % (api_url, project_id,\n 'templates', template_id)\n update_resp, update_content = \\\n http_client.request(url, method=\"PUT\",\n body=req_body,\n headers=headers)\n update_content = json.loads(update_content)\n log_msg = \"%s%s%s - %s\" % (\n file_name[:-5], \" ==> status:\",\n update_content[\"status\"],\n update_content[\"message\"])\n sys.stdout.write(\"%s\\n\" % log_msg)\n if update_resp[\"status\"] == \"200\":\n success_templates += 1\n break\n if not template_id:\n log_msg = \"%s%s%s - %s\" % (file_name[:-5], \" ==> status:\",\n content[\"status\"],\n content[\"message\"])\n sys.stderr.write(\"%s\\n\" % log_msg)\n my_file.write(\"%s\\n\" % log_msg)\n else:\n log_msg = \"%s%s%s - %s\" % (file_name[:-5], \" ==> status:\",\n content[\"status\"],\n content[\"message\"])\n sys.stderr.write(\"%s\\n\" % log_msg)\n my_file.write(\"%s\\n\" % log_msg)\n if not csv_flag:\n total_templates = len(json_files)\n failed_templates = total_templates - success_templates\n else:\n total_templates = len(input_list)\n failed_templates = total_templates - success_templates\n sys.stdout.write('Total templates: ' + str(total_templates) + \"\\n\")\n sys.stdout.write(\"Success Templates: \" + str(success_templates) + \"\\n\")\n sys.stderr.write(\"Failed Templates: \" + str(failed_templates) + \"\\n\")\n\n my_file.write('Total templates: ' + str(total_templates) + \"\\n\")\n my_file.write(\"Failed Templates: \" + str(failed_templates) + \"\\n\")\n my_file.close()\n\n except Exception as e:\n sys.stdout.write(e.message)\n exit(1)","def main(arguments):\n\n # The input file can be optionally encoded with gzip format:\n input_file = arguments.input_file[0]\n assert isinstance(input_file, str)\n if input_file.endswith(\".gz\"):\n _open = gzip.open\n else:\n _open = open\n with _open(input_file, \"rt\",\n encoding='utf-8') as fd:\n print(\"Loading JSON content into memory....\")\n raw = json.load(fd) # Parses all the input file.\n\n # Also the output file can be optionally encoded with gzip format:\n output_file = arguments.output_file[0]\n assert isinstance(output_file, str)\n uuid = 0\n if output_file.endswith(\".gz\"):\n _open = gzip.open\n else:\n _open = open\n with _open(output_file, \"wt\",\n encoding='utf-8') as fd:\n # for each element extracted from the input\n print(\"Generating distilled file\")\n for item in load_input(raw):\n uuid += 1 # generates incremental uuid from 1\n item['uuid'] = uuid\n fd.write(json.dumps(item,\n sort_keys=True))\n fd.write(\"\\n\") # one encoded document per line\n\n print(\"{} documents imported\".format(uuid))","def fix_jsons_in(bids_dir: Path):\n\n print(\"Finalizing task json files.\")\n\n for path in bids_dir.rglob(\"func/*_task-*.json\"):\n append_to_json_file(key=\"TaskName\", value=task_name_of(path), path_to_json=path)\n\n print(\"Appending echo times to phase difference json files.\")\n\n for path in bids_dir.rglob(\"fmap/*_phasediff.json\"):\n magnitude1_path = the_path_that_matches(pattern=\"sub-*_magnitude1.json\", in_directory=path.parent)\n magnitude2_path = the_path_that_matches(pattern=\"sub-*_magnitude2.json\", in_directory=path.parent)\n echo_time1 = value_of_key_in_json_file(\"EchoTime\", magnitude1_path)\n echo_time2 = value_of_key_in_json_file(\"EchoTime\", magnitude2_path)\n append_to_json_file(key=\"EchoTime1\", value=echo_time1, path_to_json=path)\n append_to_json_file(key=\"EchoTime2\", value=echo_time2, path_to_json=path)\n\n print(\"Setting targets of fieldmap json files.\")\n\n for path in bids_dir.rglob(\"fmap/*.json\"):\n func_dir = path.parent.parent / \"func\"\n trimmed_func_paths = [\"func/\" + func_path.name for func_path in func_dir.glob(\"*.nii\")]\n append_to_json_file(key=\"IntendedFor\", value=trimmed_func_paths, path_to_json=path)","def generate_test_data(root: str) -> str:\n size = (64, 64)\n folder_path = os.path.join(root, \"enviroatlas_lotp\")\n\n if not os.path.exists(folder_path):\n os.makedirs(folder_path)\n\n for prefix in tile_list:\n for suffix, data_profile in layer_data_profiles.items():\n img_path = os.path.join(folder_path, f\"{prefix}_{suffix}.tif\")\n img_dir = os.path.dirname(img_path)\n if not os.path.exists(img_dir):\n os.makedirs(img_dir)\n\n data_profile[\"profile\"][\"height\"] = size[0]\n data_profile[\"profile\"][\"width\"] = size[1]\n data_profile[\"profile\"][\"transform\"] = Affine(\n 1.0, 0.0, 608170.0, 0.0, -1.0, 3381430.0\n )\n\n write_data(\n img_path,\n data_profile[\"profile\"],\n data_profile[\"data_type\"],\n data_profile[\"vals\"],\n )\n\n # build the spatial index\n schema = {\n \"geometry\": \"Polygon\",\n \"properties\": {\n \"split\": \"str\",\n \"naip\": \"str\",\n \"nlcd\": \"str\",\n \"roads\": \"str\",\n \"water\": \"str\",\n \"waterways\": \"str\",\n \"waterbodies\": \"str\",\n \"buildings\": \"str\",\n \"lc\": \"str\",\n \"prior_no_osm_no_buildings\": \"str\",\n \"prior\": \"str\",\n },\n }\n with fiona.open(\n os.path.join(folder_path, \"spatial_index.geojson\"),\n \"w\",\n driver=\"GeoJSON\",\n crs=\"EPSG:3857\",\n schema=schema,\n ) as dst:\n for prefix in tile_list:\n img_path = os.path.join(folder_path, f\"{prefix}_a_naip.tif\")\n with rasterio.open(img_path) as f:\n geom = shapely.geometry.mapping(shapely.geometry.box(*f.bounds))\n geom = fiona.transform.transform_geom(\n f.crs.to_string(), \"EPSG:3857\", geom\n )\n\n row = {\n \"geometry\": geom,\n \"properties\": {\n \"split\": prefix.split(\"/\")[0].replace(\"_tiles-debuffered\", \"\")\n },\n }\n for suffix, data_profile in layer_data_profiles.items():\n key = suffix_to_key_map[suffix]\n row[\"properties\"][key] = f\"{prefix}_{suffix}.tif\"\n dst.write(row)\n\n # Create archive\n archive_path = os.path.join(root, \"enviroatlas_lotp\")\n shutil.make_archive(archive_path, \"zip\", root_dir=root, base_dir=\"enviroatlas_lotp\")\n shutil.rmtree(folder_path)\n md5: str = calculate_md5(archive_path + \".zip\")\n return md5","def generate_args(threshold):\n # EUWATCH\n return_periods = ['00005', '00025', '00050', '00100', '00250', '00500', '01000']\n\n for return_period in return_periods:\n print(\"EUWATCH\", return_period, threshold)\n yield {\n 'infile': \"data/tanzania_flood/EUWATCH/inun_dynRout_RP_{}_Tanzania/inun_dynRout_RP_{}_contour_Tanzania.tif\".format(return_period, return_period),\n 'tmpfile_1': \"data/tanzania_flood/EUWATCH_{}_mask-{}.tif\".format(return_period, threshold),\n 'tmpfile_2': \"data/tanzania_flood/EUWATCH_{}_vector_mask-{}.shp\".format(return_period, threshold),\n 'outfile': \"data/tanzania_flood/threshold_{}/EUWATCH_{}_mask-{}.shp\".format(threshold, return_period, threshold)\n }\n\n # GLOFRIS models\n models = ['GFDL-ESM2M', 'HadGEM2-ES', 'IPSL-CM5A-LR', 'MIROC-ESM-CHEM', 'NorESM1-M']\n\n for model in models:\n for return_period in return_periods:\n print(model, return_period, threshold)\n yield {\n 'infile': \"data/tanzania_flood/{}/rcp6p0/2030-2069/inun_dynRout_RP_{}_bias_corr_masked_Tanzania/inun_dynRout_RP_{}_bias_corr_contour_Tanzania.tif\".format(model, return_period, return_period),\n 'tmpfile_1': \"data/tanzania_flood/{}_{}_mask-{}.tif\".format(model, return_period, threshold),\n 'tmpfile_2': \"data/tanzania_flood/{}_{}_vector_mask-{}.shp\".format(model, return_period, threshold),\n 'outfile': \"data/tanzania_flood/threshold_{}/{}_{}_mask-{}.shp\".format(threshold, model, return_period, threshold)\n }\n\n # Convert SSBN models\n ssbn_return_periods=['5', '10', '20', '50', '75', '100', '200', '250', '500', '1000']\n ssbnmodels = {\n \"TZ_fluvial_undefended\": \"FU\",\n \"TZ_pluvial_undefended\": \"PU\"\n }\n\n for model, abbr in ssbnmodels.items():\n for return_period in ssbn_return_periods:\n print(\"SSBN\", abbr, return_period, threshold)\n yield {\n 'infile': \"data/tanzania_flood/SSBN_flood_data/{}/TZ-{}-{}-1.tif\".format(model, abbr, return_period),\n 'tmpfile_1': \"data/tanzania_flood/SSBN_{}_{}_mask-{}.tif\".format(abbr, return_period, threshold),\n 'tmpfile_2': \"data/tanzania_flood/SSBN_{}_{}_vector_mask-{}.shp\".format(abbr, return_period, threshold),\n 'outfile': \"data/tanzania_flood/threshold_{}/SSBN_{}_{}_mask-{}.shp\".format(threshold, abbr, return_period, threshold)\n }","def generate_output(results, version, template):\n # FIXME: This code is highly coupled with actual scans and may not\n # support adding new scans at all\n\n from licensedcode.cache import get_licenses_db\n\n converted = {}\n converted_infos = {}\n converted_packages = {}\n licenses = {}\n\n LICENSES = 'licenses'\n COPYRIGHTS = 'copyrights'\n PACKAGES = 'packages'\n URLS = 'urls'\n EMAILS = 'emails'\n\n # Create a flattened data dict keyed by path\n for scanned_file in results:\n scanned_file = dict(scanned_file)\n path = scanned_file['path']\n results = []\n if COPYRIGHTS in scanned_file:\n for entry in scanned_file[COPYRIGHTS]:\n results.append({\n 'start': entry['start_line'],\n 'end': entry['end_line'],\n 'what': 'copyright',\n 'value': entry['value'],\n })\n if LICENSES in scanned_file:\n for entry in scanned_file[LICENSES]:\n # make copy\n entry = dict(entry)\n entry_key = entry['key']\n results.append({\n 'start': entry['start_line'],\n 'end': entry['end_line'],\n 'what': 'license',\n 'value': entry_key,\n })\n\n # FIXME: we should NOT rely on license objects: only use what is in the JSON instead\n if entry_key not in licenses:\n licenses[entry_key] = entry\n # we were modifying the scan data in place ....\n entry['object'] = get_licenses_db().get(entry_key)\n if results:\n converted[path] = sorted(results, key=itemgetter('start'))\n\n # TODO: this is klunky: we need to drop templates entirely or we\n # should rather just pass a the list of files from the scan\n # results and let the template handle this rather than\n # denormalizing the list here??\n converted_infos[path] = {}\n for name, value in scanned_file.items():\n if name in (LICENSES, PACKAGES, COPYRIGHTS, EMAILS, URLS):\n continue\n converted_infos[path][name] = value\n\n if PACKAGES in scanned_file:\n converted_packages[path] = scanned_file[PACKAGES]\n\n licenses = dict(sorted(licenses.items()))\n\n files = {\n 'license_copyright': converted,\n 'infos': converted_infos,\n 'packages': converted_packages\n }\n\n return template.generate(files=files, licenses=licenses, version=version)","def generate_tools_list():\n out = {}\n\n # Set BETYDB_LOCAL_CACHE_FOLDER = /tools directory\n print(\"Dumping BETY experiments file into \"+os.environ.get('BETYDB_LOCAL_CACHE_FOLDER', \"/home/extractor/\"))\n #dump_experiments()\n\n toollist = [\n \"bin2tif.py\",\n \"nrmac.py\",\n \"canopyCover.py\",\n \"fieldmosaic.py\",\n \"submit_clowder.py\",\n \"submit_bety.py\",\n \"submit_geo.py\",\n \"bety_experiments.json\"\n ]\n\n print(\"Including /tools directory files\")\n for t in toollist:\n #tool_daxf = create_daxf(t, os.path.join(\"tests/workflow/workflow-pilot/workflow_terra/tools\", t))\n tool_daxf = create_daxf(t, os.path.join(os.getcwd(), \"tools\", t))\n # Use filename as dict key in case we need it as input later\n out[t] = tool_daxf\n\n sensor_metadata_list = [\n \"ua-mac/sensor-metadata/sensors/stereo/sensor_fixed_metadata.json\",\n \"ua-mac/sensor-metadata/sensors/flirIrCamera/sensor_fixed_metadata.json\",\n \"ua-mac/sensor-metadata/sensors/scanner3D/sensor_fixed_metadata.json\",\n \"ua-mac/sensor-metadata/sensors/VNIR/sensor_fixed_metadata.json\",\n \"ua-mac/sensor-metadata/sensors/scanalyzer/sensor_fixed_metadata.json\"\n ]\n print(\"Including sensor fixed metadata\")\n for s in sensor_metadata_list:\n sensor_metadata_daxf = create_daxf(s, os.path.join(sites_dir, s))\n # Use '$SENSOR_fixed' as dict key in case we need it as input later\n out[s.split(\"/\")[-2]+\"_fixed\"] = sensor_metadata_daxf\n\n return out","def generate_final_data(model_names):\n\n for model_name in model_names:\n print(\"Creating fina data for \" + model_name[0])\n\n final_data = {}\n brush_data = common.load_json(\"../steps/\" + model_name[0] + \"/brush_data.json\")\n diff_data = common.load_json(\"../steps/\" + model_name[0] + \"/diff_plot_data.json\")\n distance_data = common.load_json(\"../steps/\" + model_name[0] + \"/distance_data.json\")\n\n final_data[0] = {\n \"step_number\" : 0,\n \"valid\" : brush_data['0'][\"valid\"],\n \"brush_data\" : sanitize_brush_data(brush_data['0']),\n \"diff_data\" : null_diff_data(),\n \"distance_data\" : null_distance_data()\n }\n\n for step_idx in range(1, len(brush_data)):\n print(str(step_idx) + \" \",)\n final_data[step_idx] = {}\n final_data[step_idx][\"step_number\"] = step_idx\n final_data[step_idx][\"valid\"] = brush_data[str(step_idx)][\"valid\"]\n final_data[step_idx][\"brush_data\"] = sanitize_brush_data(brush_data[str(step_idx)])\n final_data[step_idx][\"diff_data\"] = get_diff_data_step(diff_data, step_idx - 1)\n final_data[step_idx][\"distance_data\"] = get_distance_data_step(distance_data, str(step_idx))\n\n common.save_json(final_data, \"../final_data/\" + model_name[0] + \"/final_data.json\", compressed=False)","def process(sources, output, force):\n logging.basicConfig(level=logging.INFO,\n format='%(asctime)s [%(levelname)s] - %(message)s', datefmt=\"%H:%M:%S\")\n\n logging.getLogger('shapely.geos').setLevel(logging.WARNING)\n logging.getLogger('Fiona').setLevel(logging.WARNING)\n logging.getLogger('requests.packages.urllib3.connectionpool').setLevel(logging.WARNING)\n requests.packages.urllib3.disable_warnings()\n # logging.getLogger('processing').setLevel(logging.DEBUG)\n\n catalog_features = []\n failures = []\n path_parts_to_skip = utils.get_path_parts(sources).index(\"sources\") + 1\n success = True\n for path in utils.get_files(sources):\n try:\n logging.info(\"Processing \" + path)\n pathparts = utils.get_path_parts(path)[path_parts_to_skip:]\n pathparts[-1] = pathparts[-1].replace('.json', '.geojson')\n\n outdir = os.path.join(output, *pathparts[:-1], pathparts[-1].replace('.geojson', ''))\n outfile = os.path.join(output, *pathparts)\n\n source = utils.read_json(path)\n urlfile = urlparse(source['url']).path.split('/')[-1]\n \n if not hasattr(adapters, source['filetype']):\n logging.error('Unknown filetype ' + source['filetype'])\n failures.append(path)\n continue\n \n read_existing = False\n if os.path.isfile(outfile):\n logging.info(\"Output file exists\")\n if os.path.getmtime(outfile) > os.path.getmtime(path):\n logging.info(\"Output file is up to date\")\n if not force:\n read_existing = True\n logging.warning('Skipping ' + path + ' since generated file exists. Use --force to regenerate.') \n else:\n logging.info(\"Output is outdated, {} < {}\".format(\n datetime.datetime.fromtimestamp(os.path.getmtime(outfile)),\n datetime.datetime.fromtimestamp(os.path.getmtime(path))))\n\n if read_existing:\n with open(outfile, \"rb\") as f:\n geojson = json.load(f)\n properties = geojson['properties']\n else:\n logging.info('Downloading ' + source['url'])\n \n try:\n fp = utils.download(source['url'])\n except IOError:\n logging.error('Failed to download ' + source['url'])\n failures.append(path)\n continue\n \n logging.info('Reading ' + urlfile)\n \n if 'filter' in source:\n filterer = BasicFilterer(source['filter'], source.get('filterOperator', 'and'))\n else:\n filterer = None\n \n try:\n geojson = getattr(adapters, source['filetype'])\\\n .read(fp, source['properties'],\n filterer=filterer,\n layer_name=source.get(\"layerName\", None),\n source_filename=source.get(\"filenameInZip\", None))\n except IOError as e:\n logging.error('Failed to read ' + urlfile + \" \" + str(e))\n failures.append(path)\n continue\n except zipfile.BadZipfile as e:\n logging.error('Unable to open zip file ' + source['url'])\n failures.append(path)\n continue\n finally:\n os.remove(fp.name)\n if(len(geojson['features'])) == 0:\n logging.error(\"Result contained no features for \" + path)\n continue\n excluded_keys = ['filetype', 'url', 'properties', 'filter', 'filenameInZip']\n properties = {k:v for k,v in list(source.items()) if k not in excluded_keys}\n properties['source_url'] = source['url']\n properties['feature_count'] = len(geojson['features'])\n logging.info(\"Generating demo point\")\n properties['demo'] = geoutils.get_demo_point(geojson)\n \n geojson['properties'] = properties\n \n utils.make_sure_path_exists(os.path.dirname(outfile))\n\n #cleanup existing generated files\n if os.path.exists(outdir):\n rmtree(outdir)\n filename_to_match, ext = os.path.splitext(pathparts[-1])\n output_file_dir = os.sep.join(utils.get_path_parts(outfile)[:-1])\n logging.info(\"looking for generated files to delete in \" + output_file_dir)\n for name in os.listdir(output_file_dir):\n base, ext = os.path.splitext(name)\n if base == filename_to_match:\n to_remove = os.path.join(output_file_dir, name)\n logging.info(\"Removing generated file \" + to_remove)\n os.remove(to_remove)\n\n utils.write_json(outfile, geojson)\n\n logging.info(\"Generating label points\")\n label_geojson = geoutils.get_label_points(geojson)\n label_path = outfile.replace('.geojson', '.labels.geojson')\n utils.write_json(label_path, label_geojson)\n\n logging.info('Done. Processed to ' + outfile)\n \n if not \"demo\" in properties:\n properties['demo'] = geoutils.get_demo_point(geojson)\n\n properties['path'] = \"/\".join(pathparts)\n catalog_entry = {\n 'type': 'Feature',\n 'properties': properties,\n 'geometry': geoutils.get_union(geojson)\n }\n catalog_features.append(catalog_entry)\n\n if not os.path.exists(outdir) or not os.path.exists(os.path.join(outdir, \"units.json\")):\n logging.info(\"Generated exploded GeoJSON to \" + outdir)\n if not os.path.exists(outdir):\n os.makedirs(outdir)\n # .json instead of .geojson, incase there is a unit named \"source\"\n utils.write_json(os.path.join(outdir, \"source.json\"), catalog_entry) \n units = []\n for feature in geojson['features']:\n feature_id = str(feature['properties']['id'])\n feature_id = feature_id.replace('/', '')\n feature_filename = os.path.join(outdir, feature_id + \".geojson\")\n utils.write_json(feature_filename, feature)\n units.append(feature['properties'])\n utils.write_json(os.path.join(outdir, \"units.json\"), units)\n else:\n logging.debug(\"exploded GeoJSON already exists, not generating\")\n\n except Exception as e:\n logging.error(str(e))\n logging.exception(\"Error processing file \" + path)\n failures.append(path)\n success = False\n\n catalog = {\n 'type': 'FeatureCollection',\n 'features': catalog_features\n }\n utils.write_json(os.path.join(output,'catalog.geojson'), catalog)\n\n if not success:\n logging.error(\"Failed sources: \" + \", \".join(failures))\n sys.exit(-1)","def process_files_json():\n # chdir into beep root\n pwd = os.getcwd()\n os.chdir(os.environ.get(\"BEEP_ROOT\", \"/\"))\n\n meta_list = list(filter(lambda x: '_Metadata.csv' in x, os.listdir(SRC_DIR)))\n file_list = list(filter(lambda x: '.csv' in x if x not in meta_list else None, os.listdir(SRC_DIR)))\n all_list = list(filter(lambda x: '.csv' in x, os.listdir(SRC_DIR)))\n\n all_list = sorted(all_list)\n dumpfn(all_list, \"all_files.json\")\n\n [file_id, mapdf] = init_map(PROJECT_NAME, DEST_DIR)\n\n new_file_index = file_id\n\n for filename in tqdm(sorted(file_list)):\n # If the file has already been renamed another entry should not be made\n if mapdf['filename'].str.contains(filename).sum() > 0:\n continue\n old_file = os.path.join(SRC_DIR, filename)\n new_path = os.path.join(DEST_DIR, PROJECT_NAME)\n shutil.copy(old_file, new_path) # copy main data file\n shutil.copy(old_file.replace(\".csv\", '_Metadata.csv'), new_path) # copy meta data file\n\n if PROJECT_NAME == 'FastCharge':\n [date, channel_no, strname, protocol] = get_parameters_fastcharge(filename, SRC_DIR)\n elif PROJECT_NAME == 'ClosedLoopOED':\n [date, channel_no, strname, protocol] = get_parameters_oed(filename, SRC_DIR)\n else:\n raise ValueError(\"Unsupported PROJECT_NAME: {}\".format(PROJECT_NAME))\n\n df_dup = mapdf.set_index(['protocol', 'date'])\n if (protocol, date) in df_dup.index:\n row = mapdf[(mapdf['protocol'] == protocol) & (mapdf['date'] == date)]\n file_id = row['fid'].iloc[0]\n protocol = row['protocol'].iloc[0]\n date = row['date'].iloc[0]\n strname = row['strname'].iloc[0]\n else:\n file_id = new_file_index\n new_file_index = new_file_index + 1\n\n new_name = \"{}_{}_{}\".format(PROJECT_NAME, f'{file_id:06}', channel_no)\n new_file = os.path.join(DEST_DIR, PROJECT_NAME, \"{}.csv\".format(new_name))\n\n new_row = pd.DataFrame([[file_id, protocol, channel_no, date, strname,\n os.path.abspath(old_file),\n os.path.abspath(new_file)]],\n columns=METADATA_COLUMN_NAMES)\n mapdf = mapdf.append(new_row)\n\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename), new_file)\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename).replace(\".csv\", \"_Metadata.csv\"),\n new_file.replace(\".csv\", \"_Metadata.csv\"))\n\n mapdf.to_csv(os.path.join(DEST_DIR, PROJECT_NAME, PROJECT_NAME + \"map.csv\"), index=False)\n mapdf = mapdf.reset_index(drop=True)\n os.chdir(pwd)\n return json.dumps(mapdf.to_dict(\"list\"))","def _generate_objects_file(self):\n xmls = glob(f'{ROOT}/Annotations/**/*.xml', recursive=True)","def reconstitute():\n with open(TEXT_FPATH, 'w') as txt:\n for jfpath in json_fpaths():\n with open(jfpath) as f:\n jstruct = json.load(f)\n\n for recipe in jstruct.keys():\n _reconstitute_recipe(txt, jstruct[recipe])","def main():\r\n # handle arguments\r\n parser = argparse.ArgumentParser()\r\n\r\n parser.add_argument('-t', '--time', help = 'start time', default = \"2018-12-26 18:11:08.509654\")\r\n parser.add_argument('-bd', '--min_duration', type = int, help = 'minimum duration', default = 25)\r\n parser.add_argument('-td', '--max_duration', type = int, help = 'maximum duration', default = 70)\r\n parser.add_argument('-e', '--events', type = int, help = 'how many events to generate', default = 1000)\r\n\r\n args = parser.parse_args()\r\n\r\n f = open(f\"tests/test_1.json\", \"a\")\r\n\r\n string_time = \"2019-07-08 10:40:00.423123\"\r\n\r\n current_time = datetime.datetime.strptime(string_time, '%Y-%m-%d %H:%M:%S.%f')\r\n\r\n for i in range(0, args.events):\r\n\r\n duration = random.randint(args.min_duration, args.max_duration)\r\n\r\n json = \"{\\\"timestamp\\\": \\\"\" \\\r\n + str(current_time) \\\r\n + \"\\\", \\\"translation_id\\\": \\\"5aa5b2f39f7254a75aa5\\\", \" \\\r\n \"\\\"source_language\\\": \\\"en\\\",\\\"target_language\\\":\" \\\r\n \" \\\"fr\\\",\\\"client_name\\\": \\\"easyjet\\\",\\\"event_name\\\":\" \\\r\n \"\\\"translation_delivered\\\",\\\"nr_words\\\": 30, \\\"duration\\\": \"\\\r\n + str(duration) + \"}\\n\"\r\n\r\n f.write(json)\r\n\r\n minutes = random.randint(0, 59)\r\n seconds = random.randint(0, 59)\r\n\r\n current_time += datetime.timedelta(minutes=minutes, seconds=seconds)\r\n\r\n print(f\"New file is located at inputs/{args.events}.json\")","def test_template_json():\n for l in list(templates.data):\n t = templates[l]\n assert len(json.dumps(t.json())) > 0","def main():\n parser = argparse.ArgumentParser(description='Process input file and save to output file.')\n\n parser.add_argument('-i',\n '--input',\n help='Trip report file (txt file) to process.',\n action='store')\n\n parser.add_argument('-o',\n '--output',\n help='Output file (json).',\n action='store')\n\n if len(sys.argv) == 1:\n parser.print_help()\n sys.exit(1)\n\n args = parser.parse_args()\n\n if not args.input:\n print('Please specify the trip report input text file.')\n sys.exit(1)\n\n if args.output:\n output_file = args.output\n else:\n output_file = OUTPUT_DEFAULT\n print(f'No output file specified. Using the default: {OUTPUT_DEFAULT}')\n\n trip_list = [] # the list of trips(dictionaries) to output to the data file\n trip_started = False\n day_started = False\n\n with open(args.input, 'r') as fh:\n\n while True:\n\n line = fh.readline()\n\n if not line:\n break\n\n if line.isspace():\n continue\n\n if '________' in line:\n continue\n\n if line.startswith('TRIP'): # detect start of a trip (anywhere from 1-5 days long)\n # print('Start trip' + line)\n\n trip = Parser.trip_parser(line) # create a trip(dictionary)\n trip['days'] = [] # adds a day list (a list of sectors(dictionaries)) to the trip list\n\n trip_started = True # sets trip started to true\n continue\n\n # if new day has not started, create a new day\n if trip_started and not day_started and Parser.new_day(line):\n day = {'sign_on': line[43:48], 'day_sectors': []}\n day_started = True # sets day started to true\n\n if trip_started and day_started:\n if not Parser.end_day(line):\n # print('During day: ' + line)\n day['day_number'] = line[24:26].strip() # assign a day number to that day\n\n if Parser.in_sector(line): # check if a sector has started\n day['day_sectors'].append(Parser.sector_parser(line)) # append sector to day\n\n else:\n day['sign_off'] = line[53:58].strip() # get sign off time from line\n day['flight_duty_period'] = line[71:76].strip() # get flight duty period\n flight_duty_split = day['flight_duty_period'].split('h') # split flight duty period on 'h'\n day['flight_duty_period_hours'] = int(flight_duty_split[0]) # convert to hours\n day['flight_duty_period_minutes'] = int(flight_duty_split[1]) # convert to minutes\n\n day_started = False # sets day started to false\n\n if not day_started:\n if 'Sign_off' in line: # indicated the day is finished and its only a single day trip\n day['lay_over'] = '0h00' # hard coded 0h00 layover as this is return flight from home base\n day['lay_over_hours'] = 0 # hard coded 0 hours\n day['lay_over_minutes'] = 0 # hard coded 0 minutes\n\n # order the day using an OrderedDict, before adding it to the trip dict\n day_ordered = Parser.order_day(day)\n trip['days'].append(day_ordered)\n\n elif '--------------------------------' in line: # the day is over and now layover\n lay_over = line[88:93].strip() # get layover from line\n day['lay_over'] = lay_over # add to day dictionary\n day['lay_over_hours'] = Parser.layover_split(lay_over)[0] # split and convert to int\n day['lay_over_minutes'] = Parser.layover_split(lay_over)[1] # split and convert to int\n\n # order the day using an OrderedDict, before adding it to the trip dict\n day_ordered = Parser.order_day(day)\n trip['days'].append(day_ordered)\n\n if not line[28:36].isspace() and line[27:35] == 'Sign_off': # detect end of a trip\n trip_started = False # set trip started to False\n\n trip_list.append(trip) # append the trip(dictionary) to the trip list\n\n with open(output_file, 'w') as fh: # Convert everything (including datetime object) to string\n fh.write(json.dumps(trip_list, default=str, indent=4)) # write to json file for output\n\n Display.display_data(output_file) # display analytics data within the terminal\n\n return output_file","def maps():\n flatmap_list = []\n root_path = pathlib.Path(settings['FLATMAP_ROOT'])\n if root_path.is_dir():\n for flatmap_dir in root_path.iterdir():\n index = os.path.join(settings['FLATMAP_ROOT'], flatmap_dir, 'index.json')\n mbtiles = os.path.join(settings['FLATMAP_ROOT'], flatmap_dir, 'index.mbtiles')\n if os.path.isdir(flatmap_dir) and os.path.exists(index) and os.path.exists(mbtiles):\n with open(index) as fp:\n index = json.loads(fp.read())\n version = index.get('version', 1.0)\n reader = MBTilesReader(mbtiles)\n if version >= 1.3:\n metadata = read_metadata(reader, 'metadata')\n if (('id' not in metadata or flatmap_dir.name != metadata['id'])\n and ('uuid' not in metadata or flatmap_dir.name != metadata['uuid'].split(':')[-1])):\n app.logger.error(f'Flatmap id mismatch: {flatmap_dir}')\n continue\n flatmap = {\n 'id': metadata['id'],\n 'source': metadata['source'],\n 'version': version\n }\n if 'created' in metadata:\n flatmap['created'] = metadata['created']\n if 'taxon' in metadata:\n flatmap['taxon'] = normalise_identifier(metadata['taxon'])\n flatmap['describes'] = metadata['describes'] if 'describes' in metadata else flatmap['taxon']\n elif 'describes' in metadata:\n flatmap['taxon'] = normalise_identifier(metadata['describes'])\n flatmap['describes'] = flatmap['taxon']\n if 'biological-sex' in metadata:\n flatmap['biologicalSex'] = metadata['biological-sex']\n if 'uuid' in metadata:\n flatmap['uuid'] = metadata['uuid']\n if 'name' in metadata:\n flatmap['name'] = metadata['name']\n else:\n try:\n source_row = reader._query(\"SELECT value FROM metadata WHERE name='source'\").fetchone()\n except (InvalidFormatError, sqlite3.OperationalError):\n flask.abort(404, 'Cannot read tile database: {}'.format(mbtiles))\n if source_row is None:\n continue\n flatmap = {\n 'id': flatmap_dir.name,\n 'source': source_row[0]\n }\n created = reader._query(\"SELECT value FROM metadata WHERE name='created'\").fetchone()\n if created is not None:\n flatmap['created'] = created[0]\n describes = reader._query(\"SELECT value FROM metadata WHERE name='describes'\").fetchone()\n if describes is not None and describes[0]:\n flatmap['describes'] = normalise_identifier(describes[0])\n flatmap_list.append(flatmap)\n return flask.jsonify(flatmap_list)","def load_all_templates(dataset, template_dir: str) -> Dict[str, NexusTemplate]:\n template_set = {\n template_name\n for template_name in os.listdir(template_dir)\n if not template_name.endswith(\".json\")\n }\n template_set.add(\"linear\")\n\n template_ord = []\n for template_name in TEMPLATE_PREFERRED_ORDER:\n try:\n template_set.remove(template_name)\n except KeyError:\n pass\n else:\n template_ord.append(template_name)\n template_ord.extend(sorted(template_set))\n\n return {\n template_name: load_template(dataset, template_dir, template_name)\n for template_name in template_ord\n }","def test_render_templates():\n water_mol = Atoms(cclib.bridge.cclib2openbabel.readfile(\"data/water.xyz\", \"xyz\"))\n if not water_mol.name:\n water_mol.name = \"data/water.xyz\"\n\n main([\"-g\", \"/tmp/foo.ADF.in\"])\n main([\"/tmp/foo.ADF.in\", \"data/water.xyz\"])\n assert_equals(\n open(\"data/water.in\").read().strip(),\n \"\"\"TITLE data/water.xyz\n\nCHARGE 0 0\n\nNumber of atoms\n 3\n\nATOMS Cartesian\nO 0.0584027061 0.0584027059 0.0000000000\nH 1.0096135406 -0.0680162466 0.0000000000\nH -0.0680162466 1.0096135407 0.0000000000\nEnd\n\nBasis\nEnd\n\nGeometry\nEnd\"\"\",\n )\n\n main([\"-g\", \"/tmp/test.GAMESS.inp\"])\n main([\"/tmp/test.GAMESS.inp\", \"data/water.xyz\"])\n assert_equals(\n open(\"data/water.inp\").read(),\n \"\"\" $CONTRL COORD=CART UNITS=ANGS $END\n\n $DATA\ndata/water.xyz\nC1\nO 8.0 0.0584027061 0.0584027059 0.0000000000\nH 1.0 1.0096135406 -0.0680162466 0.0000000000\nH 1.0 -0.0680162466 1.0096135407 0.0000000000\n $END\n\n\n\"\"\",\n )\n\n main([\"-g\", \"/tmp/hello.GAMESSUK.inp\"])\n main([\"/tmp/hello.GAMESSUK.inp\", \"data/water.xyz\"])\n assert_equals(open(\"data/water.inp\").read(), water_mol.to_string(\"gukin\"))\n\n main([\"-g\", \"/tmp/hello.world.Gaussian.gjf\"])\n main([\"/tmp/hello.world.Gaussian.gjf\", \"data/water.xyz\"])\n assert_equals(\n open(\"data/water.gjf\").read(),\n \"\"\"#Put Keywords Here, check Charge and Multiplicity.\n\n data/water.xyz\n\n0 1\nO 0.0584027061 0.0584027059 0.0000000000\nH 1.0096135406 -0.0680162466 0.0000000000\nH -0.0680162466 1.0096135407 0.0000000000\n\n\"\"\",\n )\n\n main([\"-g\", \"/tmp/bar.Jaguar.in\"])\n main([\"/tmp/bar.Jaguar.in\", \"data/water.xyz\"])\n assert_equals(open(\"data/water.in\").read(), water_mol.to_string(\"jin\"))\n\n main([\"-g\", \"/tmp/foo.Molpro.inp\"])\n main([\"/tmp/foo.Molpro.inp\", \"data/water.xyz\"])\n assert_equals(open(\"data/water.inp\").read(), water_mol.to_string(\"mp\"))\n\n main([\"-g\", \"/tmp/example.MOPAC.mop\"])\n main([\"/tmp/example.MOPAC.mop\", \"data/water.xyz\"])\n assert_equals(\n open(\"data/water.mop\").read(),\n \"\"\"CHARGE=0 MS=0.0\ndata/water.xyz\n\nO 0.05840 1 0.05840 1 0.00000 1\nH 1.00961 1 -0.06802 1 0.00000 1\nH -0.06802 1 1.00961 1 0.00000 1\n\"\"\",\n )\n\n main([\"-g\", \"/tmp/bar.MPQC.in\"])\n main([\"/tmp/bar.MPQC.in\", \"data/water.xyz\"])\n assert_equals(open(\"data/water.in\").read(), water_mol.to_string(\"mpqcin\"))\n\n main([\"-g\", \"/tmp/foo.NWChem.nw\"])\n main([\"/tmp/foo.NWChem.nw\", \"data/water.xyz\"])\n assert_equals(\n open(\"data/water.nw\").read(),\n \"\"\"start molecule\n\ntitle data/water.xyz\n\ngeometry units angstroms print xyz autosym\nO 0.0584027061 0.0584027059 0.0000000000\nH 1.0096135406 -0.0680162466 0.0000000000\nH -0.0680162466 1.0096135407 0.0000000000\nend\n\"\"\",\n )\n\n main([\"-g\", \"/tmp/example.ORCA.inp\"])\n main([\"/tmp/example.ORCA.inp\", \"data/water.xyz\"])\n assert_equals(\n open(\"data/water.inp\").read(),\n \"\"\"# data/water.xyz\n! Opt\n\n* xyz 0 1\nO 0.0584027061 0.0584027059 0.0000000000\nH 1.0096135406 -0.0680162466 0.0000000000\nH -0.0680162466 1.0096135407 0.0000000000\n*\n\"\"\",\n )\n\n main([\"-g\", \"/tmp/bar.Psi.dat\"])\n main([\"/tmp/bar.Psi.dat\", \"data/water.xyz\"])\n assert_equals(\n open(\"data/water.dat\").read(),\n \"\"\"# data/water.xyz\n\nmolecule {\n0 1\nO 0.0584027061 0.0584027059 0.0000000000\nH 1.0096135406 -0.0680162466 0.0000000000\nH -0.0680162466 1.0096135407 0.0000000000\nunits angstrom\n}\n\noptimize('scf')\n\"\"\",\n )\n\n main([\"-g\", \"/tmp/example.QChem.in\"])\n main([\"/tmp/example.QChem.in\", \"data/water.xyz\"])\n assert_equals(open(\"data/water.in\").read(), water_mol.to_string(\"qcin\"))\n\n main([\"-g\", \"/tmp/foo.ZINDO.input\"])\n main([\"/tmp/foo.ZINDO.input\", \"data/water.xyz\"])\n assert_equals(open(\"data/water.input\").read(), water_mol.to_string(\"zin\"))","def create_files_from_templates(self, model_attributes):\n for folder_name in [\"views\", \"urls\"]:\n file_path = \"%s/%s/%s_%s.py\" % (model_attributes['app_label'], folder_name,\n model_attributes['model_name_slug'], folder_name)\n template_path = \"django_baker/%s\" % (folder_name)\n self.create_file_from_template(file_path, template_path, model_attributes)\n for file_name in [\"base\", \"list\", \"detail\", \"create\", \"update\", \"delete\"]:\n file_path = \"%s/templates/%s/%s_%s.html\" % (model_attributes['app_label'], model_attributes['app_label'],\n model_attributes['model_name_slug'], file_name)\n template_path = \"django_baker/%s.html\" % (file_name)\n self.create_file_from_template(file_path, template_path, model_attributes)","def create_base_templates(outdir, templateEnv):\n for file in ME_TEMPLATES:\n filename = os.path.join(outdir, ME_FILENAME.format(file))\n template = templateEnv.get_template(file + '.go.jinja')\n\n with open(filename, 'w') as f:\n output = template.render(copyright=COPYRIGHT,\n generator_warning=GENERATOR_WARNING,\n package_name=PACKAGE_NAME)\n f.write(output)\n pass","def get_template_script(output_dir='.', keep_schrodinger=False, keep_openeye=False,\n systems='all'):\n paths = examples_paths()\n template_script = \"\"\"\n ---\n options:\n output_dir: {output_dir}\n default_number_of_iterations: 0\n temperature: 300*kelvin\n pressure: 1*atmosphere\n minimize: no\n verbose: no\n default_nsteps_per_iteration: 1\n molecules:\n benzene:\n filepath: {benzene_path}\n antechamber: {{charge_method: bcc}}\n benzene-epik0:\n filepath: {benzene_path}\n epik:\n select: 0\n antechamber: {{charge_method: bcc}}\n benzene-epikcustom:\n filepath: {benzene_path}\n epik:\n select: 0\n ph: 7.0\n tautomerize: yes\n antechamber: {{charge_method: bcc}}\n p-xylene:\n filepath: {pxylene_path}\n antechamber: {{charge_method: bcc}}\n p-xylene-name:\n name: p-xylene\n openeye: {{quacpac: am1-bcc}}\n antechamber: {{charge_method: null}}\n toluene:\n filepath: {toluene_path}\n antechamber: {{charge_method: bcc}}\n toluene-smiles:\n smiles: Cc1ccccc1\n antechamber: {{charge_method: bcc}}\n toluene-name:\n name: toluene\n antechamber: {{charge_method: bcc}}\n Abl:\n filepath: {abl_path}\n T4Lysozyme:\n filepath: {lysozyme_path}\n solvents:\n vacuum:\n nonbonded_method: NoCutoff\n GBSA-OBC2:\n nonbonded_method: NoCutoff\n implicit_solvent: OBC2\n PME:\n nonbonded_method: PME\n nonbonded_cutoff: 1*nanometer\n clearance: 10*angstroms\n positive_ion: Na+\n negative_ion: Cl-\n leap:\n parameters: [leaprc.water.tip4pew]\n systems:\n explicit-system:\n receptor: benzene\n ligand: toluene\n solvent: PME\n leap:\n parameters: [leaprc.protein.ff14SB, leaprc.gaff]\n implicit-system:\n receptor: T4Lysozyme\n ligand: p-xylene\n solvent: GBSA-OBC2\n leap:\n parameters: [leaprc.protein.ff14SB, leaprc.gaff]\n hydration-system:\n solute: toluene\n solvent1: PME\n solvent2: vacuum\n leap:\n parameters: [leaprc.protein.ff14SB, leaprc.gaff]\n mcmc_moves:\n single:\n type: LangevinSplittingDynamicsMove\n sequence:\n type: SequenceMove\n move_list:\n - type: MCDisplacementMove\n - type: LangevinDynamicsMove\n samplers:\n repex:\n type: ReplicaExchangeSampler\n sams:\n type: SAMSSampler\n protocols:\n absolute-binding:\n complex:\n alchemical_path:\n lambda_electrostatics: [1.0, 0.5, 0.0]\n lambda_sterics: [1.0, 0.5, 0.0]\n solvent:\n alchemical_path:\n lambda_electrostatics: [1.0, 0.5, 0.0]\n lambda_sterics: [1.0, 0.5, 0.0]\n hydration-protocol:\n solvent1:\n alchemical_path:\n lambda_electrostatics: [1.0, 0.0]\n lambda_sterics: [1.0, 0.0]\n solvent2:\n alchemical_path:\n lambda_electrostatics: [1.0, 0.0]\n lambda_sterics: [1.0, 1.0]\n experiments:\n system: explicit-system\n protocol: absolute-binding\n \"\"\".format(output_dir=output_dir, benzene_path=paths['benzene'],\n pxylene_path=paths['p-xylene'], toluene_path=paths['toluene'],\n abl_path=paths['abl'], lysozyme_path=paths['lysozyme'])\n\n # Load script as dictionary.\n script_dict = yank_load(template_script)\n\n # Find all molecules that require optional tools.\n molecules_to_remove = []\n for molecule_id, molecule_description in script_dict['molecules'].items():\n need_schrodinger = 'epik' in molecule_description\n need_openeye = any([k in molecule_description for k in ['name', 'smiles', 'openeye']])\n if ((need_schrodinger and not keep_schrodinger) or\n (need_openeye and not keep_openeye)):\n molecules_to_remove.append(molecule_id)\n\n # Remove molecules.\n for molecule_id in molecules_to_remove:\n del script_dict['molecules'][molecule_id]\n\n # Remove systems.\n if systems != 'all':\n systems_to_remove = [s for s in script_dict['systems'] if s not in systems]\n for system_id in systems_to_remove:\n del script_dict['systems'][system_id]\n\n return script_dict","def _yield_result_files(self, tpl, **kwargs):\n for sheet in self.shortcut_sheets:\n for ngs_library in sheet.all_ngs_libraries:\n extraction_type = ngs_library.test_sample.extra_infos[\"extractionType\"]\n if ngs_library.extra_infos[\"seqPlatform\"] in (\"ONP\", \"PacBio\"):\n suffix = \"_long\"\n else:\n suffix = \"\"\n yield from expand(\n tpl,\n mapper=self.config[\"tools\"][extraction_type.lower() + suffix],\n ngs_library=[ngs_library],\n **kwargs\n )","def extract_hg_json(json_files):\n for f in json_files:\n # print(f)\n file_path = \"hg_files/\" + f\n # read_from_json = json.load(file_path.read())\n # print(read_from_json)\n with open(file_path) as json_files:\n data = json.load(json_files)\n # pprint(data)\n github_base_link = \"https://github.com/Akhliskun/firefox-infra-changelog/blob/master/hg_files/\"\n repository_name = \"[\" + f.rstrip().replace(\".json\", \"\") + \"]\" + \"(\" + github_base_link + \\\n f.rstrip().replace(\" \", \"%20\") + \")\"\n\n for test in data[\"changesets\"]:\n commit_description = test[\"desc\"]\n replaced_commit_description = re.sub(\"[\\n]\", \" \", commit_description)\n commit_date = test[\"date\"][:1]\n tdz = test[\"date\"][1:]\n test = str(commit_date).strip(\"[]\")\n time_designator = str(tdz).strip(\"[]\")\n data_push = hg_timestamps_handler(test, time_designator)\n replaced_commit_description = str(replaced_commit_description)\n write_main_mk_table(\"main_mk_table.md\", repository_name, replaced_commit_description, data_push)\n # We are braking this for loop since we got the last commit.\n break","def main(\n files: List[Path] = typer.Argument(default=None, dir_okay=False, exists=True),\n template: Optional[str] = typer.Option(\n None, '--template', help='Name of template file'\n ),\n logo: Optional[str] = typer.Option(None, '--logo', help='Name of logo file'),\n logo_width: Optional[str] = typer.Option(\n None, '--logo-width', help='Logo width (default 35mm)'\n ),\n highlight_style: Optional[str] = typer.Option(None, '--highlight-style',\n help='Specify coloring style to be used in highlighting source code'),\n syntax_definition: Optional[str] = typer.Option(None, '--syntax-definition',\n help='Specify a directory which contains syntax definition files'),\n no_toc: bool = typer.Option(\n False, '--no-toc', help='table of contents in PDF document'\n ),\n no_number_sections: bool = typer.Option(False, '--no-number-sections', help='no section numbering'),\n\n no_titlepage: bool = typer.Option(False, '--no-titlepage', help='title in PDF document'),\n tex_file: bool = typer.Option(\n False, '--tex', help='create TeX file instead of PDF document'\n ),\n email: Optional[str] = typer.Option(None, '--email', help='Author email'),\n company: Optional[str] = typer.Option(None, '--company', help='Name of company'),\n department: Optional[str] = typer.Option(\n None, '--department', help='Name of department'\n ),\n confidential: bool = typer.Option(\n False, '--confidential', help='indicate confidential'\n ),\n debug: bool = typer.Option(False, '--debug', help='turns debugging on'),\n pdf_engine: str = typer.Option(\n 'xelatex',\n '--pdf-engine',\n help='Specify pdf engine, one of lualatex, xelatex or tectonic ',\n ),\n _version: bool = typer.Option(\n None, '-V', '--version', callback=version_callback, help='Show version and exit'\n ),\n):\n\n if not files:\n typer.echo('Error: Must specify at least one .md file.')\n raise typer.Abort()\n\n mdfiles: List[str] = [str(md) for md in files]\n\n template = template or os.environ.get('MD2PDF_TEMPLATE')\n if template is None:\n print('No template specified')\n sys.exit(1)\n\n email = email or os.environ.get('MD2PDF_AUTHOR_EMAIL')\n footer_center = ''\n\n # command line overwrites `MD2PDF_PDF_ENGINE`. if both are not given\n # then `xelatex` is the default\n pdf_engine = pdf_engine or os.environ.get('MD2PDF_PDF_ENGINE') or 'xelatex'\n # check that pdf-engine is one of the following\n if pdf_engine not in ['xelatex', 'lualatex', 'tectonic']:\n print('--pdf-engine must be one of \"xelatex\", \"lualatex\", \"tectonic\"')\n sys.exit(1)\n\n ext = '.pdf'\n if tex_file:\n ext = '.tex'\n\n if len(mdfiles) == 1:\n toml_file = os.path.splitext(mdfiles[0])[0] + '.toml'\n\n if os.path.exists(toml_file):\n print(f'TOML file {toml_file} found')\n parsed_toml = toml.load(toml_file)\n default_val = parsed_toml.get('default')\n if default_val is None:\n print(f'No file names found in {toml_file}')\n else:\n mdfiles = default_val.get('files')\n\n for mdf in mdfiles:\n print(f'Compiling {mdf}')\n\n main_mdfile = os.path.realpath(mdfiles[0])\n\n outfile = Path(main_mdfile).stem + ext\n\n year = date.today().year\n\n company = company or os.environ.get('MD2PDF_COMPANY')\n department = department or os.environ.get('MD2PDF_DEPARTMENT')\n\n if company:\n if confidential:\n footer_center = f'© Copyright {year} {company}'\n else:\n footer_center = f'{year} {company}'\n\n pdcmd = PandocCmd(outfile)\n pdcmd.append(f'--template={template}')\n pdcmd.append(f'--pdf-engine={pdf_engine}')\n\n pdcmd.set_v('footer-center', footer_center)\n pdcmd.set_v('company', company)\n pdcmd.set_v('department', department)\n\n syntax_definition = syntax_definition or os.environ.get('MD2PDF_SYNTAX_DEFINITION_DIR')\n if syntax_definition is not None:\n add_syntax_definition(pdcmd, syntax_definition)\n\n pdcmd.append('--highlight-style')\n highlight_style = highlight_style or os.environ.get('MD2PDF_HIGHLIGHT_STYLE')\n if highlight_style is None:\n pdcmd.append('pygments')\n else:\n check_highlight_style(highlight_style)\n pdcmd.append(highlight_style)\n\n if not no_number_sections:\n pdcmd.append('--number-sections')\n\n if no_titlepage:\n pdcmd.set_m('titlepage', 'false')\n\n logo = logo or os.environ.get('MD2PDF_LOGO')\n pdcmd.set_v('logo', logo)\n\n logo_width = logo_width or os.environ.get('MD2PDF_LOGO_WIDTH')\n pdcmd.set_v('logo-width', logo_width)\n\n pdcmd.set_m('email', email)\n\n if not no_toc:\n pdcmd.append('--toc')\n\n pdcmd.extend(mdfiles)\n\n if debug:\n print(' '.join(pdcmd.pandoc))\n\n\n pdcmd.run()","def create_input_file(self, polymer_identifier, format, outpath):\n\n\t\tsmiles = self.get_smiles_from_identifier(polymer_identifier)\n\t\t\n\t\tresult = generate_input_files(smiles, format)\n\t\twith open(outpath, 'w+') as f:\n\t\t\tf.write(result)","def read_templates(folder):\n output = []\n for path, subdirs, files in os.walk(folder):\n for name in files:\n if name.endswith('.yml'):\n tpl = yaml.load(open(os.path.join(path, name)).read())\n tpl['template_name'] = name\n\n # Test if all required fields are in template:\n assert 'keywords' in tpl.keys(), 'Missing keywords field.'\n required_fields = ['date', 'amount', 'invoice_number']\n assert len(set(required_fields).intersection(tpl['fields'].keys())) == len(required_fields), \\\n 'Missing required key in template {} {}. Found {}'.format(name, path, tpl['fields'].keys())\n \n # Keywords as list, if only one.\n if type(tpl['keywords']) is not list:\n tpl['keywords'] = [tpl['keywords']]\n\n output.append(InvoiceTemplate(tpl))\n return output","def main(unused_argv):\n\n # Read the scene file.\n with open(FLAGS.scene_path, 'r') as file_id:\n scenes = json.load(file_id)\n\n # Read the synonyms file.\n with open(FLAGS.synonym_path, 'r') as file_id:\n synonyms = json.load(file_id)\n sorter = lambda x: len(x[0].split(' '))\n\n # Read the metainformation file.\n with open(FLAGS.metainfo_path, 'r') as file_id:\n gvars.METAINFO = json.load(file_id)\n tag_inv_map = {attr: tag for tag, attr in gvars.METAINFO['tag_map'].items()\n if tag != '<P>'}\n gvars.METAINFO['tag_inv_map'] = tag_inv_map\n gvars.METAINFO['synonym_keys'] = sorted(synonyms.items(),\n key=sorter, reverse=True)\n\n # Add ids to objects.\n scenes = utils.add_object_ids(scenes)\n scenes = utils.clean_object_attributes(scenes)\n\n # Read the caption templates.\n template_paths = os.listdir(FLAGS.caption_template_root)\n cap_templates = []\n for ii in template_paths:\n with open(os.path.join(FLAGS.caption_template_root, ii), 'r') as file_id:\n cur_templates = json.load(file_id)\n cap_templates.extend(cur_templates)\n #utils.pretty_print_templates(cap_templates, 1)\n\n # Read the question templates.\n template_paths = os.listdir(FLAGS.question_template_root)\n ques_templates = []\n for ii in template_paths:\n with open(os.path.join(FLAGS.question_template_root, ii), 'r') as file_id:\n cur_templates = json.load(file_id)\n ques_templates.extend(cur_templates)\n #utils.pretty_print_templates(ques_templates, 1)\n\n # 1. Check if there a scene_id_file specified.\n # 2. Check if num_images is -1\n if FLAGS.scene_id_file != '':\n with open(FLAGS.scene_id_file, 'r') as file_id:\n missing_ids = [int(ii.strip('\\n')) for ii in file_id.readlines()]\n print('Dialogs missing for scenes: %d' % len(missing_ids))\n\n # Create a image_index -> scenes list index dictionary\n image_list_id_dict = {ii['image_index']: index\n for index, ii in enumerate(scenes['scenes'])}\n scenes_subset = [scenes['scenes'][image_list_id_dict[scene_id]]\n for scene_id in missing_ids]\n\n elif FLAGS.num_images == -1:\n scenes_subset = scenes['scenes']\n\n else:\n scenes_subset = scenes['scenes'][0: FLAGS.num_images]\n\n # BFS for each scene.\n if FLAGS.num_workers == 1:\n # Single thread version.\n dialogs = []\n for index, scene in enumerate(scenes_subset):\n cur_time = time.strftime('%a-%d%b%y-%X', time.gmtime())\n print('Generating [ %s ] [ Worker: %d, Progress: %d/%d Scene: %d ]' %\\\n (cur_time, 0, index, len(scenes_subset), scene['image_index']))\n gen_dialog = generate_dialog_bfs(scene, cap_templates, ques_templates)\n dialogs.append(gen_dialog)\n\n else:\n # Multithread version.\n output_q = multiprocessing.Queue()\n jobs = []\n for worker_id in range(FLAGS.num_workers):\n allotment = scenes_subset[worker_id::FLAGS.num_workers]\n inputs = (allotment, cap_templates, ques_templates)\n inputs += (worker_id, output_q)\n\n process = multiprocessing.Process(target=worker, args=inputs)\n jobs.append(process)\n process.start()\n\n # Wait for all the jobs to finish and collect the output.\n final_results = {}\n for _ in jobs:\n final_results.update(output_q.get())\n for job in jobs:\n job.join()\n\n # Flatten and sort.\n final_results = [jj for _, ii in final_results.items() for jj in ii]\n dialogs = sorted(final_results, key=lambda x: x['image_index'])\n # utils.pretty_print_dialogs(dialogs)\n\n # Save the dialogs.\n print('Saving dialog at: %s' % FLAGS.save_path)\n with open(FLAGS.save_path, 'w') as file_id:\n json.dump(dialogs, file_id)","def _download_inputs(inputs: Dict[str, str]) -> Dict[str, Path]:\n in_paths = dict()\n for name, endpoint in inputs.items():\n target_dir = _BASE_PATH / name\n target_dir.mkdir()\n target_file = target_dir / 'data.json'\n r = requests.get('{}/data.json'.format(endpoint))\n with target_file.open('wb') as f:\n f.write(r.content)\n in_paths[name] = target_file\n return in_paths","def __fill_all_templates__(self,configs):\n template_dir = configs['system'].get('Common_directories','template')\n sample_template = os.path.join(template_dir,configs['pipeline'].get('Template_files','sample'))\n system_template = os.path.join(template_dir,configs['pipeline'].get('Template_files','system'))\n qsub_template = os.path.join(template_dir,configs['pipeline'].get('Template_files','bcbio'))\n self.__fill_template__(sample_template,self.sample_file)\n self.__fill_template__(system_template,self.systems_file)\n self.__fill_template__(qsub_template,self.qsub_file)","def read_input_files(self):\r\n\r\n for input_file in self.list_of_input_files:\r\n input_file.read_header_of_file()\r\n self.list_of_header_objects.extend(input_file.list_of_header_objects)\r\n self.list_of_header_objects_without_ID.extend(input_file.list_of_header_objects_without_ID)\r\n self.list_of_contigs.extend(input_file.list_of_contigs)\r\n\r\n self.list_of_header_objects = list(toolz.unique(self.list_of_header_objects, key=lambda x: x.tag_and_ID))\r\n self.list_of_header_objects_without_ID = list(\r\n toolz.unique(self.list_of_header_objects_without_ID, key=lambda x: x.line))\r\n self.list_of_contigs = list(toolz.unique(self.list_of_contigs, key=lambda x: x.line))\r\n self.list_of_header_objects.extend(self.list_of_header_objects_without_ID)\r\n self.list_of_header_objects.sort(key=lambda x: x.line)\r\n self.list_of_header_objects.extend(self.list_of_contigs)\r\n self.list_of_header_objects.sort(key=lambda x: x.tag, reverse=False)\r\n self.create_body_header_line_for_output()\r\n self.write_header_in_output_file()\r\n\r\n list_of_chrom = list(self.indices.keys())\r\n list_of_chrom.sort(key=lambda x: self.alphanum_key(x))\r\n for chrom in list_of_chrom:\r\n self.list_of_body_objects.clear()\r\n for input_file in self.list_of_input_files:\r\n input_file.read_specific_chrom_body_of_file(chrom)\r\n self.list_of_body_objects.extend(input_file.list_of_body_objects)\r\n\r\n self.adjust_body_records_to_samples()\r\n self.list_of_body_objects = list(toolz.unique(self.list_of_body_objects, key=lambda x: x.line))\r\n self.list_of_body_objects.sort(key=lambda x: self.alphanum_key(x.line))\r\n self.verify_and_merge_body_records()\r\n self.write_specific_chrom_in_output_file()","def write_complete_data():\n for file_name in os.listdir(SOURCE_PATH):\n if file_name in [\"root.json\", \"es-419.json\"]:\n # \"root\" is not a language, \"es-419\" doesn't contain spell-out rules\n continue\n full_source_path = os.path.join(SOURCE_PATH, file_name)\n full_target_path = os.path.join(TARGET_PATH, file_name.split(\".\")[0] + \".py\")\n full_supplementary_path = os.path.join(SUPPLEMENTARY_PATH, file_name)\n\n language_data = {key: {} for key in REQUIRED_NUMBERS_DATA}\n ordered_language_data = {key: {} for key in REQUIRED_NUMBERS_DATA}\n with open(full_source_path, \"r\") as source:\n data = json.load(source)\n try:\n requisite_data = data[\"rbnf\"][\"rbnf\"][\"SpelloutRules\"]\n except KeyError:\n logging.error(\n f\"\\\"['rbnf']['rbnf']['SpelloutRules']\\\" doesn't exist in {file_name}\"\n )\n continue\n\n for keys, vals in requisite_data.items():\n if _is_valid(keys):\n for key, val in vals.items():\n # Removing soft-hyphens from the source file.\n val = val.replace(\"\\xad\", \"\")\n _extract_information(key, val, language_data)\n\n with open(full_supplementary_path, \"r\") as supplementary_data:\n data = json.load(supplementary_data)\n for keys in REQUIRED_NUMBERS_DATA:\n language_data[keys].update(data[keys])\n sorted_tuples = sorted(\n language_data[keys].items(), key=lambda x: (x[1], x[0])\n )\n for items in sorted_tuples:\n word, number = items[0], items[1]\n ordered_language_data[keys][word] = int(number)\n ordered_language_data[\"SKIP_TOKENS\"] = sorted(data[\"SKIP_TOKENS\"])\n try:\n ordered_language_data[\"USE_LONG_SCALE\"] = data[\"USE_LONG_SCALE\"]\n except KeyError:\n logging.error(f\"long_scale information missing in {file_name}\")\n\n translation_data = json.dumps(\n ordered_language_data, indent=4, ensure_ascii=False\n )\n # Overwriting boolean value with capitalized form\n translation_data = re.sub(r\"\\bfalse\\b\", \"False\", translation_data)\n translation_data = re.sub(r\"\\btrue\\b\", \"True\", translation_data)\n out_text = \"info = \" + translation_data + \"\\n\"\n with open(full_target_path, \"w+\") as target_file:\n target_file.write(out_text)","def test_parse_directory_and_make_json(self):\n parsed = [i for i in parse_directory(\"./test_data/repo\")]\n martial = [\n item for item in parsed if str(item[0].urn) == \"urn:cts:latinLit:textgroup.work.version-lat1\"\n ][0]\n french = [\n item for item in parsed if str(item[0].urn) == \"urn:cts:latinLit:groupe.oeuvre.version-lat1\"\n ][0]\n json_obj, filename = make_json(*martial)\n json_parsed = json.loads(json_obj)\n self.assertEqual(\n json_parsed[\"text\"][\"0\"][\"0\"][\"0\"], \"Spero me secutum in libellis meis tale temperamen-\",\n \"Text passages should be parsed correctly\"\n )\n self.assertEqual(\n filename, \"textgroup__work__lat.json\",\n \"Filename should be created in a stable and understandable manner\"\n )\n\n json_obj, filename = make_json(*french)\n json_parsed = json.loads(json_obj)\n self.assertIn(\n \"cit, nobis magno consensu vitia\", json_parsed[\"text\"][\"0\"][\"0\"],\n \"Text passages should be parsed correctly\"\n )\n self.assertEqual(\n filename, \"groupe_de_texte__oeuvre__lat.json\",\n \"Filename should be created in a stable and understandable manner\"\n )","def load_template(\n dataset: DatasetManager, template_dir: str, template_name: str\n) -> NexusTemplate:\n if template_name == \"linear\":\n return LinearNexusTemplate()\n\n fullpath = os.path.join(template_dir, template_name)\n with open(fullpath + \".json\", \"r\") as fdata:\n data = json.load(fdata)\n\n level_doors = []\n other_doors = []\n for eid, door_data in data[\"doors\"].items():\n if door_data[\"level\"] in dataset.levels:\n level_doors.append(eid)\n else:\n other_doors.append(eid)\n\n return NexusTemplate(fullpath, template_name, data, level_doors, other_doors)","def generate_examples(file_name):\n for line in read_file(file_name):\n yield json.loads(line)","def main(args):\n args = parse_args(args)\n setup_logging(args.loglevel)\n _logger.debug(\"Generating NUFEB simulation files\")\n\n # create nutrients\n light = Nutrient(1e-1, None, None, \"g\", \"nn\")\n co2 = Nutrient(float(args.co2), 1.9e-09, 44.01, \"l\", \"nn\")\n o2 = Nutrient(0.28125, 2.30e-9, 32, \"l\", \"nn\")\n sucrose = Nutrient(float(args.sucrose), 5.2e-10, 342.3, \"l\", \"nn\")\n gco2 = Nutrient(0, None, 44.01, \"g\", \"nn\")\n TEMPLATES_DIR = (Path(__file__).parent) / \"templates\"\n\n captureRate = round(1000 / args.timestep)\n # define dump parameters\n dump_list = {\n \"vtk_dump\": f\"dump atom_vtk all vtk {captureRate} dump*.vtu id type diameter vx vy vz fx fy fz \\n dump grid_vtk all grid/vtk {captureRate} dump_%_*.vti con\",\n \"image_dump\": f\"dump du_image all image {captureRate} image.*.jpg type diameter zoom 2 bacillus type size 1280 720 view 45 60 \\n dump_modify du_image acolor 1 green acolor 2 red\",\n \"movie_dump\": f\"dump du_mov all movie {captureRate} movie.avi type diameter zoom 1.5 bacillus type size 1280 720 view 0 0 \\n dump_modify du_mov acolor 1 green acolor 2 red\",\n \"hdf_dump\": f\"dump du_h5 all nufeb/hdf5 {captureRate} dump.h5 id type x y z vx vy vz fx fy fz radius conc reac\",\n }\n\n dumps = defaultdict(list)\n for i in range(4):\n tmp = [\"vtk_dump\", \"image_dump\", \"movie_dump\", \"hdf_dump\"]\n dumps[tmp[i]]\n\n for dump, dump_var in zip(\n [args.vtk, args.img, args.movie, args.hdf],\n [\"vtk_dump\", \"image_dump\", \"movie_dump\", \"hdf_dump\"],\n ):\n if dump is True or dump == \"True\":\n dumps[dump_var] = dump_list[dump_var]\n else:\n dumps[dump_var] = \"\"\n\n ## Species-specific parameters\n\n # check for runs folder\n if not os.path.isdir(\"runs\"):\n os.mkdir(\"runs\")\n x = float(args.dims.split(\",\")[0])\n y = float(args.dims.split(\",\")[1])\n z = float(args.dims.split(\",\")[2])\n for n in range(1, int(args.num) + 1):\n culture = Culture(args)\n atoms_list = []\n bacilli_list = []\n # Create list of atoms and bacilli for atom definition file\n for cell in culture.cells:\n atoms_list.append(cell.Atom())\n bacilli_list.append(cell.Bacillus())\n # make atom definition file\n for r in range(1, int(args.reps) + 1):\n L = [\n \" NUFEB Simulation\\r\\n\\n\",\n f\" {args.cells_init} atoms \\n\",\n f\" {len(culture.cell_types)} atom types \\n\",\n f\" {args.cells_init} bacilli \\n\\n\",\n f\" 0.0e-4 {x :.2e} xlo xhi \\n\",\n f\" 0.0e-4 {y :.2e} ylo yhi \\n\",\n f\" 0.0e-4 {z :.2e} zlo zhi \\n\\n\",\n \" Atoms \\n\\n\",\n ]\n atoms = L + atoms_list\n atoms.append(\"\\n\")\n atoms.append(\" Bacilli \\n\\n\")\n atoms = atoms + bacilli_list\n # write atom definition file\n f = open(\n f\"runs/atom_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{r}.in\",\n \"w+\",\n )\n f.writelines(atoms)\n RUN_DIR = (\n Path(\"runs\")\n / f\"Run_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{args.reps}\"\n )\n if not os.path.isdir(RUN_DIR):\n os.mkdir(RUN_DIR)\n # os.mkdir(f'runs/Run_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{args.reps}')\n # write initial conditions json file\n dumpfile = open(RUN_DIR / \"metadata.json\", \"w\")\n # dumpfile = open(f\"/runs/Run_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{args.reps}/metadata.json\",'w')\n json.dump(CellInfo, dumpfile, indent=6)\n dumpfile.close()\n ###\n\n # write Inputscript\n # open the file\n filein = open(TEMPLATES_DIR / \"bacillus.txt\")\n # filein = resources.read_text(\"nufeb_tools.templates\", \"Bacillus.txt\")\n # read it\n src = Template(filein.read())\n # do the substitution\n result = src.safe_substitute(\n {\n \"n\": args.cells_init,\n \"SucRatio\": culture.SucRatio,\n \"SucPct\": culture.SucPct,\n \"n_cyanos\": culture.n_cyanos,\n \"n_ecw\": culture.n_ecw,\n \"Replicates\": args.reps,\n \"Timesteps\": args.ntimesteps,\n \"ts\": args.timestep,\n \"CYANOGroup\": culture.cyGroup,\n \"ECWGroup\": culture.ecwGroup,\n \"Zheight\": float(args.dims.split(\",\")[2]),\n \"CYANODiv\": culture.cyDiv,\n \"ECWDiv\": culture.ecwDiv,\n \"light\": light.concentration,\n \"co2\": co2.concentration,\n \"o2\": o2.concentration,\n \"sucrose\": sucrose.concentration,\n \"gco2\": gco2.concentration,\n \"CYANOMonod\": culture.cyMonod,\n \"ECWMonod\": culture.ecwMonod,\n \"CYANOcount\": culture.cyanoCount,\n \"ECWcount\": culture.ecwCount,\n \"v_ncyano\": culture.vcyano,\n \"v_necw\": culture.vecw,\n \"vtk_dump\": dumps[\"vtk_dump\"],\n \"image_dump\": dumps[\"image_dump\"],\n \"movie_dump\": dumps[\"movie_dump\"],\n \"hdf_dump\": dumps[\"hdf_dump\"],\n }\n )\n f = open(\n f\"./runs/Inputscript_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}.lmp\",\n \"w+\",\n )\n f.writelines(result)\n\n # write local run script\n # open the file\n filein = open(TEMPLATES_DIR / \"local.txt\")\n # filein = resources.read_text(\"nufeb_tools.templates\", \"local.txt\")\n # read it\n src = Template(filein.read())\n # do the substitution\n result = src.safe_substitute(\n {\n \"n\": n,\n \"SucRatio\": culture.SucRatio,\n \"SucPct\": culture.SucPct,\n \"n_cyanos\": culture.n_cyanos,\n \"n_ecw\": culture.n_ecw,\n \"Reps\": args.reps,\n }\n )\n f = open(\n f\"./runs/local_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}.sh\", \"w+\"\n )\n f.writelines(result)\n # write slurm script\n # open the file\n filein = open(TEMPLATES_DIR / \"slurm_dev.txt\")\n # filein = resources.read_text(\"nufeb_tools.templates\", \"Slurm.txt\")\n # read it\n src = Template(filein.read())\n # do the substitution\n result = src.safe_substitute(\n {\n \"n\": args.cells_init,\n \"job\": f\"NUFEB_cyano{n}\",\n \"USER\": args.user,\n \"Replicates\": args.reps,\n \"SucPct\": culture.SucPct,\n \"n_cyanos\": culture.n_cyanos,\n \"n_ecw\": culture.n_ecw,\n }\n )\n _logger.info(\"Script ends here\")","def test_json():\n schemas = {\n 'schema-languages': 'bible/languages.json',\n 'schema-book-metadata': 'bible/book-metadata.json',\n 'schema-bible': 'bible/bible-*.json'\n }\n for schema_name, data_path_glob in schemas.items():\n schema_path = 'schemas/{}.json'.format(schema_name)\n with open(schema_path) as schema_file:\n schema = json.load(schema_file)\n data_paths = glob.iglob(data_path_glob)\n for data_path in data_paths:\n with open(data_path) as data_file:\n data = json.load(data_file)\n yield jsonschema.validate, data, schema","def local_metadata(paths):\n\n # Update template directory\n image_graph = network.load_graph(paths.image_network)\n\n template_paths = {}\n\n def template_selection(path_listing):\n for node in path_listing:\n if os.path.exists(paths.resource_pack + '\\\\' + os.path.join(*(node.split(os.path.sep)[1:]))):\n image_data = dict(image_graph.nodes(data=True))[node]\n print(image_data)\n template_paths[os.path.split(image_data['group_name'])[1]] = node\n return\n\n for bunch in connected_component_subgraphs(image_graph):\n sorted_bunch = network.connectivity_sort(bunch.nodes(), bunch)\n\n if len(sorted_bunch) == 1:\n continue\n\n template_selection(sorted_bunch)\n\n print(str(len(list(template_paths.values()))) + ' templates identified.')\n\n with open(paths.binding_identifiers, 'w') as json_binding_ids:\n json.dump(template_paths, json_binding_ids, sort_keys=True, indent=2)\n\n bindings.build(paths, template_paths.values())","def generate_hyperoptimize_json_arrest(path_json: str, model_type: str):\n tmaps: Dict[str, TensorMap] = {}\n\n sliding_window_params = [\n (24, 2),\n (24, 4),\n (24, 6),\n (48, 2),\n (48, 4),\n (48, 6),\n (72, 2),\n (72, 4),\n (72, 6),\n ]\n outcome = [\n (12, 1),\n (12, 2),\n (6, 1),\n (6, 2),\n (3, 1),\n (3, 0),\n ]\n signals = [\n \"blood_pressure_systolic_value\",\n \"blood_pressure_diastolic_value\",\n \"respirations_value\",\n \"pulse_value\",\n \"temperature_value\",\n \"urine_output_value\",\n \"calcium_value\",\n \"sodium_value\",\n \"potassium_value\",\n \"chloride_value\",\n \"bun_value\",\n \"creatinine_value\",\n \"wbc_value\",\n \"hgb_value\",\n \"glucose_value\",\n \"anion_gap_value\",\n \"ppi_value\",\n \"plt_value\",\n ]\n features = [\"min\", \"max\", \"mean\", \"std\", \"first\", \"last\", \"count\"]\n\n input_tensors_set: List[List[str]] = []\n output_tensors_set: List[List[str]] = []\n for window, step in sliding_window_params:\n input_tmaps = []\n sliding_window = (\n f\"{window}_hrs_sliding_window_admin_date_to_arrest_start_date_\"\n f\"{step}_hrs_step\"\n )\n\n for signal in signals:\n for feature in features:\n input_tmaps.append(f\"{signal}_{sliding_window}_{feature}\")\n # input_tmaps.append(\"age_first_visit_arrest_start_date_double\")\n # input_tmaps.append(f\"length_of_stay_{T1}_hrs_pre_arrest_start_date\")\n input_tensors_set.append(input_tmaps)\n\n for prediction, gap in outcome:\n output_tmaps = []\n output_tmaps.append(\n f\"{sliding_window}_{prediction}_hrs_prediction_{gap}_hrs_gap\",\n )\n output_tensors_set.append(output_tmaps)\n\n for tmap_list in input_tensors_set + output_tensors_set:\n for tmap_name in tmap_list:\n try:\n tmaps = update_tmaps(tmap_name=tmap_name, tmaps=tmaps)\n except Exception as e:\n raise ValueError(f\"Unable to create tmap {tmap_name}\") from e\n\n parameters: Dict[str, List[Any]] = generate_model_dict(model_type)\n parameters.update(\n {\n \"input_tensors\": input_tensors_set,\n \"output_tensors\": output_tensors_set,\n \"patient_csv\": [\n \"/media/ml4c3/cohorts_lists/rr-and-codes.csv\",\n ],\n },\n )\n\n generate_hyperoptimize_json(parameters=parameters, path_json=path_json)","def _parse_additional_json(dir_name: Path) -> Dict[str, Any]:\n additional_json = {}\n for filename in dir_name.glob(\"*.json*\"):\n key = filename.name.split(\".\")[0]\n if key not in (\"custodian\", \"transformations\"):\n additional_json[key] = loadfn(filename, cls=None)\n return additional_json","def main():\n os.makedirs(PATH)\n fetch_data()\n convert_to_json(model_list, 'models.json', is_model=True)\n convert_to_json(backend_list, 'backends.json')\n convert_to_json(type_list, 'types.json')\n convert_to_json(featurizer_list, 'featurizers.json')","def create_file(output_json):\n folder = \"data/\"\n filename = datetime.now().strftime(\"%d-%m-%Y\") + \"-moisture-read.json\"\n filepath = folder+filename\n\n # Create Local folder\n try:\n os.mkdir(folder)\n except OSError:\n pass\n #print(\"Directory already created or a failure occured on directory (%s)\" % folder)\n\n # Create Empty Json file if it doesnt exists\n if(Path(filepath)).exists():\n pass\n else:\n try:\n f = open(filepath, \"a\")\n f.write('{\\n\"moisture_iot_project\":[]\\n}')\n f.close()\n except Exception as e:\n print(\"Failure occured creating the JSON file (%s)\" % e)\n\n # Open Json file to append current structure\n with open(filepath) as outfile:\n data = json.load(outfile)\n\n # Get list with all dictionaries\n temp = data['moisture_iot_project']\n\n # Append current structure\n temp.append(output_json)\n\n # Reorganize List values and re-write to JSON file\n data['moisture_iot_project'] = temp\n write_json(data, filepath)","def data_gen(path):\n files = glob.glob(path + \"//*.json\")\n final_data = []\n tot_sents = 0\n for file in files:\n if \"processed_data.json\" in file or \"merged_data.json\" in file or \"result.json\" in file:\n print(file)\n continue\n # if \"holiday\" not in file.lower():\n # continue\n if \"merged\" not in file.lower():\n continue\n # if \"holiday\" in file.lower() or \"merged\" in file.lower():\n # continue\n logger.info(\"Processing \" + file)\n data = json.load(open(file, \"r\", encoding=\"UTF-8\"))\n for (i, datai) in enumerate(data):\n try:\n if \"Results\"in datai.keys():\n ents = datai[\"Results\"]\n else:\n # the whole sentence is an entity\n ents = [datai]\n datai[\"Input\"] = datai[\"Text\"]\n\n sent_ents = []\n for (i, ent) in enumerate(ents):\n # make up lost tokens\n if \"Start\" not in ent.keys():\n ent[\"Start\"] = datai[\"Input\"].find(ent[\"Text\"])\n #logger.warning(\"Can't find Start in original, find one according to the entity text\")\n if \"Length\" not in ent.keys():\n ent[\"Length\"] = len(ent[\"Text\"])\n #logger.warning(\"Can't find Length in original, find one according to the entity text\")\n\n # extract key information as a entity\n ent_type = ent[\"Type\"] if \"Type\" in ent.keys() else (ent[\"TypeName\"] if \"TypeName\" in ent.keys() else ent[\"Typename\"])\n # convert datetimeV2.* to *\n ent_type = ent_type.split(\".\")[-1] if \"datetimeV2\" in ent_type else ent_type\n # convert ordinal.* to ordinal\n ent_type = ent_type.split(\".\")[0] if \"ordinal\" in ent_type else ent_type\n \n # remove entities with null typename\n if len(ent_type) == 0:\n logger.warning(\"Null entities occured in \"+str(ents))\n continue\n \n # find entity resolutions\n if \"Value\" in ent.keys() and \"Resolution\" not in ent.keys():\n ent[\"Resolution\"] = ent[\"Value\"]\n if \"Resolution\" in ent.keys():\n if type(ent[\"Resolution\"])==str:\n assert ent[\"Resolution\"] == \"not resolved\"\n value = \"\"\n else:\n if \"values\" in ent[\"Resolution\"].keys():\n if \"timex\" in ent[\"Resolution\"][\"values\"][0].keys():\n value = \";\".join([v[\"timex\"] for v in ent[\"Resolution\"][\"values\"]])\n else:\n value = \";\".join([v[\"value\"] for v in ent[\"Resolution\"][\"values\"]])\n elif \"offset\" in ent[\"Resolution\"].keys():\n value = ent[\"Resolution\"][\"offset\"]\n elif \"Timex\" in ent[\"Resolution\"].keys():\n value = ent[\"Resolution\"][\"Timex\"]\n elif \"timex\" in ent[\"Resolution\"].keys():\n value = ent[\"Resolution\"][\"timex\"]\n elif \"TimeZoneResolution\" in ent[\"Resolution\"].keys():\n value = ent[\"Resolution\"][\"TimeZoneResolution\"]\n else:\n value = ent[\"Resolution\"][\"value\"]\n else:\n value = \"\"\n\n # filter out unwanted entitiy types\n # get rid of number from number entities\n if ent_type.lower() not in [\"number\",\"ip\",\"quotedtext\",\"url\"]:\n # keep only number entities\n # if ent_type.lower() in [\"number\"]:\n sent_ents.append({\n \"Text\":\n ent[\"Text\"],\n \"Type\":\n ent_type,\n \"Start\":\n ent[\"Start\"],\n \"End\":\n ent[\"End\"] if \"End\" in ent.keys() else ent[\"Start\"] + ent[\"Length\"] - 1,\n \"Resolution\":\n value,\n })\n except Exception as e:\n # in case of any un-expected formats\n print(file)\n print(datai)\n print(ent)\n print(ent[\"Resolution\"].keys())\n raise e\n # find context\n if \"Context\" in datai.keys():\n context = datai[\"Context\"][\"ReferenceDateTime\"]\n max_len = len(\"2017-09-27T17:25:54\")\n context = context[:max_len]\n else:\n context = \"\"\n final_data.append({\"Text\": datai[\"Input\"], \"Entities\": sent_ents,\"Context\": context})\n tot_sents += len(data)\n assert len(final_data) == tot_sents\n\n # robustness check and get basic statistics about current dataset\n data_analysis(final_data)\n # dump the processed data\n final_data = json.dumps(final_data, indent=4, ensure_ascii=False)\n new_file = open(path + \"//processed_data.json\", \"w+\", encoding=\"UTF-8\")\n new_file.writelines(final_data)","def on_get(self, req, resp):\n resp.set_header('Content-Type', 'text/json')\n diaries_paths = encode.get_files_in_directory(DIARIES_TO_CREATE_DIR, \".pdf\")\n\n def extract_file_name(path): return os.path.basename(path)\n resp.body = json.dumps({\"templates_file_names\": list(map(extract_file_name, diaries_paths)),\n \"templates_paths\": diaries_paths})","def test_make_json_advanced(self):\n resources = get_test_resources()\n output, filename = make_json(commit=\"1245\", exclude=[\"tei:note\", \"tei:orig\"], credit=\"PerseusDL\", **resources)\n output = json.loads(output)\n self.assertEqual(\n output[\"text\"][\"0\"][\"0\"][\"0\"], \"Spero me secutum in libellis meis tale temperamen-\",\n \"Text passages should be parsed correctly\"\n )\n self.assertEqual(\n output[\"text\"][\"1\"][\"0\"][\"1\"], \"Et comites longae quaeris habere viae, \",\n \"Text passages should be parsed correctly and note removed\"\n )\n self.assertEqual(\n output[\"text\"][\"1\"][\"1\"][\"3\"], \"Crede mihi, nimium Martia turba sapit. \",\n \"Text passages should be parsed correctly and note removed\"\n )\n self.assertEqual(\n output[\"text\"][\"1\"][\"0\"][\"0\"], \"Qui tecum cupis esse meos ubicumque libellos \",\n \"Text passages should be parsed correctly\"\n )\n self.assertEqual(\n filename, \"textgroup__work__lat.json\",\n \"Filename should be created in a stable and understandable manner\"\n )\n self.assertEqual(\n output[\"original-urn\"], \"urn:cts:latinLit:textgroup.work.version-lat1\",\n \"Original URN should be fed\"\n )\n self.assertEqual(\n output[\"urn\"], \"urn:cts:latinLit:textgroup.work.version-lat1-simple\",\n \"CLTK URN should be suffixed\"\n )\n self.assertEqual(\n output[\"credit\"], \"PerseusDL\",\n \"Credit should be empty by default\"\n )\n self.assertEqual(\n output[\"meta\"], \"book-poem-line\",\n \"meta should reflect the citation scheme\"\n )\n self.assertEqual(\n output[\"author\"], \"textgroup\",\n \"Author name should be the English textgroup name\"\n )\n self.assertEqual(\n output[\"work\"], \"work\",\n \"Work name should be the English work name\"\n )\n self.assertEqual(\n output[\"edition\"], \"description\",\n \"We should have the English description\"\n )\n self.assertEqual(\n output[\"commit\"], \"1245\",\n \"We should have the commit information\"\n )","def _writeInputJSON(self, tstep):\n\n # update json based on the Properties:\n # print(\"Property keys:\")\n for key in self.properties.index:\n # print(key)\n prop = self.properties[key]\n\n if(key[0] == PropertyID.PID_RefractiveIndex and\n key[2] == tstep and key[1] == objID.OBJ_CONE):\n print(\"PID_RefractiveIndex, \", prop.getValue())\n parent = self._jsondata['materials']\n parent[3][\"refractiveIndex\"] = prop.getValue()\n\n elif(key[0] == PropertyID.PID_NumberOfRays and\n key[2] == tstep):\n print(\"PID_NumberOfRays, \", prop.getValue())\n parent = self._jsondata['sources']\n for item in parent:\n item[\"rays\"] = prop.getValue()\n\n elif(key[0] == PropertyID.PID_ChipSpectrum and\n key[2] == tstep):\n print(\"PID_ChipSpectrum, \", prop.getValue())\n parent = self._jsondata['sources']\n for item in parent:\n item[\"wavelengths\"] = prop.getValue()[\n \"wavelengths\"].tolist()\n item[\"intensities\"] = prop.getValue()[\n \"intensities\"].tolist()\n\n elif(key[0] == PropertyID.PID_ParticleNumberDensity and\n key[2] == tstep):\n print(\"PID_ParticleNumberDensity, \", prop.getValue())\n parent = self._jsondata['materials']\n if prop.getValueType() is ValueType.Scalar:\n parent[3][\"particleDensities\"] = [prop.getValue()]\n else:\n parent[3][\"particleDensities\"] = prop.getValue()\n\n elif(key[0] == PropertyID.PID_ScatteringCrossSections and\n key[2] == tstep):\n pass\n elif(key[0] == PropertyID.PID_InverseCumulativeDist and\n key[2] == tstep):\n pass\n # Datafiles:\n parent = self._jsondata['materials']\n\n n_particle_key = (\n PropertyID.PID_NumberOfFluorescentParticles, objID.OBJ_CONE, tstep)\n n_particles = self.properties[n_particle_key]\n parent[3]['numberOfFluorescentParticles'] = n_particles.getValue()\n print(\"n_particles=\", n_particles.getValue(),\n parent[3]['numberOfFluorescentParticles'])\n\n # Phosphor efficiences:\n if PropertyID.PID_PhosphorEfficiency in\\\n self.properties.index.get_level_values('propertyID'):\n effs = self.properties.xs(\n (PropertyID.PID_PhosphorEfficiency, tstep), level=('propertyID', 'tstep'))\n\n efflist = []\n for i, row in effs.iteritems():\n p = row.getValue()\n efflist.extend([p])\n\n parent[3][\"phosphorEfficiencies\"] = efflist\n if len(efflist) != n_particles.getValue():\n raise APIError.APIError(\"Number of phosphor efficiencies \\\n (%d) does not match with number of \\\n fluorescent particles (%d)\" %\n (len(efflist),\n n_particles.getValue())\n )\n else:\n raise APIError.APIError(\n \"Did not find phosphor efficiencies in Properties!\")\n\n # Properties containing emission spectrums\n if PropertyID.PID_EmissionSpectrum in\\\n self.properties.index.get_level_values('propertyID'):\n em = self.properties.xs((PropertyID.PID_EmissionSpectrum, tstep),\n level=('propertyID', 'tstep'))\n\n em_fname = []\n for i, row in em.iteritems():\n p = row.getValue()\n fname = 'InvCumul_EM_%d.dat' % i\n gS.writeEmissionSpectrumFile(p[\"wavelengths\"],\n p[\"intensities\"],\n fname)\n em_fname.extend([fname])\n\n parent[3][\"cumulativeEmissionSpectrumFilenames\"] = em_fname\n if len(em_fname) != n_particles.getValue():\n raise APIError.APIError(\"Number of em spectrum file names \\\n (%d) does not match with number of \\\n fluorescent particles (%d)\" %\n (len(em_fname),\n n_particles.getValue())\n )\n else:\n raise APIError.APIError(\n \"Did not find em spectrum file names in Properties!\")\n\n # Excitation spectrum property\n if PropertyID.PID_ExcitationSpectrum in\\\n self.properties.index.get_level_values('propertyID'):\n ex = self.properties.xs((PropertyID.PID_ExcitationSpectrum, tstep),\n level=('propertyID', 'tstep'))\n\n ex_fname = []\n for i, row in ex.iteritems():\n p = row.getValue()\n fname = 'InvCumul_EX_%d.dat' % i\n gS.writeExAbsSpectrumFile(p[\"wavelengths\"],\n p[\"intensities\"],\n fname)\n ex_fname.extend([fname])\n parent[3][\"excitationSpectrumFilenames\"] = ex_fname\n\n if len(ex_fname) != n_particles.getValue():\n raise APIError.APIError(\"Number of ex spectrum file names \\\n (%d) does not match with number of \\\n fluorescent particles (%d)\" %\n (len(ex_fname),\n n_particles.getValue())\n )\n else:\n raise APIError.APIError(\n \"Did not find ex spectrum file names in Properties!\")\n\n # Absorption spectrum property\n if PropertyID.PID_AsorptionSpectrum in\\\n self.properties.index.get_level_values('propertyID'):\n aabs = self.properties.xs((PropertyID.PID_AsorptionSpectrum,\n tstep),\n level=('propertyID', 'tstep'))\n\n aabs_fname = []\n for i, row in aabs.iteritems():\n p = row.getValue()\n fname = 'InvCumul_ABS_%d.dat' % i\n gS.writeExAbsSpectrumFile(p[\"wavelengths\"],\n p[\"intensities\"],\n fname)\n aabs_fname.extend([fname])\n parent[3][\"absorptionSpectrumFilenames\"] = aabs_fname\n if len(aabs_fname) != n_particles.getValue():\n raise APIError.APIError(\"Number of abs spectrum \\\n file names (%d) does not match \\\n with number of fluorescent \\\n particles (%d)\" %\n (len(aabs_fname),\n n_particles.getValue()))\n else:\n raise APIError.APIError(\n \"Did not find abs spectrum file names in Properties!\")\n\n # write the json file:\n f = open('input.json', 'w')\n f.write(json.dumps(self._jsondata))\n f.close()","def main():\n\n # Set up argument parser.\n parser = argparse.ArgumentParser(\n description='Removes duplicate key-value pairs from JSON files.')\n parser.add_argument('--suffix', default='',\n help='optional suffix for output files; '\n 'if empty, files will be changed in place')\n parser.add_argument('files', nargs='+', help='input files')\n args = parser.parse_args()\n\n # Iterate over files.\n for filename in args.files:\n # Read in json using Python libraries. This eliminates duplicates.\n print('Processing ' + filename + '...')\n try:\n with codecs.open(filename, 'r', 'utf-8') as infile:\n j = json.load(infile)\n except ValueError as e:\n print('Error reading ' + filename)\n raise InputError(filename, str(e))\n\n # Built up output strings as an array to make output of delimiters easier.\n output = []\n for key in j:\n if key != '@metadata':\n output.append('\\t\"' + key + '\": \"' +\n j[key].replace('\\n', '\\\\n') + '\"')\n\n # Output results.\n with codecs.open(filename + args.suffix, 'w', 'utf-8') as outfile:\n outfile.write('{\\n')\n outfile.write(',\\n'.join(output))\n outfile.write('\\n}\\n')","def test_extract_configs():\n extract_config_dir = os.path.join(\n settings.BASE_DIR, \"extract_configs\", \"templates\"\n )\n for ft, obj in FILE_TYPES.items():\n ec_file = obj[\"template\"]\n if not ec_file:\n continue\n ec_path = os.path.join(extract_config_dir, ec_file)\n print(f\"Testing extract config: {ec_path}\")\n assert os.path.exists(ec_path)\n df = make_template_df(ft)\n Extractor().extract(df, ec_path)","def task_reformat_data():\n\n for data_type in data_sets:\n yield {\n 'actions': ['python reformat_weather_data.py %(dependencies)s > %(targets)s'],\n 'file_dep': ['UK_{}_data.txt'.format(data_type)],\n 'targets': ['UK_{}_data.reformatted.txt'.format(data_type)],\n }","def unit_test_obj_mk_obj_template(p, rname, inputs):\n # define name and arguments\n name = 'obj_mk_obj_template'\n arg_names = ['night_name', 'files']\n arg_types = [str, list]\n\n # get arguments\n args = get_args(p, name, rname, inputs, arg_names, arg_types)\n return args, name","def download_json_files(ori, des, date, hredep, args):\n\n print(\"======================================\")\n print(\"= Extracting JSON files from OTP API =\")\n print(\"======================================\")\n i = 0\n for id in ori.keys(): # just so we can get all the ids (could have been des.keys() or hredep.keys())\n if download_json:\n # don't retrieve the data from OTP API if the user specifies it\n url = build_url(ori[id]['orilon'], ori[id]['orilat'],\n des[id]['deslon'], des[id]['deslat'],\n date[id]['year'], date[id]['month'], date[id]['day'],\n hredep[id]['hour'], hredep[id]['minute'],\n args[id])\n try :\n extract_json(url, id, make_dir(json_output))\n except OSError:\n print(\"ERROR : OTP is not currently running on the given port\")\n exit();\n\n printrp('( ' + str(i) + ' / ' + str(len(ori)) + ' )') if found_CmdPrinter else print(i)\n i += 1\n if download_json:\n print('( ' + str(i) + ' / ' + str(len(ori)) + ' )')\n else:\n print(\"Already downloaded\")","def task_generate_tasks():\n \n yield {\n 'basename': 'generate_tasks',\n 'name': None,\n # 'doc': 'docs for X',\n 'watch': ['trains/'],\n 'task_dep': ['create_folders'],\n }\n \n for root, dirs, files in os.walk('trains/',topdown=False):\n for f in files:\n #print(f)\n yield template_train_model(os.path.join(root,f))","def _generate_examples(self, filepath, split):\r\n if self.config.name == \"trex\":\r\n paths = filepath\r\n relations_path = paths[0]\r\n paths = paths[1:]\r\n all_rels = {}\r\n with open(relations_path, encoding=\"utf-8\") as f:\r\n for row in f:\r\n data = json.loads(row)\r\n all_rels[data[\"relation\"]] = data\r\n id_ = -1\r\n for filepath in paths:\r\n with open(filepath, encoding=\"utf-8\") as f:\r\n for row in f:\r\n data = json.loads(row)\r\n pred = all_rels.get(data[\"predicate_id\"], {})\r\n for evidences in data[\"evidences\"]:\r\n id_ += 1\r\n yield id_, {\r\n \"uuid\": str(data[\"uuid\"]),\r\n \"obj_uri\": str(data[\"obj_uri\"]),\r\n \"obj_label\": str(data[\"obj_label\"]),\r\n \"sub_uri\": str(data[\"sub_uri\"]),\r\n \"sub_label\": str(data[\"sub_label\"]),\r\n \"predicate_id\": str(data[\"predicate_id\"]),\r\n \"sub_surface\": str(evidences[\"sub_surface\"]),\r\n \"obj_surface\": str(evidences[\"obj_surface\"]),\r\n \"masked_sentence\": str(evidences[\"masked_sentence\"]),\r\n \"template\": str(pred.get(\"template\", \"\")),\r\n \"template_negated\": str(pred.get(\"template_negated\", \"\")),\r\n \"label\": str(pred.get(\"label\", \"\")),\r\n \"description\": str(pred.get(\"description\", \"\")),\r\n \"type\": str(pred.get(\"type\", \"\")),\r\n }\r\n elif self.config.name == \"conceptnet\":\r\n id_ = -1\r\n with open(filepath, encoding=\"utf-8\") as f:\r\n for row in f:\r\n data = json.loads(row)\r\n if data.get(\"negated\") is not None:\r\n for masked_sentence, negated in zip(data[\"masked_sentences\"], data[\"negated\"]):\r\n id_ += 1\r\n yield id_, {\r\n \"uuid\": str(data[\"uuid\"]),\r\n \"sub\": str(data.get(\"sub\", \"\")),\r\n \"obj\": str(data.get(\"obj\", \"\")),\r\n \"pred\": str(data[\"pred\"]),\r\n \"obj_label\": str(data[\"obj_label\"]),\r\n \"masked_sentence\": str(masked_sentence),\r\n \"negated\": str(negated),\r\n }\r\n else:\r\n for masked_sentence in data[\"masked_sentences\"]:\r\n id_ += 1\r\n yield id_, {\r\n \"uuid\": str(data[\"uuid\"]),\r\n \"sub\": str(data.get(\"sub\", \"\")),\r\n \"obj\": str(data.get(\"obj\", \"\")),\r\n \"pred\": str(data[\"pred\"]),\r\n \"obj_label\": str(data[\"obj_label\"]),\r\n \"masked_sentence\": str(masked_sentence),\r\n \"negated\": str(\"\"),\r\n }\r\n elif self.config.name == \"squad\":\r\n id_ = -1\r\n with open(filepath, encoding=\"utf-8\") as f:\r\n for row in f:\r\n data = json.loads(row)\r\n for masked_sentence in data[\"masked_sentences\"]:\r\n id_ += 1\r\n yield id_, {\r\n \"id\": str(data[\"id\"]),\r\n \"sub_label\": str(data[\"sub_label\"]),\r\n \"obj_label\": str(data[\"obj_label\"]),\r\n \"negated\": str(data.get(\"negated\", \"\")),\r\n \"masked_sentence\": str(masked_sentence),\r\n }\r\n elif self.config.name == \"google_re\":\r\n id_ = -1\r\n paths = filepath\r\n for filepath in paths:\r\n # from https://github.com/facebookresearch/LAMA/blob/master/scripts/run_experiments.py\r\n if \"place_of_birth\" in filepath:\r\n pred = {\r\n \"relation\": \"place_of_birth\",\r\n \"template\": \"[X] was born in [Y] .\",\r\n \"template_negated\": \"[X] was not born in [Y] .\",\r\n }\r\n elif \"date_of_birth\" in filepath:\r\n pred = {\r\n \"relation\": \"date_of_birth\",\r\n \"template\": \"[X] (born [Y]).\",\r\n \"template_negated\": \"[X] (not born [Y]).\",\r\n }\r\n else:\r\n pred = {\r\n \"relation\": \"place_of_death\",\r\n \"template\": \"[X] died in [Y] .\",\r\n \"template_negated\": \"[X] did not die in [Y] .\",\r\n }\r\n with open(filepath, encoding=\"utf-8\") as f:\r\n for row in f:\r\n data = json.loads(row)\r\n for masked_sentence in data[\"masked_sentences\"]:\r\n id_ += 1\r\n yield id_, {\r\n \"pred\": str(data[\"pred\"]),\r\n \"sub\": str(data[\"sub\"]),\r\n \"obj\": str(data[\"obj\"]),\r\n \"evidences\": str(data[\"evidences\"]),\r\n \"judgments\": str(data[\"judgments\"]),\r\n \"sub_w\": str(data[\"sub_w\"]),\r\n \"sub_label\": str(data[\"sub_label\"]),\r\n \"sub_aliases\": str(data[\"sub_aliases\"]),\r\n \"obj_w\": str(data[\"obj_w\"]),\r\n \"obj_label\": str(data[\"obj_label\"]),\r\n \"obj_aliases\": str(data[\"obj_aliases\"]),\r\n \"uuid\": str(data[\"uuid\"]),\r\n \"masked_sentence\": str(masked_sentence),\r\n \"template\": str(pred[\"template\"]),\r\n \"template_negated\": str(pred[\"template_negated\"]),\r\n }","def read_json(self):\n # read in all json files in the input_path, that match the\n # algorithm_name and are not outputs\n for f in os.listdir(self.input_path):\n if(os.path.splitext(f)[1] == \".json\") and (os.path.basename(f).startswith(self.algorithm_name)) and (not os.path.basename(f).startswith(\"_\")):\n self.__input_jsons += [json.load(open(self.input_path + f))]","def create_input_file():\n\n entries = {}\n entries['items'] = []\n\n with open('data.json', 'w') as outfile:\n dump(entries, outfile, indent=4)\n\n print('Created a new data.json file...')","def test_make_json_simple(self):\n resources = get_test_resources()\n output, filename = make_json(**resources)\n output = json.loads(output)\n self.assertEqual(\n output[\"text\"][\"0\"][\"0\"][\"0\"], \"Spero me secutum in libellis meis tale temperamen-\",\n \"Text passages should be parsed correctly\"\n )\n self.assertEqual(\n output[\"text\"][\"1\"][\"0\"][\"0\"], \"Qui tecum cupis esse meos ubicumque libellos \",\n \"Text passages should be parsed correctly\"\n )\n\n self.assertEqual(\n output[\"text\"][\"1\"][\"0\"][\"1\"], \"Et comites longae quaeris habere viae, Something\",\n \"Text passages should be parsed correctly and note kept\"\n )\n self.assertEqual(\n output[\"text\"][\"1\"][\"1\"][\"3\"], \"Crede slug. mihi, nimium Martia turba sapit. \",\n \"Text passages should be parsed correctly and abbr kept\"\n )\n self.assertEqual(\n filename, \"textgroup__work__lat.json\",\n \"Filename should be created in a stable and understandable manner\"\n )\n self.assertEqual(\n output[\"original-urn\"], \"urn:cts:latinLit:textgroup.work.version-lat1\",\n \"Original URN should be fed\"\n )\n self.assertEqual(\n output[\"urn\"], \"urn:cts:latinLit:textgroup.work.version-lat1-simple\",\n \"CLTK URN should be suffixed\"\n )\n self.assertEqual(\n output[\"credit\"], \"\",\n \"Credit should be empty by default\"\n )\n self.assertEqual(\n output[\"meta\"], \"book-poem-line\",\n \"meta should reflect the citation scheme\"\n )\n self.assertEqual(\n output[\"author\"], \"textgroup\",\n \"Author name should be the English textgroup name\"\n )\n self.assertEqual(\n output[\"work\"], \"work\",\n \"Work name should be the English work name\"\n )\n self.assertEqual(\n output[\"edition\"], \"description\",\n \"We should have the English description\"\n )","def get_files_io():\n if GC.conf['general']['training']:\n files_zip = {\n 'raw': os.path.join(COOKED_DATA, 'train.txt'),\n 'new': os.path.join(COOKED_DATA, 'train_new.txt'),\n 'norm': os.path.join(COOKED_DATA, 'train_norm.txt'),\n 'manu': os.path.join(RAW_DATA, 'others', 'temp_updt_manu.txt'),\n 'labels': os.path.join(TRAIN_DATA, 'train_norm.txt_labels.pkl'),\n 'segll': os.path.join(TRAIN_DATA, 'train_norm.txt_seginf_loglab.pkl'),\n 'segdl': os.path.join(TRAIN_DATA, 'train_norm.txt_seginf_deeplog.pkl'),\n 'struct': os.path.join(TRAIN_DATA, 'train_norm.txt_structured.csv'),\n 'output': TRAIN_DATA\n }\n else:\n files_zip = {\n 'raw': os.path.join(COOKED_DATA, 'test.txt'),\n 'new': os.path.join(COOKED_DATA, 'test_new.txt'),\n 'norm': os.path.join(COOKED_DATA, 'test_norm.txt'),\n 'labels': os.path.join(TEST_DATA, 'test_norm.txt_labels.pkl'),\n 'segll': os.path.join(TEST_DATA, 'test_norm.txt_seginf_loglab.pkl'),\n 'segdl': os.path.join(TEST_DATA, 'test_norm.txt_seginf_deeplog.pkl'),\n 'map_norm_raw': os.path.join(TEST_DATA, 'map_norm_raw.pkl'),\n 'map_norm_rcv': os.path.join(TEST_DATA, 'map_norm_rcv.pkl'),\n 'norm_rcv': os.path.join(TEST_DATA, 'test_norm_rcv.txt'),\n 'struct': os.path.join(TEST_DATA, 'test_norm.txt_structured.csv'),\n 'struct_rcv': os.path.join(TEST_DATA, 'test_norm_rcv.txt_structured.csv'),\n 'top': os.path.join(TEST_DATA, 'analysis_summary_top.txt'),\n 'sum': os.path.join(TEST_DATA, 'analysis_summary.csv'),\n 'rst_llab': os.path.join(TEST_DATA, 'results_loglab.csv'),\n 'rst_dlog': os.path.join(TEST_DATA, 'results_deeplog.txt'),\n 'rst_llzr': os.path.join(TEST_DATA, 'results_loglizer.csv'),\n 'dbg': os.path.join(TEST_DATA, 'debug.csv'),\n 'output': TEST_DATA\n }\n return files_zip","def test_files(self, location):\n for filename in os.listdir(location):\n with open(location + '/' + filename) as json_file:\n data = json.load(json_file)\n self.test_data(data)","def _template_formatting(field, inputs, inputs_dict_st):\n from .specs import MultiInputObj, MultiOutputFile\n\n # if a template is a function it has to be run first with the inputs as the only arg\n template = field.metadata[\"output_file_template\"]\n if callable(template):\n template = template(inputs)\n\n # as default, we assume that keep_extension is True\n keep_extension = field.metadata.get(\"keep_extension\", True)\n\n inp_fields = re.findall(r\"{\\w+}\", template)\n inp_fields_fl = re.findall(r\"{\\w+:[0-9.]+f}\", template)\n inp_fields += [re.sub(\":[0-9.]+f\", \"\", el) for el in inp_fields_fl]\n if len(inp_fields) == 0:\n return template\n\n val_dict = {}\n file_template = None\n\n for fld in inp_fields:\n fld_name = fld[1:-1] # extracting the name form {field_name}\n if fld_name not in inputs_dict_st:\n raise AttributeError(f\"{fld_name} is not provided in the input\")\n fld_value = inputs_dict_st[fld_name]\n if fld_value is attr.NOTHING:\n # if value is NOTHING, nothing should be added to the command\n return attr.NOTHING\n else:\n # checking for fields that can be treated as a file:\n # have type File, or value that is path like (including str with extensions)\n if isinstance(fld_value, os.PathLike) or (\n isinstance(fld_value, str) and \".\" in fld_value\n ):\n if file_template:\n raise Exception(\n f\"can't have multiple paths in {field.name} template,\"\n f\" but {template} provided\"\n )\n else:\n file_template = (fld_name, fld_value)\n else:\n val_dict[fld_name] = fld_value\n\n # if field is MultiOutputFile and some elements from val_dict are lists,\n # each element of the list should be used separately in the template\n # and return a list with formatted values\n if field.type is MultiOutputFile and any(\n [isinstance(el, (list, MultiInputObj)) for el in val_dict.values()]\n ):\n # all fields that are lists\n keys_list = [\n k for k, el in val_dict.items() if isinstance(el, (list, MultiInputObj))\n ]\n if any(\n [len(val_dict[key]) != len(val_dict[keys_list[0]]) for key in keys_list[1:]]\n ):\n raise Exception(\n f\"all fields used in {field.name} template have to have the same length\"\n f\" or be a single value\"\n )\n formatted_value = []\n for ii in range(len(val_dict[keys_list[0]])):\n val_dict_el = copy(val_dict)\n # updating values to a single element from the list\n for key in keys_list:\n val_dict_el[key] = val_dict[key][ii]\n\n formatted_value.append(\n _element_formatting(\n template, val_dict_el, file_template, keep_extension=keep_extension\n )\n )\n else:\n formatted_value = _element_formatting(\n template, val_dict, file_template, keep_extension=keep_extension\n )\n return formatted_value","def main(self, verbose=0):\n indepdict=self.scan_for_loop(self.indeploop)\n pegdict1 = self.scan_for_loop(self.pegloop1)\n pegdict2 = self.scan_for_loop(self.pegloop2)\n if len(indepdict.keys()) == 0 and len(pegdict1.keys()) == 0 and len(pegdict2.keys()) == 0:\n return dict()\n alldict = dict(indepdict)\n alldict.update(pegdict1)\n alldict.update(pegdict2)\n indepcomb=self.get_combo_list(indepdict, 0)\n pegcomb1=self.get_combo_list(pegdict1, 1)\n pegcomb2=self.get_combo_list(pegdict2, 1)\n allcombs = self.combine_three_combo_lists(indepcomb, pegcomb1, pegcomb2)\n datasets = self.prepare_looped_datasets(alldict, allcombs)\n createdfiles = self.create_input_files(datasets)\n if verbose == 1:\n self.print_list(indepcomb)\n self.print_list(pegcomb1)\n self.print_list(pegcomb2)\n self.print_list(allcombs)\n for datakey in datasets:\n self.print_list(datasets[datakey])\n return createdfiles","def main():\n\targs = getArgs()\n\tid_question = args.id_question\n\tlang = args.language\n\tdir_cp = None\n\twith open('config.json') as json_file:\n\t\tconfig_data = json.load(json_file)\n\t\tdir_cp = config_data['dir_cp']\n\n\t\n\t\n\t# sample_io = GetData(args.id_question).get_uri_io_sample()\n\ttemplate = FileUtil(id_question, dir_cp['path'], lang)\n\ttemplate.write_template()\n\t# print(sample_io)","def _build_resources_template(self, output_filename=\"{}_r.json\"):\n\n template = self._base_troposphere_template()\n\n for resource_type, resource_cls in six.iteritems(AVAILABLE_RESOURCES):\n resource_cls.register_type_resources_template(self, template)\n for r in self.get_resources(resource_type):\n r.register_resources_template(template)\n\n template = utils.fix_troposphere_references(template)\n\n if template and template.resources:\n output_filename = output_filename.format(self._get_next_build_sequence_id())\n self.puts(colored.cyan(output_filename))\n with open(os.path.join(self.build_path, output_filename), 'w') as f:\n f.write(template.to_json())","def process_singles(pk_type, single_files_path, out_path, skip_lines, encoding):\n if single_files_path.startswith(\".\"):\n return\n\n if os.path.isdir(single_files_path):\n for path, _, files in os.walk(single_files_path):\n for file_name in files:\n if file_name.endswith(\".json\") or file_name.endswith(\".DS_Store\"):\n continue\n json_pk = collections.OrderedDict()\n if file_name:\n extension = file_name[file_name.rfind(\".\") + 1:]\n if (hasattr(pk_type, \"pk_formats\") and\n extension not in pk_type.pk_formats):\n continue\n filepath = os.path.join(path, file_name)\n json_pk = create_script_dict(pk_type, filepath, file_name, skip_lines,\n encoding)\n write_out_scripts(json_pk, filepath, out_path)\n else:\n file_name = os.path.basename(single_files_path)\n json_pk = create_script_dict(pk_type, single_files_path, file_name, skip_lines,\n encoding)\n write_out_scripts(json_pk, single_files_path, out_path)","def return_template_output(base_dir,filename,data_dict):\n templateLoader = jinja2.FileSystemLoader( searchpath=base_dir)\n templateEnv = jinja2.Environment( loader=templateLoader )\n template = templateEnv.get_template(filename)\n output = template.render(data_dict)\n return output","def genConvOnboardingInfoJsonFile( sztpOnboardingInfo, onboardingFileJson ):\n template = {\n \"boot-image\": {\n \"os-name\": str,\n \"os-version\": str,\n \"download-uri\": list, # of uri strings\n \"image-verification\": [ {\n \"hash-algorithm\": str,\n \"hash-value\": str } ],\n },\n \"configuration-handling\": str,\n \"pre-configuration-script\": str,\n \"configuration\": str,\n \"post-configuration-script\": str\n }\n\n def verifyBootImage( template, sztpBootImage ):\n \"\"\"Verify boot image is correct\"\"\"\n def verifyImageVerification( imageVerification ):\n \"\"\"Verify instance of image-verification is correct\"\"\"\n if \"hash-algorithm\" in imageVerification:\n assert imageVerification[ \"hash-algorithm\" ] == \\\n \"ietf-sztp-conveyed-info:sha-256\",\\\n \"Unsupported hash-algorithm\"\n assert \"hash-value\" in imageVerification, \\\n \"Expected hash-value not present\"\n hashValue = imageVerification[ \"hash-value\" ]\n # Verify hashValue appears to be a yang:hex-string\n assert len( hashValue ) == 32 * 3 - 1 and \\\n all( c == ':' or c in string.hexdigits for c in hashValue ), \\\n \"hash-value invalid\"\n\n def verifyImageVerificationList( template, sztpImageVerification ):\n \"\"\"Verify image-verification list is correct\"\"\"\n assert isinstance( sztpImageVerification, list ), \\\n \"Expected list\"\n for imageVer in sztpImageVerification:\n assert verifyDictTypes( template, imageVer ), \"Unexpected value types\"\n assert set( imageVer.keys() ).issubset( set( template.keys() ) ), \\\n \"Unexpected keys in dict\"\n verifyImageVerification( imageVer )\n\n mandatory = [ \"download-uri\" ]\n assert isinstance( sztpBootImage, dict ), \"Expected dict\"\n assert set( sztpBootImage.keys() ).issubset( template.keys() ), \\\n \"Unexpected keys in dict\"\n assert verifyDictTypes( template, sztpBootImage ), \\\n \"Unexpected value types\"\n assert set( mandatory ).issubset( sztpBootImage ), \\\n \"Mandatory keys not present\"\n if \"image-verification\" in sztpBootImage:\n verifyImageVerificationList( template[ \"image-verification\" ][ 0 ],\n sztpBootImage[ \"image-verification\" ] )\n\n # verify onboarding-info dict is correctly constructed\n assert isinstance( sztpOnboardingInfo, dict ), \"Expected dict\"\n assert set( sztpOnboardingInfo.keys() ).issubset( template.keys() ), \\\n \"Unexpected keys in dict\"\n assert verifyDictTypes( template, sztpOnboardingInfo ), \\\n \"Unexpected values types\"\n assert sztpOnboardingInfo[ \"configuration-handling\" ] == \"replace\", \\\n \"Unsupported configuration-handling value\"\n if \"boot-image\" in sztpOnboardingInfo:\n verifyBootImage( template[ \"boot-image\" ],\n sztpOnboardingInfo[ \"boot-image\" ] )\n\n # construct outer dictionary and convert to json\n ietfOnboardingInfo = { \"ietf-sztp-conveyed-info:onboarding-information\":\n sztpOnboardingInfo }\n jsonIetfOnboardingInfo = json.dumps( ietfOnboardingInfo, indent=4 )\n\n # save to file\n with open( onboardingFileJson, \"w\" ) as tmpFile:\n tmpFile.write( jsonIetfOnboardingInfo )","def extract_template(temp_dir, fea_type):\n kps = []\n descriptors = np.array([])\n in_path = temp_dir + 'imgs/' # images\n names = os.listdir(in_path)\n for i, name in enumerate(names):\n img = cv2.imread(in_path + name, 0)\n if any(np.array(img.shape) > 1000):\n img = cv2.resize(img, None, fx=0.5, fy=0.5, interpolation=cv2.INTER_CUBIC)\n print(img.shape)\n kp, des = get_des(fea_type, img)\n if descriptors.size == 0:\n kps = kp\n descriptors = des\n else:\n kps.extend(kp)\n descriptors = np.vstack((descriptors, des))\n\n print(\"template descriptors shape: \" + str(descriptors.shape))\n with open(temp_dir + fea_type + '_template_0.pickle', 'wb') as ff:\n pickle.dump(descriptors, ff)\n\n # with open(temp_dir + fea_type + '_template_0.pickle', 'rb') as f:\n # template = pickle.load(f)\n\n return","def generate_terraform_script(tf_dir):\n\n tf_dir = Path(tf_dir)\n if not tf_dir.is_dir():\n raise TypeError\n\n tf_files = [\n \"main\",\n \"variables\",\n \"backend\",\n \"output\"\n ]\n\n for file in tf_files:\n tpl_file = Path(tf_dir, file + \".tf.tpl\")\n tf_file = Path(tf_dir, file + \".tf\")\n if tpl_file.exists():\n tpl = jinja2.Template(tpl_file.read_text(encoding=\"utf-8\"))\n content = tpl.render(config=config)\n tf_file.write_text(content, encoding=\"utf-8\")","def process(filename, exclude_dirs=['unittest','test',]):\n print(\"Generating {}\".format(filename))\n nb = 0\n nb_err = 0\n _main_root = os.path.dirname(filename)\n _VFS = {}\n for _mydir in (\"libs\", \"Lib\"):\n for _root, _dir, _files in os.walk(os.path.join(_main_root, _mydir)):\n #if _root.endswith('lib_migration'):\n _flag=False\n for _exclude in exclude_dirs:\n if _exclude in _root: #_root.endswith(_exclude):\n _flag=True\n continue\n if _flag:\n continue # skip these modules\n if '__pycache__' in _root:\n continue\n nb += 1\n\n for _file in _files:\n _ext = os.path.splitext(_file)[1]\n if _ext not in ('.js', '.py'):\n continue\n nb += 1\n\n with open(os.path.join(_root, _file), \"r\") as file_with_data:\n _data = file_with_data.read()\n \n if len(_data) == 0:\n print('no data for %s' % _file)\n _data = unicode('')\n print(_data, type(_data))\n else:\n _data = _data.decode('utf-8')\n\n if _ext in '.js':\n if js_minify is not None:\n try:\n _data = js_minify(_data)\n except Exception as error:\n print(error)\n elif _ext == '.py' and len(_data) > 0:\n try:\n _data = pyminifier.remove_comments_and_docstrings(_data)\n _data = pyminifier.dedent(_data)\n except Exception as error:\n print(error)\n nb_err += 1\n\n _vfs_filename = os.path.join(_root, _file).replace(_main_root, '')\n _vfs_filename = _vfs_filename.replace(\"\\\\\", \"/\")\n\n if _vfs_filename.startswith('/libs/crypto_js/rollups/'):\n if _file not in ('md5.js', 'sha1.js', 'sha3.js',\n 'sha224.js', 'sha384.js', 'sha512.js'):\n continue\n\n mod_name = _vfs_filename[len(_mydir) + 2:].replace('/', '.')\n mod_name, ext = os.path.splitext(mod_name)\n is_package = mod_name.endswith('__init__')\n if is_package:\n mod_name = mod_name[:-9]\n _VFS[mod_name] = [ext, _data, 1]\n else:\n _VFS[mod_name] = [ext, _data]\n print((\"adding %s %s\" % (mod_name, _vfs_filename)))\n print('%s files, %s errors' % (nb, nb_err))\n with open(filename, \"w\") as file_to_write_VFS:\n file_to_write_VFS.write('__BRYTHON__.use_VFS = true;\\n')\n file_to_write_VFS.write('__BRYTHON__.VFS=%s;\\n\\n' % json.dumps(_VFS))","def generate_merged_file(json_path:str) -> dict:\n filenames = os.listdir(json_path)\n content_map = defaultdict(dict)\n\n for filename in filenames:\n with open(os.path.join(json_path, filename)) as json_file:\n data = json.load(json_file)\n patientID = str(data['patient']['PatientID'])\n studyUID = str(data['study']['StudyInstanceUID'])\n studyDetails = data['study']\n seriesDetails = data['series']\n seriesInstanceUID = data['series']['SeriesInstanceUID']\n\n if(studyUID not in content_map[patientID]) :\n content_map[patientID][studyUID]=studyDetails\n \n if('Series' not in content_map[patientID][studyUID] ):\n content_map[patientID][studyUID]['Series']={}\n content_map[patientID][studyUID]['Series'][seriesInstanceUID]=seriesDetails\n content_map[patientID][studyUID]['Series'][seriesInstanceUID]['path'] = data['path']\n content_map[patientID][studyUID]['Series'][seriesInstanceUID]['files'] = data['files']\n\n return content_map","def generate_code_files(code_list: List[str], base: str) -> None:\n for code in code_list:\n parts = code.split(' ')\n status = parts[0]\n name = \" \".join(parts[1:])\n path = os.path.join('codes', base, f'{status[0]}XX', f'{status}.json')\n data = {\n 'code': int(status),\n 'name': name,\n 'messages': []\n }\n with open(path, 'w') as jsonfile:\n json.dump(data, jsonfile, indent=4)","def transform(item_paths, output_dir, experiment_code, compresslevel=0):\n aliquots_emitter = emitter('aliquot', output_dir=output_dir)\n for line in reader('{}/sample.json'.format(output_dir)):\n assert 'submitter_id' in line, line\n aliquots_emitter.write(default_aliquot(line['submitter_id'], project_id=DEFAULT_PROJECT_ID))\n aliquots_emitter.close()","def load_umi_template(json_template):\n if os.path.isfile(json_template):\n with open(json_template) as f:\n dicts = json.load(f, object_pairs_hook=OrderedDict)\n\n return [{key: json_normalize(value)} for key, value in dicts.items()]\n else:\n raise ValueError(\"File {} does not exist\".format(json_template))","def processTemplates(self, tk, templateFile = '', id = '', shotNum = '', inprogressBar = ''):\r\n ## Now fetch all the template paths from shotgun\r\n getTemplatePaths = tk.paths_from_template(templateFile, {'Step' : 'Light', 'id' : id, 'Shot' : shotNum})\r\n debug(app = self, method = 'processTemplates', message = 'getTemplatePaths: %s' % getTemplatePaths, verbose = False)\r\n \r\n ## Now look for each assets template path: \r\n xmlFile = max(getTemplatePaths) \r\n debug(app = self, method = 'processTemplates', message = 'Max Version xmlFile.... %s' % xmlFile, verbose = False)\r\n \r\n ## Now if versions has stuff in it..\r\n if not xmlFile:\r\n debug(app = self, method = 'processTemplates', message = 'Can not find any xml files for %s' % shotNum, verbose = False)\r\n pass\r\n else:\r\n \r\n debug(app = self, method = 'processTemplates', message = 'PathTo: %s' % os.path.isfile(xmlFile.replace(os.path.sep, \"/\")), verbose = False)\r\n if os.path.isfile(xmlFile.replace(os.path.sep, \"/\")):## is this a valid xml file!?\r\n inprogressBar.updateProgress(percent = 10, doingWhat = 'createAll shaders...')\r\n self._createAllShaders(XMLPath = xmlFile.replace(os.path.sep, \"/\"), Namespace = '', Root = 'MaterialNodes')\r\n \r\n inprogressBar.updateProgress(percent = 30, doingWhat = 'connectAll shaders...')\r\n self._connectAllShaders(XMLPath = xmlFile.replace(os.path.sep, \"/\"), Namespace = '', Root = 'MaterialNodes')\r\n else:\r\n debug(app = self, method = 'processTemplates', message = 'FAILED Can not find a valid published xml file for %s ...' % os.path.isfile(xmlFile.replace(os.path.sep, \"/\")), verbose = False)\r\n pass","def make_phys():\n for rn in dcm_dict.keys():\n # PPG\n if not dcm_dict[rn]['ppg_file'] == 'File missing':\n # Files\n ppg_tsv = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.tsv.gz')\n ppg_json = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.json')\n # TSV\n gzip_file(dcm_dict[rn]['ppg_file'],ppg_tsv)\n # JSON\n data = OrderedDict()\n data['SamplingFrequency'] = 100.0\n data['StartTime'] = -30.0\n data['Columns'] = 'cardiac'\n with open(ppg_json, 'w') as ff:\n json.dump(data, ff,sort_keys=False, indent=4)\n # Respiration\n if not dcm_dict[rn]['resp_file'] == 'File missing':\n # Files\n resp_tsv = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-respiratory.tsv.gz')\n resp_json = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-respiratory.json')\n # TSV\n gzip_file(dcm_dict[rn]['resp_file'],resp_tsv)\n # JSON\n data = OrderedDict()\n data['SamplingFrequency'] = 25.0\n data['StartTime'] = -30.0\n data['Columns'] = 'respiratory'\n with open(resp_json, 'w') as ff:\n json.dump(data, ff,sort_keys=False, indent=4)\n # ECG\n # What to do if they have PPG and ECG?\n if not dcm_dict[rn]['ecg_file'] == 'File missing':\n # Files\n ecg_tsv = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.tsv.gz')\n ecg_json = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.json')\n # TSV\n gzip_file(dcm_dict[rn]['resp_file'],resp_tsv)\n # JSON\n data = OrderedDict()\n data['SamplingFrequency'] = 1000.0\n data['StartTime'] = -30.0\n data['Columns'] = 'cardiac'\n with open(resp_json, 'w') as ff:\n json.dump(data, ff,sort_keys=False, indent=4)","def main():\n\t# import training data\n\tfiles = [INPATH + f for f in os.listdir(INPATH) if \".json\" in f]\n\n\t# import books\n\tprint(\"Loading training data...\")\n\tbookList = loadBooks(files)\n\tprint(\"Load complete.\")\n\n\t# loop through element types and store data structure\n\tfor key, value in ELEMENTS.items():\n\t\tprint(\"Generating: %s\" % key)\n\n\t\t# set file outpath\n\t\toutfile = \"%s.json\" % key\n\t\toutpath = OUTPATH % outfile\n\n\t\tgenerateTrain(bookList, key, value, outpath)","def main():\n print \"=\" * 78\n print \"%s %s\" % (__prog_name__, __version__)\n debug, input_file_names = check_cli()\n if not input_file_names:\n _error(\"No input file name found!\\n\\n%s\" % __help__)\n for input_file_name in input_file_names:\n print \"* Reading\", input_file_name\n file_base_name = os.path.splitext(os.path.basename(input_file_name))[0]\n file_dir_name = os.path.dirname(input_file_name)\n sections = {}\n tex_map = {}\n with open(input_file_name, 'rU') as in_fd:\n sections = get_sections(in_fd.read())\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"sec\",\n {\"sections\": sections})\n\n if not sections:\n _error(\"Nothing could be read from '%s'.\\nIs this an Oolite .dat file?\" \\\n % input_file_name)\n\n # Magically call the 'check' functions\n for name in sections.keys():\n f_name = \"check_%s\" % name.lower()\n if f_name in globals().keys():\n if not globals()[f_name](sections):\n _error(\"Number of entries in '%s' section is different as declared!\" % name)\n\n def get_data(name, sections=sections):\n \"\"\"Returns the 'data' object from the 'name' one found in the\n 'sections' one.\n :sections: dictionary: Object returned by 'get_sections'.\n :name: string: The name of the section to get the 'data'.\n Returns a list of 'lines'.\n \"\"\"\n return sections.get(name, {}).get(\"data\", [])\n\n oti_file_name = build_file_path(file_dir_name, file_base_name, \"oti\")\n tex_map = parse_names(get_data(\"NAMES\"), oti_file_name)\n\n tex_refs, tex_lines_out = parse_textures(get_data(\"TEXTURES\"))\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"tex\",\n {\"tex_refs\": tex_refs,\n \"tex_lines_out\": tex_lines_out})\n\n # Update the tex_map object if textures indexes and names are both\n # used in 'TEXTURES'.\n if sorted(tex_map.keys()) != sorted(tex_refs.get(\"named\").keys()):\n tex_map = update_tex_map(tex_map,\n set(tex_refs[\"named\"].keys()).difference(tex_map.keys()))\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"txm\",\n {\"tex_map\": tex_map})\n\n n_verts, vertex_lines_out = parse_vertex(get_data(\"VERTEX\"))\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"ver\",\n {\"n_verts\": n_verts,\n \"vertex_lines_out\": vertex_lines_out})\n\n n_normals, normals_lines_out = parse_normals(get_data(\"NORMALS\"))\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"nor\",\n {\"n_normals\": n_normals,\n \"normals_lines_out\": normals_lines_out})\n\n n_faces, faces_groups = parse_faces(get_data(\"FACES\"), tex_refs,\n normals_lines_out)\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"fac\",\n {\"n_faces\": n_faces,\n \"faces_groups\": faces_groups})\n\n output_file_name = build_file_path(file_dir_name,\n file_base_name, 'obj')\n material_file_name = build_file_path(file_dir_name,\n file_base_name, 'mtl')\n mtl_lib_file = os.path.basename(material_file_name)\n\n write_obj(output_file_name, file_base_name, mtl_lib_file,\n tex_lines_out, tex_map, n_verts, vertex_lines_out,\n n_normals, normals_lines_out, n_faces, faces_groups)\n\n write_mtl(material_file_name, tex_map)\n\n _exit(\"* Done\")","def run(xml_files, gold_files, json_output):\n result = harvest_multi(xml_files, gold_files)\n with open(json_output, 'w') as writer:\n writer.write(json.dumps(result, indent=4))","def generate_template():\n date = input(\"What day is the template for? dd/mm/yy: \")\n day = input(\"What day of the week is this?: \")\n if \"/\" not in date:\n date_components = [date[0:2], date[2:4], date[4:]]\n else:\n date_components = date.split(\"/\")\n file_name = \"{}{}{}.table\".format(date_components[0], date_components[1], date_components[2])\n try:\n template_file = open(\"templates/{}_template.table\".format(day), \"r\")\n except IOError:\n print(\"source template not found\")\n else:\n source_lines = []\n output_file = open(file_name, \"w\")\n for line in template_file:\n source_lines.append(line)\n output_file.write(line)\n print(\"template generated successfully for: {} on date: {}\".format(day, date))"],"string":"[\n \"def test_main():\\n for template in templates:\\n main([\\\"-g\\\", template])\\n\\n # One at a time\\n for xyz_file in example_xyz_files:\\n main([template, xyz_file])\\n\\n # All at once\\n main([template] + list(example_xyz_files))\\n\\n # Allow use of template in the parent directory\\n with cd(\\\"data\\\"):\\n main([\\\"../pnictogen/repo/ADF.in\\\", \\\"water-dimer.xyz\\\"])\",\n \"def extract_json_to_files(input_dir,output_dir):\\n files={}\\n files['train']='train-v1.1.json'\\n files['dev']='dev-v1.1.json'\\n\\n for file in files:\\n filename=os.path.join(input_dir,files[file])\\n with open(filename,'r',encoding='utf-8') as data_file:\\n examples = []\\n dataset=json.load(data_file)\\n count_total=total_exs(dataset)\\n count_mapping_problem=0\\n count_token_problem=0\\n count_ansspan_problem=0\\n count_examples=0\\n for article_id in tqdm(range(len(dataset['data'])), desc=\\\"Preprocessing {}\\\".format(file)):\\n article_paragraph=dataset['data'][article_id]['paragraphs']\\n for paragraph_id in range(len(article_paragraph)):\\n context=article_paragraph[paragraph_id]['context']\\n context=context.replace(\\\"''\\\",'\\\"').replace(\\\"``\\\",'\\\"')\\n context = context.replace('\\\\u3000', ' ').replace('\\\\u202f',' ').replace('\\\\u2009', ' ')#.replace(\\\"'\\\",\\\"'\\\")\\n context=context.replace('\\\\-',' ')\\n context_tokens=tokenize_sequence(context)\\n context=context.lower()\\n qas=article_paragraph[paragraph_id]['qas']\\n charloc2wordloc=get_char_word_loc_mapping(context, context_tokens)\\n if charloc2wordloc is None:\\n count_mapping_problem+=len(qas)\\n continue\\n for qa in qas:\\n question=qa['question'].lower()\\n question_tokens=tokenize_sequence(question)\\n\\n ans_text=qa['answers'][0]['text'].lower()\\n ans_text=ans_text.replace('\\\\u3000', ' ').replace('\\\\u202f', ' ').replace('\\\\u2009', ' ')\\n ans_start_loc=qa['answers'][0]['answer_start']\\n if qa['id'] in ['5706baed2eaba6190074aca5','57269c73708984140094cbb5','57269c73708984140094cbb7','572a11661d04691400779721','572a11661d04691400779722','572a11661d04691400779723','572a11661d04691400779724','572a11661d04691400779725','572a2cfc1d0469140077981b','572a3a453f37b319004787e9','572a84d3f75d5e190021fb3c']:\\n ans_start_loc+=1\\n if qa['id'] in ['572a5df77a1753140016aedf','572a5df77a1753140016aee0','572a84d3f75d5e190021fb38','572a84d3f75d5e190021fb39','572a84d3f75d5e190021fb3a','572a84d3f75d5e190021fb3b','572a85df111d821400f38bad','572a85df111d821400f38bae','572a85df111d821400f38baf','572a85df111d821400f38bb0']:\\n ans_start_loc+=2\\n if qa['id'] in ['572a5df77a1753140016aee1','572a5df77a1753140016aee2']:\\n ans_start_loc+=3\\n if qa['id'] in ['57286bf84b864d19001649d6','57286bf84b864d19001649d5']:\\n ans_start_loc-=1\\n if qa['id'] in ['5726bee5f1498d1400e8e9f3','5726bee5f1498d1400e8e9f4']:\\n ans_start_loc-=2\\n ans_end_loc=ans_start_loc+len(ans_text)\\n\\n if context[ans_start_loc:ans_end_loc]!=ans_text:\\n count_ansspan_problem+=1\\n continue\\n ans_start_wordloc = charloc2wordloc[ans_start_loc][1] # answer start word loc\\n ans_end_wordloc = charloc2wordloc[ans_end_loc-1][1] # answer end word loc\\n assert ans_start_wordloc <= ans_end_wordloc\\n\\n ans_tokens = context_tokens[ans_start_wordloc:ans_end_wordloc + 1]\\n if \\\"\\\".join(ans_tokens) != \\\"\\\".join(ans_text.split()):\\n count_token_problem += 1\\n #print(ans_text)\\n #print(ans_tokens)\\n continue # skip this question/answer pair\\n examples.append((' '.join(context_tokens),' '.join(question_tokens),' '.join(ans_tokens),' '.join([str(ans_start_wordloc),str(ans_end_wordloc)])))\\n print(\\\"Number of (context, question, answer) triples discarded due to char -> token mapping problems: \\\", count_mapping_problem)\\n print(\\\"Number of (context, question, answer) triples discarded because character-based answer span is unaligned with tokenization: \\\",count_token_problem)\\n print(\\\"Number of (context, question, answer) triples discarded due character span alignment problems (usually Unicode problems): \\\",count_ansspan_problem)\\n print(\\\"Processed %i examples of total %i\\\\n\\\" % (len(examples), len(examples)+count_mapping_problem+count_token_problem+count_ansspan_problem))\\n indices = list(range(len(examples)))\\n np.random.shuffle(indices)\\n with open(os.path.join(output_dir,file+'.context'),'w',encoding='utf-8') as context_file, \\\\\\n open(os.path.join(output_dir,file+'.question'),'w',encoding='utf-8') as question_file, \\\\\\n open(os.path.join(output_dir,file+'.answer'),'w',encoding='utf-8') as answer_file, \\\\\\n open(os.path.join(output_dir,file+'.span'),'w',encoding='utf-8') as span_file:\\n for i in indices:\\n (context,question,answer,span)=examples[i]\\n context_file.write(context+'\\\\n')\\n question_file.write(question+'\\\\n')\\n answer_file.write(answer+'\\\\n')\\n span_file.write(span+'\\\\n')\",\n \"def main():\\n for db_csv_export in current_dir.glob(\\\"template*.csv\\\"):\\n data_projects = load_projects(db_csv_export)\\n json_path = db_csv_export.with_suffix(\\\".json\\\")\\n with open(json_path, \\\"w\\\") as fh:\\n json.dump(data_projects, fh, indent=2)\",\n \"def main(gtfs_file, input_json_file):\\n\\n with open(input_json_file) as jsonfile:\\n input_json = json.load(jsonfile)\\n\\n gtfs_feed = mzgtfs.feed.Feed(filename=gtfs_file)\\n\\n for fare_id, rules_attributes in input_json.iteritems():\\n add_fare_id(gtfs_feed, fare_id, rules_attributes)\\n\\n files = ['fare_attributes.txt', 'fare_rules.txt']\\n gtfs_feed.write('fare_attributes.txt', gtfs_feed.fares())\\n gtfs_feed.write('fare_rules.txt', gtfs_feed.fare_rules())\\n\\n gtfs_feed.make_zip('output.zip', files=files, clone=gtfs_file)\\n shutil.move('output.zip', gtfs_file)\\n\\n util.delete_temp_files(files)\",\n \"def run(self):\\n if not os.path.exists(self.output_folder):\\n os.makedirs(self.output_folder)\\n for entry in glob.glob(os.path.join(self.data_folder, self.data_expression)):\\n f = open(entry)\\n text = json.loads(f.read())\\n f.close()\\n self.create_page_objects(text)\",\n \"def get_templates(instrument=''):\\n import os, json\\n template_path = os.path.dirname(__file__)\\n template_names = [fn\\n for fn in os.listdir(template_path)\\n if fn.endswith(\\\".json\\\") and fn.startswith(instrument)]\\n templates = dict([(tn[len(instrument)+1:-5],\\n json.loads(open(os.path.join(template_path, tn), 'r').read()))\\n for tn in template_names])\\n return templates\",\n \"def preprocess_template(template_file: str) -> None:\\n LOGGER.info(\\\"Processing template %s\\\", template_file)\\n\\n with DFReader(open(template_file, \\\"rb\\\")) as reader:\\n level = reader.read_level()\\n\\n doors = {}\\n keys_needed: Dict[int, int] = collections.Counter()\\n for eid, (_, _, entity) in level.entities.items():\\n if not isinstance(entity, LevelDoor):\\n continue\\n\\n doors[eid] = {\\n \\\"level\\\": entity.file_name.decode(),\\n \\\"door\\\": entity.door_set,\\n }\\n keys_needed[DOOR_INFO[entity.door_set][1]] += 1\\n\\n for door_data in doors.values():\\n key_type = DOOR_INFO[door_data[\\\"door\\\"]][1]\\n while key_type < 3 and keys_needed[key_type + 1] == 0:\\n key_type += 1\\n door_data[\\\"key_get\\\"] = key_type\\n\\n with open(template_file + \\\".json\\\", \\\"w\\\") as fout:\\n json.dump(\\n {\\\"doors\\\": doors},\\n fout,\\n )\",\n \"def main(filename):\\n with open(filename) as json_file:\\n data = json.load(json_file)\\n\\n course_dict = {}\\n course_dict['course_id'] = str(os.path.split(filename.strip('/'))[-1])\\n course_dict['blocks'] = build_course_map(data)\\n\\n filename = '%s' % course_dict['course_id']\\n filepath = os.path.join('../input/', filename)\\n\\n with open(filepath, 'w') as outfile:\\n json.dump(course_dict, outfile, indent=4)\",\n \"def regenerate_json_file():\\n \\n # filepaths used in generating json data...\\n dir_export = f\\\"C:\\\\\\\\Users\\\\\\\\{os.getlogin()}\\\\\\\\Downloads\\\"\\n list_name = 'my-favourite-films.csv'\\n json_output_filename = 'reviews_web_data.json'\\n path_to_rootreducer = f'D:\\\\\\\\Programming-Projects\\\\\\\\nathansteele\\\\\\\\src\\\\\\\\reducers\\\\\\\\RootReducer.js';\\n path_to_json_output = f'D:\\\\\\\\Programming-Projects\\\\\\\\nathansteele\\\\\\\\src\\\\\\\\components\\\\\\\\films\\\\\\\\{json_output_filename}'\\n \\n # 1) find letterboxd zip export...\\n prefix = 'letterboxd'\\n postfix = 'utc.zip'\\n zip_file_name = \\\"\\\"\\n download_folder = sorted(glob.glob(f\\\"{dir_export}/*.zip\\\"), key=os.path.getmtime)\\n download_folder.reverse() # reversing the list means most recent downloads are first in the list...\\n for filepath in download_folder:\\n filename = filepath.split('\\\\\\\\')[-1]\\n if filename.split('-')[0] == prefix and filename.split('-')[-1] == postfix:\\n zip_file_name = filename\\n print(f\\\"Found the zip export! -> {zip_file_name}\\\")\\n break\\n else:\\n continue\\n\\n path_to_zip_file = f\\\"{dir_export}\\\\\\\\{zip_file_name}\\\" # path to zip file we downlodaded from letterboxd...\\n path_to_extracted_zip = f\\\"{dir_export}\\\\\\\\{zip_file_name[:-4]}\\\" # path to extracted zip (which we are about to do)...\\n\\n # 2) extract zip automatically (if not done already)...\\n if os.path.exists(path=path_to_zip_file):\\n if not os.path.exists(path=path_to_extracted_zip):\\n with zipfile.ZipFile(file=path_to_zip_file , mode='r') as z:\\n z.extractall(path_to_extracted_zip)\\n print(f\\\"Extract complete! -> {path_to_extracted_zip}\\\")\\n else:\\n print(f'Zip file already exists... No need to extract again... -> ({path_to_extracted_zip})')\\n else:\\n print(f'Zip file could not be found... -> ({path_to_zip_file})')\\n\\n\\n # local version of letterboxd data list\\n letterboxd_list = []\\n \\n # 3) locate the csv file of interest\\n if os.path.exists(path_to_extracted_zip): \\n # open csv file...\\n path_to_list = f'{path_to_extracted_zip}\\\\\\\\lists\\\\\\\\{list_name}'\\n with open(path_to_list, 'r') as f:\\n # csv reader object\\n csv_reader = csv.reader(f)\\n \\n # skip header in the csv file...\\n rows_to_skip = 5\\n for i in range(0, rows_to_skip):\\n next(csv_reader)\\n \\n # 4) iterate over each row (i.e. each film) in csv file...\\n for csv_row in csv_reader:\\n pos = csv_row[0]\\n title = csv_row[1]\\n year = csv_row[2]\\n letterboxd_url = csv_row[3]\\n letterboxd_film_id = letterboxd_url.split('/')[-1]\\n genres = []\\n directors = []\\n duration = 0\\n language = \\\"\\\"\\n imdb_url = \\\"\\\"\\n imdb_avg_rating = \\\"\\\"\\n imdb_num_votes = \\\"\\\"\\n tmdb_url = \\\"\\\"\\n poster_url = \\\"\\\"\\n \\n # parse data from letterboxd web page... (this takes ~1.21s)\\n page = session.get(url=letterboxd_url, verify=False, stream=True)\\n soup = BeautifulSoup(page.content, 'html.parser')\\n \\n # retrieve list of genres...\\n div_genres = soup.select_one('#tab-genres')\\n for link in div_genres.select('div.text-sluglist a.text-slug[href]'):\\n if 'genre' in link['href']:\\n genre = link.text.capitalize()\\n if genre == 'Science-fiction':\\n genre = 'Sci-fi'\\n genres.append(genre)\\n\\n # retrieve duration\\n textfooter = soup.select_one('section.col-main > p.text-footer').text\\n if 'mins' in textfooter:\\n minstext = textfooter.find('mins', 0, len(textfooter))\\n duration = textfooter[minstext-5:minstext].strip()\\n \\n # retrieve the first spoken language\\n div_details = soup.select_one('#tab-details')\\n for link in div_details.select('div.text-sluglist a.text-slug[href]'):\\n if 'language' in link['href']:\\n language = link.text.capitalize()\\n break\\n \\n # retrieve IMDB url\\n footer = soup.select_one('section.col-main p.text-footer')\\n url_buttons = footer.select('a.micro-button')\\n for url in url_buttons:\\n if 'imdb' in url.text.lower():\\n # get IMDB URL\\n imdb_url = url['href']\\n elif 'tmdb' in url.text.lower():\\n # get TMDB URL\\n tmdb_url = url['href']\\n if len(url_buttons) == 1:\\n # if there's only 1 url_button, it's usually the IMDB link that's missing...\\n if soup.select_one('#featured-film-header > h1').text == 'xxxHOLiC':\\n imdb_url = 'https://www.imdb.com/title/tt16233104/'\\n\\n # retrieve avg rating on letterboxd\\n # page_content_str = page.content.decode('utf-8')\\n # letterboxd_avg_rating = soup.select_one('.average-rating')\\n\\n # Use the OMDB API (https://www.omdbapi.com/) to retrieve some additional data from IMDB website...\\n omdb_api_key = '4af56bed' # apparently this expires after 1000 days (today is 07/02/2023, 1000 days from now is 03/11/2025... holy shit!)\\n imdb_film_id = imdb_url.split('/')[-2]\\n url = f'http://www.omdbapi.com/?i={imdb_film_id}&apikey={omdb_api_key}'\\n imdb = requests.get(url=url, verify=False)\\n imdb_json = json.loads(imdb.text)\\n\\n # retrieve avg IMD rating\\n imdb_avg_rating = imdb_json['imdbRating']\\n \\n # retrieve number of votes on IMDB (we remove the comma, because react is fucking stupid and cant sort numbers when they contain commas)\\n imdb_num_votes = imdb_json['imdbVotes'].replace(',', '')\\n \\n # retrieve poster from IMDB\\n poster_url = imdb_json['Poster']\\n if 'SX300' in poster_url:\\n poster_url = poster_url.split('SX300')[0]\\n \\n # retrieve title from IMDB (because letterboxd parsing is shite!)\\n # title = imdb_json['Title']\\n \\n # retrieve list of directors (because letterboxd parsing is shite!)\\n directors = imdb_json['Director'].split(', ')\\n \\n # id of my review!\\n titlev2 = Helpers.simplify_movie_title(title=title)\\n review_id = f\\\"{titlev2}-{letterboxd_film_id}-review\\\"\\n \\n \\\"\\\"\\\"\\n # iterate over \\\\\\\\img\\\\\\\\films\\\\\\\\\\n screenshots = []\\n directory_in_str = f'D:\\\\\\\\Programming-Projects\\\\\\\\nathansteele\\\\\\\\src\\\\\\\\img\\\\\\\\films';\\n for subdir, dirs, files in os.walk(directory_in_str):\\n for file in files:\\n # find the right directory...\\n title_from_directory_storing_screenshots = subdir.split('\\\\\\\\')[-1]\\n titlev3 = Helpers.simplify_movie_title(title=title_from_directory_storing_screenshots)\\n if titlev3 == titlev2:\\n # get my screenshots...\\n if 'screenshot' in file:\\n screenshot = os.path.join(subdir, file)\\n screenshots.append(screenshot)\\n \\n # use my custom poster if I put one there...\\n if 'custom_poster' in file:\\n poster_url = os.path.join(subdir, file)\\n \\\"\\\"\\\"\\n \\n # DEBUGGING....\\n print(f\\\" > {pos}: {title}\\\")\\n #print(f' > Title = ({title})')\\n #print(f' > IMDB url = ({imdb_url})')\\n #print(f' > Language = ({language})')\\n #print(f' > Duration = ({duration})')\\n #print(f' > Genres = ({genres})')\\n #print(f' > IMDB avg rating = ({imdb_avg_rating})')\\n #print(f' > IMDB num votes = ({imdb_num_votes})')\\n #print(f' > Poster = ({poster_url})')\\n #print(f' > Directors = ({directors})')\\n #print(f' > Tags = ({my_tags})')\\n \\n # append to list...\\n letterboxd_list.append({\\n 'letterboxdFilmId': letterboxd_film_id,\\n 'imdbFilmId': imdb_film_id,\\n 'letterboxdUrl': letterboxd_url,\\n 'imdbUrl': imdb_url,\\n 'posterUrl': poster_url,\\n 'position': pos,\\n 'title': title,\\n 'year': year,\\n 'duration': duration,\\n 'language': language,\\n 'imdbAvgRating': imdb_avg_rating,\\n 'imdbNumVotes': imdb_num_votes,\\n 'tmdbUrl': tmdb_url,\\n 'directors': directors,\\n 'genres': genres,\\n 'reviewId': review_id\\n })\\n \\n # clear json file first...\\n open(path_to_json_output, 'w').close()\\n \\n # write new content...\\n with open(path_to_json_output, 'w') as f:\\n json.dump(letterboxd_list, f, indent=4)\\n \\n print(f'JSON export finished! -> {path_to_json_output}')\",\n \"def get_template_files(fs, template_type):\\n # no template fitting for null runs\\n if fs[\\\"null_run\\\"]:\\n template_type = None\\n\\n if \\\"template_type\\\" in fs:\\n if template_type == fs[\\\"template_type\\\"]:\\n return\\n\\n fs[\\\"template_type\\\"] = template_type\\n\\n # find all corresponding foreground templates\\n if template_type is None:\\n fs[\\\"template_root\\\"] = None\\n fs[\\\"template_root2\\\"] = None\\n fs[\\\"template_files\\\"] = None\\n fs[\\\"template_files2\\\"] = None\\n fs[\\\"template_noise_root\\\"] = None\\n fs[\\\"template_noise_root2\\\"] = None\\n fs[\\\"template_noise_files\\\"] = None\\n fs[\\\"template_noise_files2\\\"] = None\\n fs[\\\"num_template\\\"] = 0\\n fs[\\\"num_template_noise\\\"] = 0\\n else:\\n num_template_noise = None\\n for hm in [\\\"1\\\", \\\"2\\\"]:\\n suff = \\\"\\\" if hm == \\\"1\\\" else \\\"2\\\"\\n troot = os.path.join(\\n fs[\\\"data_root\\\"],\\n \\\"templates_{}\\\".format(template_type),\\n \\\"halfmission-{}\\\".format(hm),\\n )\\n ### this block is so sims with template type like\\n # 353_100_gauss_003 can use ensemble in 353_100_gauss\\n tp = template_type.split(\\\"_\\\")\\n ttype = template_type\\n if tp[-1].isdigit():\\n if ttype[-7:] not in [\\\"353_100\\\", \\\"217_100\\\"]:\\n ttype = \\\"_\\\".join(tp[:-1])\\n\\n tnroot = os.path.join(\\n fs[\\\"data_root\\\"],\\n \\\"templates_noise_{}\\\".format(ttype),\\n \\\"halfmission-{}\\\".format(hm),\\n )\\n\\n tfiles = []\\n tnfiles = []\\n for f in fs[\\\"map_files\\\"]:\\n nfile = f.replace(fs[\\\"map_root\\\"], troot)\\n if not os.path.exists(nfile):\\n raise OSError(\\\"Missing hm-{} template for {}\\\".format(hm, f))\\n tfiles.append(nfile)\\n nfiles = sorted(\\n glob.glob(\\n f.replace(fs[\\\"map_root\\\"], tnroot).replace(\\n \\\".fits\\\", \\\"_*.fits\\\"\\n )\\n )\\n )\\n if not len(nfiles):\\n raise OSError(\\n \\\"Missing hm-{} template noise for {}\\\".format(hm, f)\\n )\\n tnfiles.append(nfiles)\\n if num_template_noise is not None:\\n if len(nfiles) != num_template_noise:\\n raise OSError(\\n \\\"Wrong number of template noise sims. \\\"\\n \\\"Found {} files, expected {}.\\\".format(\\n len(nfiles), num_template_noise\\n )\\n )\\n\\n num_template_noise = len(nfiles)\\n\\n tfiles = np.asarray(tfiles)\\n tnfiles = np.asarray(tnfiles)\\n fs[\\\"template_root{}\\\".format(suff)] = troot\\n fs[\\\"template_files{}\\\".format(suff)] = tfiles\\n fs[\\\"template_noise_root{}\\\".format(suff)] = tnroot\\n fs[\\\"template_noise_files{}\\\".format(suff)] = tnfiles\\n\\n fs[\\\"num_template\\\"] = len(fs[\\\"template_files\\\"])\\n fs[\\\"num_template_noise\\\"] = num_template_noise\\n self.log(\\n \\\"Found {} templates in {}\\\".format(\\n fs[\\\"num_template\\\"], fs[\\\"template_root\\\"]\\n ),\\n \\\"info\\\",\\n )\\n self.log(\\n \\\"Found {} template noise files in {}\\\".format(\\n fs[\\\"num_template_noise\\\"], fs[\\\"template_noise_root\\\"]\\n ),\\n \\\"info\\\",\\n )\\n self.log(\\\"Template files: {}\\\".format(fs[\\\"template_files\\\"]), \\\"debug\\\")\\n\\n fields = [\\n \\\"template_type\\\",\\n \\\"template_root\\\",\\n \\\"template_root2\\\",\\n \\\"template_files\\\",\\n \\\"template_files2\\\",\\n \\\"template_noise_root\\\",\\n \\\"template_noise_root2\\\",\\n \\\"template_noise_files\\\",\\n \\\"template_noise_files2\\\",\\n \\\"num_template\\\",\\n \\\"num_template_noise\\\",\\n ]\\n for k in fields:\\n setattr(self, k, fs[k])\",\n \"def create_dicts():\\n load_data_for_dict('data/atis/train/seq.in', 'data/atis/voc/vocabulary.json')\\n load_data_for_dict('data/atis/valid/seq.in', 'data/atis/voc/vocabulary.json')\\n load_data_for_dict('data/atis/test/seq.in', 'data/atis/voc/vocabulary.json') \\n load_data_for_dict('data/atis/train/seq.out', 'data/atis/voc/slot_vocabulary.json')\",\n \"def get_files(template_path, resource_type, skip_customer_resources=False):\\n try:\\n json_files = []\\n for file_path in find_files(template_path, '*.json'):\\n folder_list = list(file_path.split(\\\"/\\\"))\\n if not ('/customer/' in file_path.lower() and skip_customer_resources):\\n folder_name = list(folder_list[-1].split('.'))\\n file_name = folder_name[-2]\\n if resource_type in ['template', 'script', 'policy']:\\n if '_ignore' not in file_path and not file_name.startswith('Blueprint_'):\\n if folder_list[-2] == file_name:\\n json_files.append(file_path)\\n else:\\n if file_name.startswith('Blueprint_'):\\n folder_name = \\\"Blueprint_%s\\\" % folder_list[-2]\\n if folder_name == file_name:\\n json_files.append(file_path)\\n else:\\n json_file = open(file_path, 'r')\\n content = json.dumps(json_file.read()).encode('utf-8')\\n json_file.close()\\n content = json.loads(content)\\n blueprint_details = json.loads(content)\\n bp_name = \\\"Blueprint_%s\\\" % blueprint_details.get('name')\\n if bp_name == file_name:\\n json_files.append(file_path)\\n return json_files\\n except Exception as e:\\n sys.stderr.write(e.message)\\n exit(1)\",\n \"def manufacturing_manifest_json(self):\\n\\n file_name = os.path.join(self.cur_8digit_dir, \\\"manufacturing.manifest.json\\\")\\n\\n with open(file_name) as f_in:\\n man_manifest = json.load(f_in)\\n\\n for component in man_manifest[\\\"ComponentManufactureList\\\"]:\\n # Get ManufacturingModel (if exists)\\n if \\\"ManufacturingModel\\\" in component:\\n rel_path_from_results = os.path.join(self.cur_8digit_dir, component[\\\"ManufacturingModel\\\"])\\n if os.path.exists(rel_path_from_results):\\n self.files_for_export.append(os.path.join('results', rel_path_from_results))\\n\\n # Get STEPModel (if exists)\\n if \\\"STEPModel\\\" in component:\\n rel_path_from_results = os.path.join(self.cur_8digit_dir, component[\\\"STEPModel\\\"])\\n if os.path.exists(rel_path_from_results):\\n self.files_for_export.append(os.path.join('results', rel_path_from_results))\\n\\n # Since this is a PrepareForIFAB folder, gather all *.stp files in ./AP203_E2_SEPERATE_PART_FILES/\\n path_to_stp_files = os.path.join(self.cur_8digit_dir,'AP203_E2_SEPERATE_PART_FILES')\\n filter_for_stp_files = os.path.join(path_to_stp_files,'*.stp')\\n stp_files = glob(filter_for_stp_files)\\n for stp_file in stp_files:\\n self.files_for_export.append(os.path.join('results',stp_file))\\n\\n # If there's a TDP tag, \\n # add the referred file,\\n\\t# then crawl that file and gather its file references\\n if \\\"TDP\\\" in man_manifest:\\n tdp_json_path = os.path.join(self.cur_8digit_dir,man_manifest[\\\"TDP\\\"])\\n self.tdp_json(tdp_json_path)\\n self.files_for_export.append(os.path.join('results', tdp_json_path))\",\n \"def build():\\n for root, dirs, files in os.walk(IN_PATH):\\n for filename in files:\\n if filename.endswith('.csv'):\\n with open(os.path.join(IN_PATH, filename), encoding='utf-8') as f:\\n reader = csv.reader(f)\\n next(reader)\\n data = nested_dict()\\n web_data = nested_dict()\\n for row in reader:\\n if row[0].startswith('report.') or row[0].startswith('cardset.'):\\n d = data\\n elif row[0].startswith('web.'):\\n d = web_data\\n path = row[0].split('.')\\n for i in range(len(path)):\\n if i == len(path) - 1:\\n d[path[i]] = row[1]\\n else:\\n d = d[path[i]]\\n with open (os.path.join(OUT_PATH, filename.replace('.csv', '.json')), 'w', encoding='utf-8') as fout:\\n json.dump({**data, **web_data}, fout)\\n with open (os.path.join(WEB_PATH, filename.replace('.csv', '.js')), 'w', encoding='utf-8') as fout:\\n fout.write('var STRINGS = {};'.format(json.dumps(web_data)))\\n\\n with open(os.path.join(IN_PATH, 'en_US.csv'), encoding='utf-8') as f:\\n reader = csv.reader(f)\\n next(reader)\\n data = nested_dict()\\n web_data = nested_dict()\\n for row in reader:\\n path = row[0].split('.')\\n if row[0].startswith('report.') or row[0].startswith('cardset.'):\\n d = data\\n elif row[0].startswith('web.'):\\n d = web_data\\n\\n for i in range(len(path)):\\n if i == len(path) - 1:\\n d[path[i]] = zz_string(row[1], row[0])\\n else:\\n d = d[path[i]]\\n with open(os.path.join(OUT_PATH, 'zz_ZZ.json'), 'w', encoding='utf-8') as fout:\\n json.dump({**data, **web_data}, fout)\\n with open(os.path.join(WEB_PATH, 'zz_ZZ.js'), 'w', encoding='utf-8') as fout:\\n fout.write('var STRINGS = {};'.format(json.dumps(web_data)))\",\n \"def load_templates(fwhm=400, line_complexes=True, stars=False,\\n full_line_list=None, continuum_list=None,\\n fsps_templates=False, alf_template=False):\\n \\n if stars:\\n # templates = glob.glob('%s/templates/Pickles_stars/ext/*dat' %(os.getenv('GRIZLI')))\\n # templates = []\\n # for t in 'obafgkmrw':\\n # templates.extend( glob.glob('%s/templates/Pickles_stars/ext/uk%s*dat' %(os.getenv('THREEDHST'), t)))\\n # templates.extend(glob.glob('%s/templates/SPEX/spex-prism-M*txt' %(os.getenv('THREEDHST'))))\\n # templates.extend(glob.glob('%s/templates/SPEX/spex-prism-[LT]*txt' %(os.getenv('THREEDHST'))))\\n # \\n # #templates = glob.glob('/Users/brammer/Downloads/templates/spex*txt')\\n # templates = glob.glob('bpgs/*ascii')\\n # info = catIO.Table('bpgs/bpgs.info')\\n # type = np.array([t[:2] for t in info['type']])\\n # templates = []\\n # for t in 'OBAFGKM':\\n # test = type == '-%s' %(t)\\n # so = np.argsort(info['type'][test])\\n # templates.extend(info['file'][test][so])\\n # \\n # temp_list = OrderedDict()\\n # for temp in templates:\\n # #data = np.loadtxt('bpgs/'+temp, unpack=True)\\n # data = np.loadtxt(temp, unpack=True)\\n # #data[0] *= 1.e4 # spex\\n # scl = np.interp(5500., data[0], data[1])\\n # name = os.path.basename(temp)\\n # #ix = info['file'] == temp\\n # #name='%5s %s' %(info['type'][ix][0][1:], temp.split('.as')[0])\\n # print(name)\\n # temp_list[name] = utils.SpectrumTemplate(wave=data[0],\\n # flux=data[1]/scl)\\n \\n # np.save('stars_bpgs.npy', [temp_list])\\n \\n \\n # tall = np.load(os.path.join(os.getenv('GRIZLI'), \\n # 'templates/stars.npy'))[0]\\n # \\n # return tall\\n # \\n # temp_list = OrderedDict()\\n # for k in tall:\\n # if k.startswith('uk'):\\n # temp_list[k] = tall[k]\\n # \\n # return temp_list\\n # \\n # for t in 'MLT':\\n # for k in tall:\\n # if k.startswith('spex-prism-'+t):\\n # temp_list[k] = tall[k]\\n # \\n # return temp_list\\n \\n #return temp_list\\n templates = ['M6.5.txt', 'M8.0.txt', 'L1.0.txt', 'L3.5.txt', 'L6.0.txt', 'T2.0.txt', 'T6.0.txt', 'T7.5.txt']\\n templates = ['stars/'+t for t in templates]\\n else:\\n ## Intermediate and very old\\n # templates = ['templates/EAZY_v1.0_lines/eazy_v1.0_sed3_nolines.dat', \\n # 'templates/cvd12_t11_solar_Chabrier.extend.skip10.dat'] \\n templates = ['eazy_intermediate.dat', \\n 'cvd12_t11_solar_Chabrier.dat']\\n \\n ## Post starburst\\n #templates.append('templates/UltraVISTA/eazy_v1.1_sed9.dat')\\n templates.append('post_starburst.dat')\\n \\n ## Very blue continuum\\n #templates.append('templates/YoungSB/erb2010_continuum.dat')\\n templates.append('erb2010_continuum.dat')\\n \\n ### Test new templates\\n # templates = ['templates/erb2010_continuum.dat',\\n # 'templates/fsps/tweak_fsps_temp_kc13_12_006.dat',\\n # 'templates/fsps/tweak_fsps_temp_kc13_12_008.dat']\\n \\n if fsps_templates:\\n #templates = ['templates/fsps/tweak_fsps_temp_kc13_12_0{0:02d}.dat'.format(i+1) for i in range(12)]\\n templates = ['fsps/fsps_QSF_12_v3_nolines_0{0:02d}.dat'.format(i+1) for i in range(12)]\\n #templates = ['fsps/fsps_QSF_7_v3_nolines_0{0:02d}.dat'.format(i+1) for i in range(7)]\\n \\n \\n if alf_template:\\n templates.append('alf_SSP.dat')\\n \\n if continuum_list is not None:\\n templates = continuum_list\\n \\n temp_list = OrderedDict()\\n for temp in templates:\\n data = np.loadtxt(os.path.join(os.getenv('GRIZLI'), 'templates', temp), unpack=True)\\n #scl = np.interp(5500., data[0], data[1])\\n scl = 1.\\n name = temp #os.path.basename(temp)\\n temp_list[name] = SpectrumTemplate(wave=data[0], flux=data[1]/scl,\\n name=name)\\n \\n temp_list[name].name = name\\n \\n if stars:\\n return temp_list\\n \\n ### Emission lines:\\n line_wavelengths, line_ratios = get_line_wavelengths()\\n \\n if line_complexes:\\n #line_list = ['Ha+SII', 'OIII+Hb+Ha', 'OII']\\n #line_list = ['Ha+SII', 'OIII+Hb', 'OII']\\n line_list = ['Ha+NII+SII+SIII+He', 'OIII+Hb', 'OII+Ne', 'Lya+CIV']\\n else:\\n if full_line_list is None:\\n line_list = DEFAULT_LINE_LIST\\n else:\\n line_list = full_line_list\\n \\n #line_list = ['Ha', 'SII']\\n \\n # Use FSPS grid for lines\\n wave_grid = None\\n # if fsps_templates:\\n # wave_grid = data[0]\\n # else:\\n # wave_grid = None \\n \\n for li in line_list:\\n scl = line_ratios[li]/np.sum(line_ratios[li])\\n for i in range(len(scl)):\\n line_i = SpectrumTemplate(wave=wave_grid, \\n central_wave=line_wavelengths[li][i], \\n flux=None, fwhm=fwhm, velocity=True)\\n \\n if i == 0:\\n line_temp = line_i*scl[i]\\n else:\\n line_temp = line_temp + line_i*scl[i]\\n \\n name = 'line {0}'.format(li)\\n line_temp.name = name\\n temp_list[name] = line_temp\\n \\n return temp_list\",\n \"def main(args=None):\\n if args is None:\\n parser = create_parser()\\n args = parser.parse_args()\\n\\n if args.debug:\\n logging.basicConfig(level=logging.DEBUG)\\n else:\\n logging.basicConfig(level=logging.INFO)\\n\\n input_module = input_mapping[args.input_reader]\\n output_module = output_mapping[args.output_format]\\n\\n templates = []\\n # Load templates from external folder if set.\\n if args.template_folder:\\n templates += read_templates(os.path.abspath(args.template_folder))\\n\\n # Load internal templates, if not disabled.\\n if not args.exclude_built_in_templates:\\n templates += read_templates()\\n output = []\\n for f in args.input_files:\\n res = extract_data(f.name, templates=templates, input_module=input_module)\\n if res:\\n logger.info(res)\\n output.append(res)\\n if args.copy:\\n filename = args.filename.format(\\n date=res['date'].strftime('%Y-%m-%d'),\\n invoice_number=res['invoice_number'],\\n desc=res['desc'],\\n )\\n shutil.copyfile(f.name, join(args.copy, filename))\\n if args.move:\\n filename = args.filename.format(\\n date=res['date'].strftime('%Y-%m-%d'),\\n invoice_number=res['invoice_number'],\\n desc=res['desc'],\\n )\\n shutil.move(f.name, join(args.move, filename))\\n f.close()\\n\\n if output_module is not None:\\n output_module.write_to_file(output, args.output_name, args.output_date_format)\",\n \"def test_format_map():\\n template_filelist = listdir(RTEMPLATE_PATH)\\n\\n R_files = []\\n json_files = []\\n for file in template_filelist:\\n if '.r' in file:\\n file = file.replace('.r', '')\\n R_files.append(file)\\n elif '.json' in file:\\n file = file.replace('.json', '')\\n json_files.append(file)\\n\\n\\n for template in R_files:\\n template_filepath = path.join(RTEMPLATE_PATH, template + '.r')\\n metadata_filepath = path.join(RTEMPLATE_PATH, template + '.json')\\n\\n with open(template_filepath, 'r') as t_fp:\\n r_text = t_fp.read()\\n\\n try:\\n with open(metadata_filepath, 'r') as m_fp:\\n metadata = json.load(m_fp)\\n except Exception as err:\\n print(metadata_filepath)\\n raise err\\n\\n format_dict = {}\\n for key in metadata['required_args']:\\n format_dict[key] = 'TEST'\\n\\n ## Actual test: apply `format_map` to r_text#\\n try:\\n r_text = r_text.format_map(format_dict)\\n except Exception as err:\\n print(template_filepath)\\n raise err\",\n \"def parse(root_path, output_path, batch_file_paths):\\n for file_path in batch_file_paths:\\n d, f = split_path(file_path, root_path)\\n print(time.ctime(), \\\"d =\\\", d, \\\"; f =\\\", f)\\n if not os.path.exists(os.path.join(OUTPUT_PATH, d)):\\n os.makedirs(os.path.join(OUTPUT_PATH, d))\\n parsed_files = get_parsed_files(output_path, d)\\n if f not in parsed_files:\\n with open(file_path) as json_file:\\n OUTPUT_FILE_PATH = os.path.join(OUTPUT_PATH, d, f)\\n with open(OUTPUT_FILE_PATH, 'w') as writer:\\n for num, line in enumerate(json_file):\\n json_data = json.loads(line)\\n title = json_data['title']\\n if json_data['text']:\\n definition = json_data['text'][0]['line']\\n writer.write(f'{title}\\\\t{definition}\\\\n')\\n else:\\n writer.write(f'{title}\\\\tNone.\\\\n')\",\n \"def main(json_input, output_folder):\\n with open(json_input, 'r') as f:\\n data = json.loads(f.read())['data']\\n\\n with open(path.join(output_folder, 'qgeneration.context.txt'), 'w') as context_f, \\\\\\n open(path.join(output_folder, 'qgeneration.context.nojson.txt'), 'w') as context_f_nojson, \\\\\\n open(path.join(output_folder, 'qgeneration.gold.txt'), 'w') as question_f:\\n for item in data:\\n context_f.write(json.dumps(item['context']) + '\\\\n')\\n context_f_nojson.write(item['context'][:1000] + '\\\\n')\\n question_f.write(json.dumps(item['answer']) + '\\\\n')\\n\\n print('DONE')\",\n \"def generate_files(self, output_dir: str) -> None:\\n full_filename = os.path.join(output_dir, self.json_file)\\n with open(full_filename, 'w', encoding='utf-8') as output_file:\\n json.dump(self.zidb, output_file, indent=2)\\n print(file=output_file) # add terminating newline\\n logging.info(\\\"Created %s\\\", full_filename)\",\n \"def create_dicts(self):\\n \\n # remove this string from filename to make output file names more manageable\\n pre_output1 = self.file1.replace(\\\"_Guys121919_CGH_1100_Jul11\\\", '')\\n pre_output2 = self.file2.replace(\\\"_Guys121919_CGH_1100_Jul11\\\", '')\\n \\n # Build the output file name.\\n # if prefix is present add it\\n if self.out_file_prefix is not None:\\n # concatenate prefix, filenames and dyes into output filename file1_file1_dye_file2_file2_dye.txt\\n self.outputfilename = self.out_file_prefix+pre_output1.replace(\\\".txt\\\", '') + \\\"_\\\" + self.file1_dye + \\\"_\\\" + pre_output2.replace(\\\".txt\\\", '') + \\\"_\\\" + self.file2_dye + \\\".txt\\\"\\n # if no prefix don't add it!\\n else:\\n # concatenate filenames and dyes into output filename file1_file1_dye_file2_file2_dye.txt\\n self.outputfilename = pre_output1.replace(\\\".txt\\\", '') + \\\"_\\\" + self.file1_dye + \\\"_\\\" + pre_output2.replace(\\\".txt\\\", '') + \\\"_\\\" + self.file2_dye + \\\".txt\\\"\\n\\n # add temp to end of file name to create a temporary output filename\\n self.tempoutputfilename = self.outputfilename.replace(\\\".txt\\\", '') + \\\"temp.txt\\\"\\n\\n # open temp output file\\n self.tempoutputfile = open(self.outputfolder + self.tempoutputfilename, 'w')\\n\\n \\n # open FE files\\n file1_open = open(self.chosenfolder + self.file1, 'r')\\n file2_open = open(self.chosenfolder + self.file2, 'r')\\n\\n # open file1 and create a dict of the features.\\n for linenumber, line in enumerate(file1_open):\\n if linenumber >= 10:\\n splitline = line.split('\\\\t')\\n self.file1_dict[int(splitline[1])] = line\\n # get n of rows in file1 (take the linenumber of the last line)\\n self.file1_len = linenumber\\n\\n # repeat for features in second file but first writing the feparam and stats to temp file - when pairing with control this ensures the \\\"header\\\" comes from the test (file2) not control (file1), NB NEITHER ARE ACCURATE!!!!\\n for linenumber, line in enumerate(file2_open):\\n if linenumber < 10:\\n self.tempoutputfile.write(line)\\n # then add all features to a dictionary, with the unique feature number as a key\\n if linenumber >= 10:\\n splitline = line.split('\\\\t')\\n self.file2_dict[int(splitline[1])] = line\\n # get n of rows in file2\\n self.file2_len = linenumber\\n\\n # close files\\n file1_open.close()\\n file2_open.close()\",\n \"def test_pnictogen():\\n for template in templates:\\n template_prefix, extension = os.path.splitext(template)\\n for xyz_file in example_xyz_files:\\n input_prefix, xyz_file_extension = os.path.splitext(xyz_file)\\n\\n mol = Atoms(\\n cclib.bridge.cclib2openbabel.readfile(xyz_file, xyz_file_extension[1:])\\n )\\n written_files = pnictogen(mol, input_prefix, template, extension[1:])\\n\\n assert_equals(type(written_files), list)\\n for written_file in written_files:\\n assert_equals(type(written_file), str)\\n\\n written_files2 = pnictogen(mol, input_prefix, template)\\n assert_equals(written_files, written_files2)\\n\\n # Allow use of template in the parent directory\\n with cd(\\\"pnictogen/repo\\\"):\\n mol = Atoms(\\n cclib.bridge.cclib2openbabel.readfile(\\\"../../data/water-dimer.xyz\\\", \\\"xyz\\\")\\n )\\n written_files = pnictogen(mol, \\\"../../data/water-dimer\\\", \\\"ADF.in\\\", \\\"in\\\")\\n\\n assert_equals(written_files, [\\\"../../data/water-dimer.in\\\"])\\n\\n main([\\\"-g\\\", \\\"/tmp/hello.world.ORCA.inp\\\"])\\n mol = Atoms(cclib.bridge.cclib2openbabel.readfile(\\\"data/co.xyz\\\", \\\"xyz\\\"))\\n written_files = pnictogen(mol, \\\"data/co\\\", \\\"/tmp/hello.world.ORCA.inp\\\", foo=\\\"bar\\\")\\n\\n assert_equals(written_files, [\\\"data/co.inp\\\"])\",\n \"def _make_files(self):\\n if not self.path.is_dir():\\n raise FileNotFoundError(f\\\"Path {self.path} does not exist.\\\")\\n\\n # Make the filepaths\\n self.file_points = self.path / \\\"point.dat\\\"\\n self.file_lines = self.path / \\\"line.dat\\\"\\n self.file_cadastre = self.path / \\\"cadastre.dat\\\"\\n self.file_portals = self.path / \\\"portals.dat\\\"\\n\\n with open(self.file_points, \\\"w\\\") as f:\\n # 2 lines ignored\\n header = datetime.datetime.now().strftime(\\\"Generated: %d/%m/%Y %H:%M\\\\n\\\")\\n f.write(header)\\n self.points_dfs = []\\n with open(self.file_lines, \\\"w\\\") as f:\\n # 5 lines ignored\\n header = (\\n datetime.datetime.now().strftime(\\\"Generated: %d/%m/%Y %H:%M\\\\n\\\")\\n + 3 * \\\"Generated: \\\\n\\\"\\n + \\\"Name,Section,source_group,x1,y1,z1,x2,y2,z2,width,vert. ext.,-,-,\\\"\\n \\\"emission_rate[kg/h/km],-,-,-,-\\\\n\\\"\\n )\\n f.write(header)\\n with open(self.file_cadastre, \\\"w\\\") as f:\\n # 1 line ignored\\n header = \\\"x,y,z,dx,dy,dz,emission_rate[kg/h],-,-,-,source_group\\\\n\\\"\\n f.write(header)\\n with open(self.file_portals, \\\"w\\\") as f:\\n # 2 lines ignored\\n header = (\\n datetime.datetime.now().strftime(\\\"Generated: %d/%m/%Y %H:%M\\\\n\\\")\\n + \\\"x1,y1,x2,y2,z0,z1,emission_rate[kg/h],-,-,-,source_group\\\\n\\\"\\n )\\n f.write(header)\\n\\n\\n # File to save the source groups values\\n self.file_source_groups = self.path / \\\"source_groups.json\\\"\\n with open(self.file_source_groups, \\\"w\\\") as f:\\n # reverse the dict (items become keys and vice versa)\\n reversed_source_groups = {v: k for k, v in self.source_groups.items()}\\n json.dump(reversed_source_groups, f, indent=2)\",\n \"def create_template(api_url, project_id, username, token, update_flag,\\n validation_messages, json_files, content_files, scope, csv_flag, input_list):\\n try:\\n # template loader log folder exists check\\n log_path = '/opt/core/cache/tmp/templateloader_logs/'\\n if not os.path.exists(log_path):\\n os.makedirs(log_path)\\n timestamp = datetime.datetime.fromtimestamp(\\n time.time()).strftime('%Y%m%d%H%M%S')\\n log_filename = 'templateloader_' + timestamp\\n my_file = open(log_path + log_filename, \\\"a\\\")\\n\\n # Print and write the log messages\\n for message in validation_messages:\\n my_file.write(\\\"%s\\\\n\\\" % message)\\n\\n success_templates = 0\\n\\n for metadata, content in zip(json_files, content_files):\\n # Metadata Read\\n json_file = open(metadata, 'r')\\n file_name = list(metadata.split(\\\"/\\\"))\\n file_name = file_name[-1]\\n req_body = json.dumps(json_file.read()).encode('utf-8')\\n req_body = json.loads(req_body)\\n json_file.close()\\n\\n req_body = json.loads(req_body)\\n\\n if csv_flag:\\n if input_list and req_body.get(\\\"name\\\") not in input_list:\\n continue\\n # Content Read\\n if os.path.isfile(content):\\n content_datafile = open(content, 'r')\\n content_value = json.dumps(content_datafile.read()).encode('utf-8')\\n content_value = json.loads(content_value)\\n content_datafile.close()\\n req_body[\\\"content_files\\\"] = dict(content=dict(content=content_value, name=content.split('/')[-1]))\\n else:\\n req_body[\\\"content_files\\\"] = get_content_files(content)\\n # Checks for files\\n files_directory = os.path.abspath(\\n os.path.join(content, os.pardir)) + \\\"/files\\\"\\n if os.path.exists(files_directory):\\n dependencies = list()\\n for script_file_path in find_files(files_directory, '*'):\\n script_file_name = os.path.basename(script_file_path)\\n script_file_obj = open(script_file_path, 'r')\\n script_file_value = script_file_obj.read()\\n script_file_obj.close()\\n dependencies.append({\\\"content\\\": script_file_value, \\\"name\\\": script_file_name})\\n req_body[\\\"content_files\\\"][\\\"files\\\"] = dependencies\\n\\n dependencies_directory = os.path.abspath(os.path.join(content, 'modules'))\\n if os.path.exists(dependencies_directory):\\n dependencies = list()\\n for elem in os.listdir(dependencies_directory):\\n module_path = os.path.join(dependencies_directory, elem)\\n if not os.path.isdir(module_path):\\n continue\\n dependencies.append({\\\"type\\\": \\\"module\\\", \\\"name\\\": elem,\\n \\\"content_files\\\": get_content_files(module_path)})\\n if dependencies:\\n req_body['dependencies'] = dependencies\\n if scope != 'default':\\n req_body['scope'] = scope\\n\\n req_body = json.dumps(req_body).encode('utf-8')\\n\\n url = \\\"%s%s/%s\\\" % (api_url, project_id, 'templates')\\n http_client = httplib2.Http()\\n headers = {\\\"X-Auth-User\\\": username, \\\"X-Auth-Token\\\": token}\\n\\n # call the Create Template API\\n resp, content = http_client.request(\\n url, method=\\\"POST\\\", body=req_body, headers=headers)\\n content = json.loads(content)\\n\\n if resp[\\\"status\\\"] == \\\"200\\\":\\n success_templates += 1\\n log_msg = \\\"%s%s%s - %s\\\" % (file_name[:-5], \\\" ==> status:\\\",\\n content[\\\"status\\\"],\\n content[\\\"message\\\"])\\n sys.stdout.write(\\\"%s\\\\n\\\" % log_msg)\\n elif resp[\\\"status\\\"] == \\\"400\\\" and update_flag:\\n template_id = None\\n url = \\\"%s%s/%s\\\" % (api_url, project_id, 'templates')\\n list_resp, list_content = http_client.request(\\n url, method=\\\"GET\\\", headers=headers)\\n list_content = json.loads(list_content)\\n if list_resp[\\\"status\\\"] == \\\"200\\\":\\n template_list = list_content['data']['templates']\\n for template in template_list:\\n if template['name'] == json.loads(req_body)['name']:\\n # call the Update Template API\\n template_id = template[\\\"id\\\"]\\n url = \\\"%s%s/%s/%s\\\" % (api_url, project_id,\\n 'templates', template_id)\\n update_resp, update_content = \\\\\\n http_client.request(url, method=\\\"PUT\\\",\\n body=req_body,\\n headers=headers)\\n update_content = json.loads(update_content)\\n log_msg = \\\"%s%s%s - %s\\\" % (\\n file_name[:-5], \\\" ==> status:\\\",\\n update_content[\\\"status\\\"],\\n update_content[\\\"message\\\"])\\n sys.stdout.write(\\\"%s\\\\n\\\" % log_msg)\\n if update_resp[\\\"status\\\"] == \\\"200\\\":\\n success_templates += 1\\n break\\n if not template_id:\\n temp_url = \\\"%s%s/%s?is_temp=true\\\" % (api_url, project_id, 'templates')\\n list_temp_resp, list_temp_content = http_client.request(\\n temp_url, method=\\\"GET\\\", headers=headers)\\n list_temp_content = json.loads(list_temp_content)\\n if list_temp_resp[\\\"status\\\"] == \\\"200\\\":\\n temp_template_list = list_temp_content['data']['templates']\\n for template in temp_template_list:\\n if template['name'] == json.loads(req_body)['name']:\\n # call the Update Template API\\n template_id = template[\\\"id\\\"]\\n url = \\\"%s%s/%s/%s\\\" % (api_url, project_id,\\n 'templates', template_id)\\n update_resp, update_content = \\\\\\n http_client.request(url, method=\\\"PUT\\\",\\n body=req_body,\\n headers=headers)\\n update_content = json.loads(update_content)\\n log_msg = \\\"%s%s%s - %s\\\" % (\\n file_name[:-5], \\\" ==> status:\\\",\\n update_content[\\\"status\\\"],\\n update_content[\\\"message\\\"])\\n sys.stdout.write(\\\"%s\\\\n\\\" % log_msg)\\n if update_resp[\\\"status\\\"] == \\\"200\\\":\\n success_templates += 1\\n break\\n if not template_id:\\n log_msg = \\\"%s%s%s - %s\\\" % (file_name[:-5], \\\" ==> status:\\\",\\n content[\\\"status\\\"],\\n content[\\\"message\\\"])\\n sys.stderr.write(\\\"%s\\\\n\\\" % log_msg)\\n my_file.write(\\\"%s\\\\n\\\" % log_msg)\\n else:\\n log_msg = \\\"%s%s%s - %s\\\" % (file_name[:-5], \\\" ==> status:\\\",\\n content[\\\"status\\\"],\\n content[\\\"message\\\"])\\n sys.stderr.write(\\\"%s\\\\n\\\" % log_msg)\\n my_file.write(\\\"%s\\\\n\\\" % log_msg)\\n if not csv_flag:\\n total_templates = len(json_files)\\n failed_templates = total_templates - success_templates\\n else:\\n total_templates = len(input_list)\\n failed_templates = total_templates - success_templates\\n sys.stdout.write('Total templates: ' + str(total_templates) + \\\"\\\\n\\\")\\n sys.stdout.write(\\\"Success Templates: \\\" + str(success_templates) + \\\"\\\\n\\\")\\n sys.stderr.write(\\\"Failed Templates: \\\" + str(failed_templates) + \\\"\\\\n\\\")\\n\\n my_file.write('Total templates: ' + str(total_templates) + \\\"\\\\n\\\")\\n my_file.write(\\\"Failed Templates: \\\" + str(failed_templates) + \\\"\\\\n\\\")\\n my_file.close()\\n\\n except Exception as e:\\n sys.stdout.write(e.message)\\n exit(1)\",\n \"def main(arguments):\\n\\n # The input file can be optionally encoded with gzip format:\\n input_file = arguments.input_file[0]\\n assert isinstance(input_file, str)\\n if input_file.endswith(\\\".gz\\\"):\\n _open = gzip.open\\n else:\\n _open = open\\n with _open(input_file, \\\"rt\\\",\\n encoding='utf-8') as fd:\\n print(\\\"Loading JSON content into memory....\\\")\\n raw = json.load(fd) # Parses all the input file.\\n\\n # Also the output file can be optionally encoded with gzip format:\\n output_file = arguments.output_file[0]\\n assert isinstance(output_file, str)\\n uuid = 0\\n if output_file.endswith(\\\".gz\\\"):\\n _open = gzip.open\\n else:\\n _open = open\\n with _open(output_file, \\\"wt\\\",\\n encoding='utf-8') as fd:\\n # for each element extracted from the input\\n print(\\\"Generating distilled file\\\")\\n for item in load_input(raw):\\n uuid += 1 # generates incremental uuid from 1\\n item['uuid'] = uuid\\n fd.write(json.dumps(item,\\n sort_keys=True))\\n fd.write(\\\"\\\\n\\\") # one encoded document per line\\n\\n print(\\\"{} documents imported\\\".format(uuid))\",\n \"def fix_jsons_in(bids_dir: Path):\\n\\n print(\\\"Finalizing task json files.\\\")\\n\\n for path in bids_dir.rglob(\\\"func/*_task-*.json\\\"):\\n append_to_json_file(key=\\\"TaskName\\\", value=task_name_of(path), path_to_json=path)\\n\\n print(\\\"Appending echo times to phase difference json files.\\\")\\n\\n for path in bids_dir.rglob(\\\"fmap/*_phasediff.json\\\"):\\n magnitude1_path = the_path_that_matches(pattern=\\\"sub-*_magnitude1.json\\\", in_directory=path.parent)\\n magnitude2_path = the_path_that_matches(pattern=\\\"sub-*_magnitude2.json\\\", in_directory=path.parent)\\n echo_time1 = value_of_key_in_json_file(\\\"EchoTime\\\", magnitude1_path)\\n echo_time2 = value_of_key_in_json_file(\\\"EchoTime\\\", magnitude2_path)\\n append_to_json_file(key=\\\"EchoTime1\\\", value=echo_time1, path_to_json=path)\\n append_to_json_file(key=\\\"EchoTime2\\\", value=echo_time2, path_to_json=path)\\n\\n print(\\\"Setting targets of fieldmap json files.\\\")\\n\\n for path in bids_dir.rglob(\\\"fmap/*.json\\\"):\\n func_dir = path.parent.parent / \\\"func\\\"\\n trimmed_func_paths = [\\\"func/\\\" + func_path.name for func_path in func_dir.glob(\\\"*.nii\\\")]\\n append_to_json_file(key=\\\"IntendedFor\\\", value=trimmed_func_paths, path_to_json=path)\",\n \"def generate_test_data(root: str) -> str:\\n size = (64, 64)\\n folder_path = os.path.join(root, \\\"enviroatlas_lotp\\\")\\n\\n if not os.path.exists(folder_path):\\n os.makedirs(folder_path)\\n\\n for prefix in tile_list:\\n for suffix, data_profile in layer_data_profiles.items():\\n img_path = os.path.join(folder_path, f\\\"{prefix}_{suffix}.tif\\\")\\n img_dir = os.path.dirname(img_path)\\n if not os.path.exists(img_dir):\\n os.makedirs(img_dir)\\n\\n data_profile[\\\"profile\\\"][\\\"height\\\"] = size[0]\\n data_profile[\\\"profile\\\"][\\\"width\\\"] = size[1]\\n data_profile[\\\"profile\\\"][\\\"transform\\\"] = Affine(\\n 1.0, 0.0, 608170.0, 0.0, -1.0, 3381430.0\\n )\\n\\n write_data(\\n img_path,\\n data_profile[\\\"profile\\\"],\\n data_profile[\\\"data_type\\\"],\\n data_profile[\\\"vals\\\"],\\n )\\n\\n # build the spatial index\\n schema = {\\n \\\"geometry\\\": \\\"Polygon\\\",\\n \\\"properties\\\": {\\n \\\"split\\\": \\\"str\\\",\\n \\\"naip\\\": \\\"str\\\",\\n \\\"nlcd\\\": \\\"str\\\",\\n \\\"roads\\\": \\\"str\\\",\\n \\\"water\\\": \\\"str\\\",\\n \\\"waterways\\\": \\\"str\\\",\\n \\\"waterbodies\\\": \\\"str\\\",\\n \\\"buildings\\\": \\\"str\\\",\\n \\\"lc\\\": \\\"str\\\",\\n \\\"prior_no_osm_no_buildings\\\": \\\"str\\\",\\n \\\"prior\\\": \\\"str\\\",\\n },\\n }\\n with fiona.open(\\n os.path.join(folder_path, \\\"spatial_index.geojson\\\"),\\n \\\"w\\\",\\n driver=\\\"GeoJSON\\\",\\n crs=\\\"EPSG:3857\\\",\\n schema=schema,\\n ) as dst:\\n for prefix in tile_list:\\n img_path = os.path.join(folder_path, f\\\"{prefix}_a_naip.tif\\\")\\n with rasterio.open(img_path) as f:\\n geom = shapely.geometry.mapping(shapely.geometry.box(*f.bounds))\\n geom = fiona.transform.transform_geom(\\n f.crs.to_string(), \\\"EPSG:3857\\\", geom\\n )\\n\\n row = {\\n \\\"geometry\\\": geom,\\n \\\"properties\\\": {\\n \\\"split\\\": prefix.split(\\\"/\\\")[0].replace(\\\"_tiles-debuffered\\\", \\\"\\\")\\n },\\n }\\n for suffix, data_profile in layer_data_profiles.items():\\n key = suffix_to_key_map[suffix]\\n row[\\\"properties\\\"][key] = f\\\"{prefix}_{suffix}.tif\\\"\\n dst.write(row)\\n\\n # Create archive\\n archive_path = os.path.join(root, \\\"enviroatlas_lotp\\\")\\n shutil.make_archive(archive_path, \\\"zip\\\", root_dir=root, base_dir=\\\"enviroatlas_lotp\\\")\\n shutil.rmtree(folder_path)\\n md5: str = calculate_md5(archive_path + \\\".zip\\\")\\n return md5\",\n \"def generate_args(threshold):\\n # EUWATCH\\n return_periods = ['00005', '00025', '00050', '00100', '00250', '00500', '01000']\\n\\n for return_period in return_periods:\\n print(\\\"EUWATCH\\\", return_period, threshold)\\n yield {\\n 'infile': \\\"data/tanzania_flood/EUWATCH/inun_dynRout_RP_{}_Tanzania/inun_dynRout_RP_{}_contour_Tanzania.tif\\\".format(return_period, return_period),\\n 'tmpfile_1': \\\"data/tanzania_flood/EUWATCH_{}_mask-{}.tif\\\".format(return_period, threshold),\\n 'tmpfile_2': \\\"data/tanzania_flood/EUWATCH_{}_vector_mask-{}.shp\\\".format(return_period, threshold),\\n 'outfile': \\\"data/tanzania_flood/threshold_{}/EUWATCH_{}_mask-{}.shp\\\".format(threshold, return_period, threshold)\\n }\\n\\n # GLOFRIS models\\n models = ['GFDL-ESM2M', 'HadGEM2-ES', 'IPSL-CM5A-LR', 'MIROC-ESM-CHEM', 'NorESM1-M']\\n\\n for model in models:\\n for return_period in return_periods:\\n print(model, return_period, threshold)\\n yield {\\n 'infile': \\\"data/tanzania_flood/{}/rcp6p0/2030-2069/inun_dynRout_RP_{}_bias_corr_masked_Tanzania/inun_dynRout_RP_{}_bias_corr_contour_Tanzania.tif\\\".format(model, return_period, return_period),\\n 'tmpfile_1': \\\"data/tanzania_flood/{}_{}_mask-{}.tif\\\".format(model, return_period, threshold),\\n 'tmpfile_2': \\\"data/tanzania_flood/{}_{}_vector_mask-{}.shp\\\".format(model, return_period, threshold),\\n 'outfile': \\\"data/tanzania_flood/threshold_{}/{}_{}_mask-{}.shp\\\".format(threshold, model, return_period, threshold)\\n }\\n\\n # Convert SSBN models\\n ssbn_return_periods=['5', '10', '20', '50', '75', '100', '200', '250', '500', '1000']\\n ssbnmodels = {\\n \\\"TZ_fluvial_undefended\\\": \\\"FU\\\",\\n \\\"TZ_pluvial_undefended\\\": \\\"PU\\\"\\n }\\n\\n for model, abbr in ssbnmodels.items():\\n for return_period in ssbn_return_periods:\\n print(\\\"SSBN\\\", abbr, return_period, threshold)\\n yield {\\n 'infile': \\\"data/tanzania_flood/SSBN_flood_data/{}/TZ-{}-{}-1.tif\\\".format(model, abbr, return_period),\\n 'tmpfile_1': \\\"data/tanzania_flood/SSBN_{}_{}_mask-{}.tif\\\".format(abbr, return_period, threshold),\\n 'tmpfile_2': \\\"data/tanzania_flood/SSBN_{}_{}_vector_mask-{}.shp\\\".format(abbr, return_period, threshold),\\n 'outfile': \\\"data/tanzania_flood/threshold_{}/SSBN_{}_{}_mask-{}.shp\\\".format(threshold, abbr, return_period, threshold)\\n }\",\n \"def generate_output(results, version, template):\\n # FIXME: This code is highly coupled with actual scans and may not\\n # support adding new scans at all\\n\\n from licensedcode.cache import get_licenses_db\\n\\n converted = {}\\n converted_infos = {}\\n converted_packages = {}\\n licenses = {}\\n\\n LICENSES = 'licenses'\\n COPYRIGHTS = 'copyrights'\\n PACKAGES = 'packages'\\n URLS = 'urls'\\n EMAILS = 'emails'\\n\\n # Create a flattened data dict keyed by path\\n for scanned_file in results:\\n scanned_file = dict(scanned_file)\\n path = scanned_file['path']\\n results = []\\n if COPYRIGHTS in scanned_file:\\n for entry in scanned_file[COPYRIGHTS]:\\n results.append({\\n 'start': entry['start_line'],\\n 'end': entry['end_line'],\\n 'what': 'copyright',\\n 'value': entry['value'],\\n })\\n if LICENSES in scanned_file:\\n for entry in scanned_file[LICENSES]:\\n # make copy\\n entry = dict(entry)\\n entry_key = entry['key']\\n results.append({\\n 'start': entry['start_line'],\\n 'end': entry['end_line'],\\n 'what': 'license',\\n 'value': entry_key,\\n })\\n\\n # FIXME: we should NOT rely on license objects: only use what is in the JSON instead\\n if entry_key not in licenses:\\n licenses[entry_key] = entry\\n # we were modifying the scan data in place ....\\n entry['object'] = get_licenses_db().get(entry_key)\\n if results:\\n converted[path] = sorted(results, key=itemgetter('start'))\\n\\n # TODO: this is klunky: we need to drop templates entirely or we\\n # should rather just pass a the list of files from the scan\\n # results and let the template handle this rather than\\n # denormalizing the list here??\\n converted_infos[path] = {}\\n for name, value in scanned_file.items():\\n if name in (LICENSES, PACKAGES, COPYRIGHTS, EMAILS, URLS):\\n continue\\n converted_infos[path][name] = value\\n\\n if PACKAGES in scanned_file:\\n converted_packages[path] = scanned_file[PACKAGES]\\n\\n licenses = dict(sorted(licenses.items()))\\n\\n files = {\\n 'license_copyright': converted,\\n 'infos': converted_infos,\\n 'packages': converted_packages\\n }\\n\\n return template.generate(files=files, licenses=licenses, version=version)\",\n \"def generate_tools_list():\\n out = {}\\n\\n # Set BETYDB_LOCAL_CACHE_FOLDER = /tools directory\\n print(\\\"Dumping BETY experiments file into \\\"+os.environ.get('BETYDB_LOCAL_CACHE_FOLDER', \\\"/home/extractor/\\\"))\\n #dump_experiments()\\n\\n toollist = [\\n \\\"bin2tif.py\\\",\\n \\\"nrmac.py\\\",\\n \\\"canopyCover.py\\\",\\n \\\"fieldmosaic.py\\\",\\n \\\"submit_clowder.py\\\",\\n \\\"submit_bety.py\\\",\\n \\\"submit_geo.py\\\",\\n \\\"bety_experiments.json\\\"\\n ]\\n\\n print(\\\"Including /tools directory files\\\")\\n for t in toollist:\\n #tool_daxf = create_daxf(t, os.path.join(\\\"tests/workflow/workflow-pilot/workflow_terra/tools\\\", t))\\n tool_daxf = create_daxf(t, os.path.join(os.getcwd(), \\\"tools\\\", t))\\n # Use filename as dict key in case we need it as input later\\n out[t] = tool_daxf\\n\\n sensor_metadata_list = [\\n \\\"ua-mac/sensor-metadata/sensors/stereo/sensor_fixed_metadata.json\\\",\\n \\\"ua-mac/sensor-metadata/sensors/flirIrCamera/sensor_fixed_metadata.json\\\",\\n \\\"ua-mac/sensor-metadata/sensors/scanner3D/sensor_fixed_metadata.json\\\",\\n \\\"ua-mac/sensor-metadata/sensors/VNIR/sensor_fixed_metadata.json\\\",\\n \\\"ua-mac/sensor-metadata/sensors/scanalyzer/sensor_fixed_metadata.json\\\"\\n ]\\n print(\\\"Including sensor fixed metadata\\\")\\n for s in sensor_metadata_list:\\n sensor_metadata_daxf = create_daxf(s, os.path.join(sites_dir, s))\\n # Use '$SENSOR_fixed' as dict key in case we need it as input later\\n out[s.split(\\\"/\\\")[-2]+\\\"_fixed\\\"] = sensor_metadata_daxf\\n\\n return out\",\n \"def generate_final_data(model_names):\\n\\n for model_name in model_names:\\n print(\\\"Creating fina data for \\\" + model_name[0])\\n\\n final_data = {}\\n brush_data = common.load_json(\\\"../steps/\\\" + model_name[0] + \\\"/brush_data.json\\\")\\n diff_data = common.load_json(\\\"../steps/\\\" + model_name[0] + \\\"/diff_plot_data.json\\\")\\n distance_data = common.load_json(\\\"../steps/\\\" + model_name[0] + \\\"/distance_data.json\\\")\\n\\n final_data[0] = {\\n \\\"step_number\\\" : 0,\\n \\\"valid\\\" : brush_data['0'][\\\"valid\\\"],\\n \\\"brush_data\\\" : sanitize_brush_data(brush_data['0']),\\n \\\"diff_data\\\" : null_diff_data(),\\n \\\"distance_data\\\" : null_distance_data()\\n }\\n\\n for step_idx in range(1, len(brush_data)):\\n print(str(step_idx) + \\\" \\\",)\\n final_data[step_idx] = {}\\n final_data[step_idx][\\\"step_number\\\"] = step_idx\\n final_data[step_idx][\\\"valid\\\"] = brush_data[str(step_idx)][\\\"valid\\\"]\\n final_data[step_idx][\\\"brush_data\\\"] = sanitize_brush_data(brush_data[str(step_idx)])\\n final_data[step_idx][\\\"diff_data\\\"] = get_diff_data_step(diff_data, step_idx - 1)\\n final_data[step_idx][\\\"distance_data\\\"] = get_distance_data_step(distance_data, str(step_idx))\\n\\n common.save_json(final_data, \\\"../final_data/\\\" + model_name[0] + \\\"/final_data.json\\\", compressed=False)\",\n \"def process(sources, output, force):\\n logging.basicConfig(level=logging.INFO,\\n format='%(asctime)s [%(levelname)s] - %(message)s', datefmt=\\\"%H:%M:%S\\\")\\n\\n logging.getLogger('shapely.geos').setLevel(logging.WARNING)\\n logging.getLogger('Fiona').setLevel(logging.WARNING)\\n logging.getLogger('requests.packages.urllib3.connectionpool').setLevel(logging.WARNING)\\n requests.packages.urllib3.disable_warnings()\\n # logging.getLogger('processing').setLevel(logging.DEBUG)\\n\\n catalog_features = []\\n failures = []\\n path_parts_to_skip = utils.get_path_parts(sources).index(\\\"sources\\\") + 1\\n success = True\\n for path in utils.get_files(sources):\\n try:\\n logging.info(\\\"Processing \\\" + path)\\n pathparts = utils.get_path_parts(path)[path_parts_to_skip:]\\n pathparts[-1] = pathparts[-1].replace('.json', '.geojson')\\n\\n outdir = os.path.join(output, *pathparts[:-1], pathparts[-1].replace('.geojson', ''))\\n outfile = os.path.join(output, *pathparts)\\n\\n source = utils.read_json(path)\\n urlfile = urlparse(source['url']).path.split('/')[-1]\\n \\n if not hasattr(adapters, source['filetype']):\\n logging.error('Unknown filetype ' + source['filetype'])\\n failures.append(path)\\n continue\\n \\n read_existing = False\\n if os.path.isfile(outfile):\\n logging.info(\\\"Output file exists\\\")\\n if os.path.getmtime(outfile) > os.path.getmtime(path):\\n logging.info(\\\"Output file is up to date\\\")\\n if not force:\\n read_existing = True\\n logging.warning('Skipping ' + path + ' since generated file exists. Use --force to regenerate.') \\n else:\\n logging.info(\\\"Output is outdated, {} < {}\\\".format(\\n datetime.datetime.fromtimestamp(os.path.getmtime(outfile)),\\n datetime.datetime.fromtimestamp(os.path.getmtime(path))))\\n\\n if read_existing:\\n with open(outfile, \\\"rb\\\") as f:\\n geojson = json.load(f)\\n properties = geojson['properties']\\n else:\\n logging.info('Downloading ' + source['url'])\\n \\n try:\\n fp = utils.download(source['url'])\\n except IOError:\\n logging.error('Failed to download ' + source['url'])\\n failures.append(path)\\n continue\\n \\n logging.info('Reading ' + urlfile)\\n \\n if 'filter' in source:\\n filterer = BasicFilterer(source['filter'], source.get('filterOperator', 'and'))\\n else:\\n filterer = None\\n \\n try:\\n geojson = getattr(adapters, source['filetype'])\\\\\\n .read(fp, source['properties'],\\n filterer=filterer,\\n layer_name=source.get(\\\"layerName\\\", None),\\n source_filename=source.get(\\\"filenameInZip\\\", None))\\n except IOError as e:\\n logging.error('Failed to read ' + urlfile + \\\" \\\" + str(e))\\n failures.append(path)\\n continue\\n except zipfile.BadZipfile as e:\\n logging.error('Unable to open zip file ' + source['url'])\\n failures.append(path)\\n continue\\n finally:\\n os.remove(fp.name)\\n if(len(geojson['features'])) == 0:\\n logging.error(\\\"Result contained no features for \\\" + path)\\n continue\\n excluded_keys = ['filetype', 'url', 'properties', 'filter', 'filenameInZip']\\n properties = {k:v for k,v in list(source.items()) if k not in excluded_keys}\\n properties['source_url'] = source['url']\\n properties['feature_count'] = len(geojson['features'])\\n logging.info(\\\"Generating demo point\\\")\\n properties['demo'] = geoutils.get_demo_point(geojson)\\n \\n geojson['properties'] = properties\\n \\n utils.make_sure_path_exists(os.path.dirname(outfile))\\n\\n #cleanup existing generated files\\n if os.path.exists(outdir):\\n rmtree(outdir)\\n filename_to_match, ext = os.path.splitext(pathparts[-1])\\n output_file_dir = os.sep.join(utils.get_path_parts(outfile)[:-1])\\n logging.info(\\\"looking for generated files to delete in \\\" + output_file_dir)\\n for name in os.listdir(output_file_dir):\\n base, ext = os.path.splitext(name)\\n if base == filename_to_match:\\n to_remove = os.path.join(output_file_dir, name)\\n logging.info(\\\"Removing generated file \\\" + to_remove)\\n os.remove(to_remove)\\n\\n utils.write_json(outfile, geojson)\\n\\n logging.info(\\\"Generating label points\\\")\\n label_geojson = geoutils.get_label_points(geojson)\\n label_path = outfile.replace('.geojson', '.labels.geojson')\\n utils.write_json(label_path, label_geojson)\\n\\n logging.info('Done. Processed to ' + outfile)\\n \\n if not \\\"demo\\\" in properties:\\n properties['demo'] = geoutils.get_demo_point(geojson)\\n\\n properties['path'] = \\\"/\\\".join(pathparts)\\n catalog_entry = {\\n 'type': 'Feature',\\n 'properties': properties,\\n 'geometry': geoutils.get_union(geojson)\\n }\\n catalog_features.append(catalog_entry)\\n\\n if not os.path.exists(outdir) or not os.path.exists(os.path.join(outdir, \\\"units.json\\\")):\\n logging.info(\\\"Generated exploded GeoJSON to \\\" + outdir)\\n if not os.path.exists(outdir):\\n os.makedirs(outdir)\\n # .json instead of .geojson, incase there is a unit named \\\"source\\\"\\n utils.write_json(os.path.join(outdir, \\\"source.json\\\"), catalog_entry) \\n units = []\\n for feature in geojson['features']:\\n feature_id = str(feature['properties']['id'])\\n feature_id = feature_id.replace('/', '')\\n feature_filename = os.path.join(outdir, feature_id + \\\".geojson\\\")\\n utils.write_json(feature_filename, feature)\\n units.append(feature['properties'])\\n utils.write_json(os.path.join(outdir, \\\"units.json\\\"), units)\\n else:\\n logging.debug(\\\"exploded GeoJSON already exists, not generating\\\")\\n\\n except Exception as e:\\n logging.error(str(e))\\n logging.exception(\\\"Error processing file \\\" + path)\\n failures.append(path)\\n success = False\\n\\n catalog = {\\n 'type': 'FeatureCollection',\\n 'features': catalog_features\\n }\\n utils.write_json(os.path.join(output,'catalog.geojson'), catalog)\\n\\n if not success:\\n logging.error(\\\"Failed sources: \\\" + \\\", \\\".join(failures))\\n sys.exit(-1)\",\n \"def process_files_json():\\n # chdir into beep root\\n pwd = os.getcwd()\\n os.chdir(os.environ.get(\\\"BEEP_ROOT\\\", \\\"/\\\"))\\n\\n meta_list = list(filter(lambda x: '_Metadata.csv' in x, os.listdir(SRC_DIR)))\\n file_list = list(filter(lambda x: '.csv' in x if x not in meta_list else None, os.listdir(SRC_DIR)))\\n all_list = list(filter(lambda x: '.csv' in x, os.listdir(SRC_DIR)))\\n\\n all_list = sorted(all_list)\\n dumpfn(all_list, \\\"all_files.json\\\")\\n\\n [file_id, mapdf] = init_map(PROJECT_NAME, DEST_DIR)\\n\\n new_file_index = file_id\\n\\n for filename in tqdm(sorted(file_list)):\\n # If the file has already been renamed another entry should not be made\\n if mapdf['filename'].str.contains(filename).sum() > 0:\\n continue\\n old_file = os.path.join(SRC_DIR, filename)\\n new_path = os.path.join(DEST_DIR, PROJECT_NAME)\\n shutil.copy(old_file, new_path) # copy main data file\\n shutil.copy(old_file.replace(\\\".csv\\\", '_Metadata.csv'), new_path) # copy meta data file\\n\\n if PROJECT_NAME == 'FastCharge':\\n [date, channel_no, strname, protocol] = get_parameters_fastcharge(filename, SRC_DIR)\\n elif PROJECT_NAME == 'ClosedLoopOED':\\n [date, channel_no, strname, protocol] = get_parameters_oed(filename, SRC_DIR)\\n else:\\n raise ValueError(\\\"Unsupported PROJECT_NAME: {}\\\".format(PROJECT_NAME))\\n\\n df_dup = mapdf.set_index(['protocol', 'date'])\\n if (protocol, date) in df_dup.index:\\n row = mapdf[(mapdf['protocol'] == protocol) & (mapdf['date'] == date)]\\n file_id = row['fid'].iloc[0]\\n protocol = row['protocol'].iloc[0]\\n date = row['date'].iloc[0]\\n strname = row['strname'].iloc[0]\\n else:\\n file_id = new_file_index\\n new_file_index = new_file_index + 1\\n\\n new_name = \\\"{}_{}_{}\\\".format(PROJECT_NAME, f'{file_id:06}', channel_no)\\n new_file = os.path.join(DEST_DIR, PROJECT_NAME, \\\"{}.csv\\\".format(new_name))\\n\\n new_row = pd.DataFrame([[file_id, protocol, channel_no, date, strname,\\n os.path.abspath(old_file),\\n os.path.abspath(new_file)]],\\n columns=METADATA_COLUMN_NAMES)\\n mapdf = mapdf.append(new_row)\\n\\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename), new_file)\\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename).replace(\\\".csv\\\", \\\"_Metadata.csv\\\"),\\n new_file.replace(\\\".csv\\\", \\\"_Metadata.csv\\\"))\\n\\n mapdf.to_csv(os.path.join(DEST_DIR, PROJECT_NAME, PROJECT_NAME + \\\"map.csv\\\"), index=False)\\n mapdf = mapdf.reset_index(drop=True)\\n os.chdir(pwd)\\n return json.dumps(mapdf.to_dict(\\\"list\\\"))\",\n \"def _generate_objects_file(self):\\n xmls = glob(f'{ROOT}/Annotations/**/*.xml', recursive=True)\",\n \"def reconstitute():\\n with open(TEXT_FPATH, 'w') as txt:\\n for jfpath in json_fpaths():\\n with open(jfpath) as f:\\n jstruct = json.load(f)\\n\\n for recipe in jstruct.keys():\\n _reconstitute_recipe(txt, jstruct[recipe])\",\n \"def main():\\r\\n # handle arguments\\r\\n parser = argparse.ArgumentParser()\\r\\n\\r\\n parser.add_argument('-t', '--time', help = 'start time', default = \\\"2018-12-26 18:11:08.509654\\\")\\r\\n parser.add_argument('-bd', '--min_duration', type = int, help = 'minimum duration', default = 25)\\r\\n parser.add_argument('-td', '--max_duration', type = int, help = 'maximum duration', default = 70)\\r\\n parser.add_argument('-e', '--events', type = int, help = 'how many events to generate', default = 1000)\\r\\n\\r\\n args = parser.parse_args()\\r\\n\\r\\n f = open(f\\\"tests/test_1.json\\\", \\\"a\\\")\\r\\n\\r\\n string_time = \\\"2019-07-08 10:40:00.423123\\\"\\r\\n\\r\\n current_time = datetime.datetime.strptime(string_time, '%Y-%m-%d %H:%M:%S.%f')\\r\\n\\r\\n for i in range(0, args.events):\\r\\n\\r\\n duration = random.randint(args.min_duration, args.max_duration)\\r\\n\\r\\n json = \\\"{\\\\\\\"timestamp\\\\\\\": \\\\\\\"\\\" \\\\\\r\\n + str(current_time) \\\\\\r\\n + \\\"\\\\\\\", \\\\\\\"translation_id\\\\\\\": \\\\\\\"5aa5b2f39f7254a75aa5\\\\\\\", \\\" \\\\\\r\\n \\\"\\\\\\\"source_language\\\\\\\": \\\\\\\"en\\\\\\\",\\\\\\\"target_language\\\\\\\":\\\" \\\\\\r\\n \\\" \\\\\\\"fr\\\\\\\",\\\\\\\"client_name\\\\\\\": \\\\\\\"easyjet\\\\\\\",\\\\\\\"event_name\\\\\\\":\\\" \\\\\\r\\n \\\"\\\\\\\"translation_delivered\\\\\\\",\\\\\\\"nr_words\\\\\\\": 30, \\\\\\\"duration\\\\\\\": \\\"\\\\\\r\\n + str(duration) + \\\"}\\\\n\\\"\\r\\n\\r\\n f.write(json)\\r\\n\\r\\n minutes = random.randint(0, 59)\\r\\n seconds = random.randint(0, 59)\\r\\n\\r\\n current_time += datetime.timedelta(minutes=minutes, seconds=seconds)\\r\\n\\r\\n print(f\\\"New file is located at inputs/{args.events}.json\\\")\",\n \"def test_template_json():\\n for l in list(templates.data):\\n t = templates[l]\\n assert len(json.dumps(t.json())) > 0\",\n \"def main():\\n parser = argparse.ArgumentParser(description='Process input file and save to output file.')\\n\\n parser.add_argument('-i',\\n '--input',\\n help='Trip report file (txt file) to process.',\\n action='store')\\n\\n parser.add_argument('-o',\\n '--output',\\n help='Output file (json).',\\n action='store')\\n\\n if len(sys.argv) == 1:\\n parser.print_help()\\n sys.exit(1)\\n\\n args = parser.parse_args()\\n\\n if not args.input:\\n print('Please specify the trip report input text file.')\\n sys.exit(1)\\n\\n if args.output:\\n output_file = args.output\\n else:\\n output_file = OUTPUT_DEFAULT\\n print(f'No output file specified. Using the default: {OUTPUT_DEFAULT}')\\n\\n trip_list = [] # the list of trips(dictionaries) to output to the data file\\n trip_started = False\\n day_started = False\\n\\n with open(args.input, 'r') as fh:\\n\\n while True:\\n\\n line = fh.readline()\\n\\n if not line:\\n break\\n\\n if line.isspace():\\n continue\\n\\n if '________' in line:\\n continue\\n\\n if line.startswith('TRIP'): # detect start of a trip (anywhere from 1-5 days long)\\n # print('Start trip' + line)\\n\\n trip = Parser.trip_parser(line) # create a trip(dictionary)\\n trip['days'] = [] # adds a day list (a list of sectors(dictionaries)) to the trip list\\n\\n trip_started = True # sets trip started to true\\n continue\\n\\n # if new day has not started, create a new day\\n if trip_started and not day_started and Parser.new_day(line):\\n day = {'sign_on': line[43:48], 'day_sectors': []}\\n day_started = True # sets day started to true\\n\\n if trip_started and day_started:\\n if not Parser.end_day(line):\\n # print('During day: ' + line)\\n day['day_number'] = line[24:26].strip() # assign a day number to that day\\n\\n if Parser.in_sector(line): # check if a sector has started\\n day['day_sectors'].append(Parser.sector_parser(line)) # append sector to day\\n\\n else:\\n day['sign_off'] = line[53:58].strip() # get sign off time from line\\n day['flight_duty_period'] = line[71:76].strip() # get flight duty period\\n flight_duty_split = day['flight_duty_period'].split('h') # split flight duty period on 'h'\\n day['flight_duty_period_hours'] = int(flight_duty_split[0]) # convert to hours\\n day['flight_duty_period_minutes'] = int(flight_duty_split[1]) # convert to minutes\\n\\n day_started = False # sets day started to false\\n\\n if not day_started:\\n if 'Sign_off' in line: # indicated the day is finished and its only a single day trip\\n day['lay_over'] = '0h00' # hard coded 0h00 layover as this is return flight from home base\\n day['lay_over_hours'] = 0 # hard coded 0 hours\\n day['lay_over_minutes'] = 0 # hard coded 0 minutes\\n\\n # order the day using an OrderedDict, before adding it to the trip dict\\n day_ordered = Parser.order_day(day)\\n trip['days'].append(day_ordered)\\n\\n elif '--------------------------------' in line: # the day is over and now layover\\n lay_over = line[88:93].strip() # get layover from line\\n day['lay_over'] = lay_over # add to day dictionary\\n day['lay_over_hours'] = Parser.layover_split(lay_over)[0] # split and convert to int\\n day['lay_over_minutes'] = Parser.layover_split(lay_over)[1] # split and convert to int\\n\\n # order the day using an OrderedDict, before adding it to the trip dict\\n day_ordered = Parser.order_day(day)\\n trip['days'].append(day_ordered)\\n\\n if not line[28:36].isspace() and line[27:35] == 'Sign_off': # detect end of a trip\\n trip_started = False # set trip started to False\\n\\n trip_list.append(trip) # append the trip(dictionary) to the trip list\\n\\n with open(output_file, 'w') as fh: # Convert everything (including datetime object) to string\\n fh.write(json.dumps(trip_list, default=str, indent=4)) # write to json file for output\\n\\n Display.display_data(output_file) # display analytics data within the terminal\\n\\n return output_file\",\n \"def maps():\\n flatmap_list = []\\n root_path = pathlib.Path(settings['FLATMAP_ROOT'])\\n if root_path.is_dir():\\n for flatmap_dir in root_path.iterdir():\\n index = os.path.join(settings['FLATMAP_ROOT'], flatmap_dir, 'index.json')\\n mbtiles = os.path.join(settings['FLATMAP_ROOT'], flatmap_dir, 'index.mbtiles')\\n if os.path.isdir(flatmap_dir) and os.path.exists(index) and os.path.exists(mbtiles):\\n with open(index) as fp:\\n index = json.loads(fp.read())\\n version = index.get('version', 1.0)\\n reader = MBTilesReader(mbtiles)\\n if version >= 1.3:\\n metadata = read_metadata(reader, 'metadata')\\n if (('id' not in metadata or flatmap_dir.name != metadata['id'])\\n and ('uuid' not in metadata or flatmap_dir.name != metadata['uuid'].split(':')[-1])):\\n app.logger.error(f'Flatmap id mismatch: {flatmap_dir}')\\n continue\\n flatmap = {\\n 'id': metadata['id'],\\n 'source': metadata['source'],\\n 'version': version\\n }\\n if 'created' in metadata:\\n flatmap['created'] = metadata['created']\\n if 'taxon' in metadata:\\n flatmap['taxon'] = normalise_identifier(metadata['taxon'])\\n flatmap['describes'] = metadata['describes'] if 'describes' in metadata else flatmap['taxon']\\n elif 'describes' in metadata:\\n flatmap['taxon'] = normalise_identifier(metadata['describes'])\\n flatmap['describes'] = flatmap['taxon']\\n if 'biological-sex' in metadata:\\n flatmap['biologicalSex'] = metadata['biological-sex']\\n if 'uuid' in metadata:\\n flatmap['uuid'] = metadata['uuid']\\n if 'name' in metadata:\\n flatmap['name'] = metadata['name']\\n else:\\n try:\\n source_row = reader._query(\\\"SELECT value FROM metadata WHERE name='source'\\\").fetchone()\\n except (InvalidFormatError, sqlite3.OperationalError):\\n flask.abort(404, 'Cannot read tile database: {}'.format(mbtiles))\\n if source_row is None:\\n continue\\n flatmap = {\\n 'id': flatmap_dir.name,\\n 'source': source_row[0]\\n }\\n created = reader._query(\\\"SELECT value FROM metadata WHERE name='created'\\\").fetchone()\\n if created is not None:\\n flatmap['created'] = created[0]\\n describes = reader._query(\\\"SELECT value FROM metadata WHERE name='describes'\\\").fetchone()\\n if describes is not None and describes[0]:\\n flatmap['describes'] = normalise_identifier(describes[0])\\n flatmap_list.append(flatmap)\\n return flask.jsonify(flatmap_list)\",\n \"def load_all_templates(dataset, template_dir: str) -> Dict[str, NexusTemplate]:\\n template_set = {\\n template_name\\n for template_name in os.listdir(template_dir)\\n if not template_name.endswith(\\\".json\\\")\\n }\\n template_set.add(\\\"linear\\\")\\n\\n template_ord = []\\n for template_name in TEMPLATE_PREFERRED_ORDER:\\n try:\\n template_set.remove(template_name)\\n except KeyError:\\n pass\\n else:\\n template_ord.append(template_name)\\n template_ord.extend(sorted(template_set))\\n\\n return {\\n template_name: load_template(dataset, template_dir, template_name)\\n for template_name in template_ord\\n }\",\n \"def test_render_templates():\\n water_mol = Atoms(cclib.bridge.cclib2openbabel.readfile(\\\"data/water.xyz\\\", \\\"xyz\\\"))\\n if not water_mol.name:\\n water_mol.name = \\\"data/water.xyz\\\"\\n\\n main([\\\"-g\\\", \\\"/tmp/foo.ADF.in\\\"])\\n main([\\\"/tmp/foo.ADF.in\\\", \\\"data/water.xyz\\\"])\\n assert_equals(\\n open(\\\"data/water.in\\\").read().strip(),\\n \\\"\\\"\\\"TITLE data/water.xyz\\n\\nCHARGE 0 0\\n\\nNumber of atoms\\n 3\\n\\nATOMS Cartesian\\nO 0.0584027061 0.0584027059 0.0000000000\\nH 1.0096135406 -0.0680162466 0.0000000000\\nH -0.0680162466 1.0096135407 0.0000000000\\nEnd\\n\\nBasis\\nEnd\\n\\nGeometry\\nEnd\\\"\\\"\\\",\\n )\\n\\n main([\\\"-g\\\", \\\"/tmp/test.GAMESS.inp\\\"])\\n main([\\\"/tmp/test.GAMESS.inp\\\", \\\"data/water.xyz\\\"])\\n assert_equals(\\n open(\\\"data/water.inp\\\").read(),\\n \\\"\\\"\\\" $CONTRL COORD=CART UNITS=ANGS $END\\n\\n $DATA\\ndata/water.xyz\\nC1\\nO 8.0 0.0584027061 0.0584027059 0.0000000000\\nH 1.0 1.0096135406 -0.0680162466 0.0000000000\\nH 1.0 -0.0680162466 1.0096135407 0.0000000000\\n $END\\n\\n\\n\\\"\\\"\\\",\\n )\\n\\n main([\\\"-g\\\", \\\"/tmp/hello.GAMESSUK.inp\\\"])\\n main([\\\"/tmp/hello.GAMESSUK.inp\\\", \\\"data/water.xyz\\\"])\\n assert_equals(open(\\\"data/water.inp\\\").read(), water_mol.to_string(\\\"gukin\\\"))\\n\\n main([\\\"-g\\\", \\\"/tmp/hello.world.Gaussian.gjf\\\"])\\n main([\\\"/tmp/hello.world.Gaussian.gjf\\\", \\\"data/water.xyz\\\"])\\n assert_equals(\\n open(\\\"data/water.gjf\\\").read(),\\n \\\"\\\"\\\"#Put Keywords Here, check Charge and Multiplicity.\\n\\n data/water.xyz\\n\\n0 1\\nO 0.0584027061 0.0584027059 0.0000000000\\nH 1.0096135406 -0.0680162466 0.0000000000\\nH -0.0680162466 1.0096135407 0.0000000000\\n\\n\\\"\\\"\\\",\\n )\\n\\n main([\\\"-g\\\", \\\"/tmp/bar.Jaguar.in\\\"])\\n main([\\\"/tmp/bar.Jaguar.in\\\", \\\"data/water.xyz\\\"])\\n assert_equals(open(\\\"data/water.in\\\").read(), water_mol.to_string(\\\"jin\\\"))\\n\\n main([\\\"-g\\\", \\\"/tmp/foo.Molpro.inp\\\"])\\n main([\\\"/tmp/foo.Molpro.inp\\\", \\\"data/water.xyz\\\"])\\n assert_equals(open(\\\"data/water.inp\\\").read(), water_mol.to_string(\\\"mp\\\"))\\n\\n main([\\\"-g\\\", \\\"/tmp/example.MOPAC.mop\\\"])\\n main([\\\"/tmp/example.MOPAC.mop\\\", \\\"data/water.xyz\\\"])\\n assert_equals(\\n open(\\\"data/water.mop\\\").read(),\\n \\\"\\\"\\\"CHARGE=0 MS=0.0\\ndata/water.xyz\\n\\nO 0.05840 1 0.05840 1 0.00000 1\\nH 1.00961 1 -0.06802 1 0.00000 1\\nH -0.06802 1 1.00961 1 0.00000 1\\n\\\"\\\"\\\",\\n )\\n\\n main([\\\"-g\\\", \\\"/tmp/bar.MPQC.in\\\"])\\n main([\\\"/tmp/bar.MPQC.in\\\", \\\"data/water.xyz\\\"])\\n assert_equals(open(\\\"data/water.in\\\").read(), water_mol.to_string(\\\"mpqcin\\\"))\\n\\n main([\\\"-g\\\", \\\"/tmp/foo.NWChem.nw\\\"])\\n main([\\\"/tmp/foo.NWChem.nw\\\", \\\"data/water.xyz\\\"])\\n assert_equals(\\n open(\\\"data/water.nw\\\").read(),\\n \\\"\\\"\\\"start molecule\\n\\ntitle data/water.xyz\\n\\ngeometry units angstroms print xyz autosym\\nO 0.0584027061 0.0584027059 0.0000000000\\nH 1.0096135406 -0.0680162466 0.0000000000\\nH -0.0680162466 1.0096135407 0.0000000000\\nend\\n\\\"\\\"\\\",\\n )\\n\\n main([\\\"-g\\\", \\\"/tmp/example.ORCA.inp\\\"])\\n main([\\\"/tmp/example.ORCA.inp\\\", \\\"data/water.xyz\\\"])\\n assert_equals(\\n open(\\\"data/water.inp\\\").read(),\\n \\\"\\\"\\\"# data/water.xyz\\n! Opt\\n\\n* xyz 0 1\\nO 0.0584027061 0.0584027059 0.0000000000\\nH 1.0096135406 -0.0680162466 0.0000000000\\nH -0.0680162466 1.0096135407 0.0000000000\\n*\\n\\\"\\\"\\\",\\n )\\n\\n main([\\\"-g\\\", \\\"/tmp/bar.Psi.dat\\\"])\\n main([\\\"/tmp/bar.Psi.dat\\\", \\\"data/water.xyz\\\"])\\n assert_equals(\\n open(\\\"data/water.dat\\\").read(),\\n \\\"\\\"\\\"# data/water.xyz\\n\\nmolecule {\\n0 1\\nO 0.0584027061 0.0584027059 0.0000000000\\nH 1.0096135406 -0.0680162466 0.0000000000\\nH -0.0680162466 1.0096135407 0.0000000000\\nunits angstrom\\n}\\n\\noptimize('scf')\\n\\\"\\\"\\\",\\n )\\n\\n main([\\\"-g\\\", \\\"/tmp/example.QChem.in\\\"])\\n main([\\\"/tmp/example.QChem.in\\\", \\\"data/water.xyz\\\"])\\n assert_equals(open(\\\"data/water.in\\\").read(), water_mol.to_string(\\\"qcin\\\"))\\n\\n main([\\\"-g\\\", \\\"/tmp/foo.ZINDO.input\\\"])\\n main([\\\"/tmp/foo.ZINDO.input\\\", \\\"data/water.xyz\\\"])\\n assert_equals(open(\\\"data/water.input\\\").read(), water_mol.to_string(\\\"zin\\\"))\",\n \"def create_files_from_templates(self, model_attributes):\\n for folder_name in [\\\"views\\\", \\\"urls\\\"]:\\n file_path = \\\"%s/%s/%s_%s.py\\\" % (model_attributes['app_label'], folder_name,\\n model_attributes['model_name_slug'], folder_name)\\n template_path = \\\"django_baker/%s\\\" % (folder_name)\\n self.create_file_from_template(file_path, template_path, model_attributes)\\n for file_name in [\\\"base\\\", \\\"list\\\", \\\"detail\\\", \\\"create\\\", \\\"update\\\", \\\"delete\\\"]:\\n file_path = \\\"%s/templates/%s/%s_%s.html\\\" % (model_attributes['app_label'], model_attributes['app_label'],\\n model_attributes['model_name_slug'], file_name)\\n template_path = \\\"django_baker/%s.html\\\" % (file_name)\\n self.create_file_from_template(file_path, template_path, model_attributes)\",\n \"def create_base_templates(outdir, templateEnv):\\n for file in ME_TEMPLATES:\\n filename = os.path.join(outdir, ME_FILENAME.format(file))\\n template = templateEnv.get_template(file + '.go.jinja')\\n\\n with open(filename, 'w') as f:\\n output = template.render(copyright=COPYRIGHT,\\n generator_warning=GENERATOR_WARNING,\\n package_name=PACKAGE_NAME)\\n f.write(output)\\n pass\",\n \"def get_template_script(output_dir='.', keep_schrodinger=False, keep_openeye=False,\\n systems='all'):\\n paths = examples_paths()\\n template_script = \\\"\\\"\\\"\\n ---\\n options:\\n output_dir: {output_dir}\\n default_number_of_iterations: 0\\n temperature: 300*kelvin\\n pressure: 1*atmosphere\\n minimize: no\\n verbose: no\\n default_nsteps_per_iteration: 1\\n molecules:\\n benzene:\\n filepath: {benzene_path}\\n antechamber: {{charge_method: bcc}}\\n benzene-epik0:\\n filepath: {benzene_path}\\n epik:\\n select: 0\\n antechamber: {{charge_method: bcc}}\\n benzene-epikcustom:\\n filepath: {benzene_path}\\n epik:\\n select: 0\\n ph: 7.0\\n tautomerize: yes\\n antechamber: {{charge_method: bcc}}\\n p-xylene:\\n filepath: {pxylene_path}\\n antechamber: {{charge_method: bcc}}\\n p-xylene-name:\\n name: p-xylene\\n openeye: {{quacpac: am1-bcc}}\\n antechamber: {{charge_method: null}}\\n toluene:\\n filepath: {toluene_path}\\n antechamber: {{charge_method: bcc}}\\n toluene-smiles:\\n smiles: Cc1ccccc1\\n antechamber: {{charge_method: bcc}}\\n toluene-name:\\n name: toluene\\n antechamber: {{charge_method: bcc}}\\n Abl:\\n filepath: {abl_path}\\n T4Lysozyme:\\n filepath: {lysozyme_path}\\n solvents:\\n vacuum:\\n nonbonded_method: NoCutoff\\n GBSA-OBC2:\\n nonbonded_method: NoCutoff\\n implicit_solvent: OBC2\\n PME:\\n nonbonded_method: PME\\n nonbonded_cutoff: 1*nanometer\\n clearance: 10*angstroms\\n positive_ion: Na+\\n negative_ion: Cl-\\n leap:\\n parameters: [leaprc.water.tip4pew]\\n systems:\\n explicit-system:\\n receptor: benzene\\n ligand: toluene\\n solvent: PME\\n leap:\\n parameters: [leaprc.protein.ff14SB, leaprc.gaff]\\n implicit-system:\\n receptor: T4Lysozyme\\n ligand: p-xylene\\n solvent: GBSA-OBC2\\n leap:\\n parameters: [leaprc.protein.ff14SB, leaprc.gaff]\\n hydration-system:\\n solute: toluene\\n solvent1: PME\\n solvent2: vacuum\\n leap:\\n parameters: [leaprc.protein.ff14SB, leaprc.gaff]\\n mcmc_moves:\\n single:\\n type: LangevinSplittingDynamicsMove\\n sequence:\\n type: SequenceMove\\n move_list:\\n - type: MCDisplacementMove\\n - type: LangevinDynamicsMove\\n samplers:\\n repex:\\n type: ReplicaExchangeSampler\\n sams:\\n type: SAMSSampler\\n protocols:\\n absolute-binding:\\n complex:\\n alchemical_path:\\n lambda_electrostatics: [1.0, 0.5, 0.0]\\n lambda_sterics: [1.0, 0.5, 0.0]\\n solvent:\\n alchemical_path:\\n lambda_electrostatics: [1.0, 0.5, 0.0]\\n lambda_sterics: [1.0, 0.5, 0.0]\\n hydration-protocol:\\n solvent1:\\n alchemical_path:\\n lambda_electrostatics: [1.0, 0.0]\\n lambda_sterics: [1.0, 0.0]\\n solvent2:\\n alchemical_path:\\n lambda_electrostatics: [1.0, 0.0]\\n lambda_sterics: [1.0, 1.0]\\n experiments:\\n system: explicit-system\\n protocol: absolute-binding\\n \\\"\\\"\\\".format(output_dir=output_dir, benzene_path=paths['benzene'],\\n pxylene_path=paths['p-xylene'], toluene_path=paths['toluene'],\\n abl_path=paths['abl'], lysozyme_path=paths['lysozyme'])\\n\\n # Load script as dictionary.\\n script_dict = yank_load(template_script)\\n\\n # Find all molecules that require optional tools.\\n molecules_to_remove = []\\n for molecule_id, molecule_description in script_dict['molecules'].items():\\n need_schrodinger = 'epik' in molecule_description\\n need_openeye = any([k in molecule_description for k in ['name', 'smiles', 'openeye']])\\n if ((need_schrodinger and not keep_schrodinger) or\\n (need_openeye and not keep_openeye)):\\n molecules_to_remove.append(molecule_id)\\n\\n # Remove molecules.\\n for molecule_id in molecules_to_remove:\\n del script_dict['molecules'][molecule_id]\\n\\n # Remove systems.\\n if systems != 'all':\\n systems_to_remove = [s for s in script_dict['systems'] if s not in systems]\\n for system_id in systems_to_remove:\\n del script_dict['systems'][system_id]\\n\\n return script_dict\",\n \"def _yield_result_files(self, tpl, **kwargs):\\n for sheet in self.shortcut_sheets:\\n for ngs_library in sheet.all_ngs_libraries:\\n extraction_type = ngs_library.test_sample.extra_infos[\\\"extractionType\\\"]\\n if ngs_library.extra_infos[\\\"seqPlatform\\\"] in (\\\"ONP\\\", \\\"PacBio\\\"):\\n suffix = \\\"_long\\\"\\n else:\\n suffix = \\\"\\\"\\n yield from expand(\\n tpl,\\n mapper=self.config[\\\"tools\\\"][extraction_type.lower() + suffix],\\n ngs_library=[ngs_library],\\n **kwargs\\n )\",\n \"def extract_hg_json(json_files):\\n for f in json_files:\\n # print(f)\\n file_path = \\\"hg_files/\\\" + f\\n # read_from_json = json.load(file_path.read())\\n # print(read_from_json)\\n with open(file_path) as json_files:\\n data = json.load(json_files)\\n # pprint(data)\\n github_base_link = \\\"https://github.com/Akhliskun/firefox-infra-changelog/blob/master/hg_files/\\\"\\n repository_name = \\\"[\\\" + f.rstrip().replace(\\\".json\\\", \\\"\\\") + \\\"]\\\" + \\\"(\\\" + github_base_link + \\\\\\n f.rstrip().replace(\\\" \\\", \\\"%20\\\") + \\\")\\\"\\n\\n for test in data[\\\"changesets\\\"]:\\n commit_description = test[\\\"desc\\\"]\\n replaced_commit_description = re.sub(\\\"[\\\\n]\\\", \\\" \\\", commit_description)\\n commit_date = test[\\\"date\\\"][:1]\\n tdz = test[\\\"date\\\"][1:]\\n test = str(commit_date).strip(\\\"[]\\\")\\n time_designator = str(tdz).strip(\\\"[]\\\")\\n data_push = hg_timestamps_handler(test, time_designator)\\n replaced_commit_description = str(replaced_commit_description)\\n write_main_mk_table(\\\"main_mk_table.md\\\", repository_name, replaced_commit_description, data_push)\\n # We are braking this for loop since we got the last commit.\\n break\",\n \"def main(\\n files: List[Path] = typer.Argument(default=None, dir_okay=False, exists=True),\\n template: Optional[str] = typer.Option(\\n None, '--template', help='Name of template file'\\n ),\\n logo: Optional[str] = typer.Option(None, '--logo', help='Name of logo file'),\\n logo_width: Optional[str] = typer.Option(\\n None, '--logo-width', help='Logo width (default 35mm)'\\n ),\\n highlight_style: Optional[str] = typer.Option(None, '--highlight-style',\\n help='Specify coloring style to be used in highlighting source code'),\\n syntax_definition: Optional[str] = typer.Option(None, '--syntax-definition',\\n help='Specify a directory which contains syntax definition files'),\\n no_toc: bool = typer.Option(\\n False, '--no-toc', help='table of contents in PDF document'\\n ),\\n no_number_sections: bool = typer.Option(False, '--no-number-sections', help='no section numbering'),\\n\\n no_titlepage: bool = typer.Option(False, '--no-titlepage', help='title in PDF document'),\\n tex_file: bool = typer.Option(\\n False, '--tex', help='create TeX file instead of PDF document'\\n ),\\n email: Optional[str] = typer.Option(None, '--email', help='Author email'),\\n company: Optional[str] = typer.Option(None, '--company', help='Name of company'),\\n department: Optional[str] = typer.Option(\\n None, '--department', help='Name of department'\\n ),\\n confidential: bool = typer.Option(\\n False, '--confidential', help='indicate confidential'\\n ),\\n debug: bool = typer.Option(False, '--debug', help='turns debugging on'),\\n pdf_engine: str = typer.Option(\\n 'xelatex',\\n '--pdf-engine',\\n help='Specify pdf engine, one of lualatex, xelatex or tectonic ',\\n ),\\n _version: bool = typer.Option(\\n None, '-V', '--version', callback=version_callback, help='Show version and exit'\\n ),\\n):\\n\\n if not files:\\n typer.echo('Error: Must specify at least one .md file.')\\n raise typer.Abort()\\n\\n mdfiles: List[str] = [str(md) for md in files]\\n\\n template = template or os.environ.get('MD2PDF_TEMPLATE')\\n if template is None:\\n print('No template specified')\\n sys.exit(1)\\n\\n email = email or os.environ.get('MD2PDF_AUTHOR_EMAIL')\\n footer_center = ''\\n\\n # command line overwrites `MD2PDF_PDF_ENGINE`. if both are not given\\n # then `xelatex` is the default\\n pdf_engine = pdf_engine or os.environ.get('MD2PDF_PDF_ENGINE') or 'xelatex'\\n # check that pdf-engine is one of the following\\n if pdf_engine not in ['xelatex', 'lualatex', 'tectonic']:\\n print('--pdf-engine must be one of \\\"xelatex\\\", \\\"lualatex\\\", \\\"tectonic\\\"')\\n sys.exit(1)\\n\\n ext = '.pdf'\\n if tex_file:\\n ext = '.tex'\\n\\n if len(mdfiles) == 1:\\n toml_file = os.path.splitext(mdfiles[0])[0] + '.toml'\\n\\n if os.path.exists(toml_file):\\n print(f'TOML file {toml_file} found')\\n parsed_toml = toml.load(toml_file)\\n default_val = parsed_toml.get('default')\\n if default_val is None:\\n print(f'No file names found in {toml_file}')\\n else:\\n mdfiles = default_val.get('files')\\n\\n for mdf in mdfiles:\\n print(f'Compiling {mdf}')\\n\\n main_mdfile = os.path.realpath(mdfiles[0])\\n\\n outfile = Path(main_mdfile).stem + ext\\n\\n year = date.today().year\\n\\n company = company or os.environ.get('MD2PDF_COMPANY')\\n department = department or os.environ.get('MD2PDF_DEPARTMENT')\\n\\n if company:\\n if confidential:\\n footer_center = f'© Copyright {year} {company}'\\n else:\\n footer_center = f'{year} {company}'\\n\\n pdcmd = PandocCmd(outfile)\\n pdcmd.append(f'--template={template}')\\n pdcmd.append(f'--pdf-engine={pdf_engine}')\\n\\n pdcmd.set_v('footer-center', footer_center)\\n pdcmd.set_v('company', company)\\n pdcmd.set_v('department', department)\\n\\n syntax_definition = syntax_definition or os.environ.get('MD2PDF_SYNTAX_DEFINITION_DIR')\\n if syntax_definition is not None:\\n add_syntax_definition(pdcmd, syntax_definition)\\n\\n pdcmd.append('--highlight-style')\\n highlight_style = highlight_style or os.environ.get('MD2PDF_HIGHLIGHT_STYLE')\\n if highlight_style is None:\\n pdcmd.append('pygments')\\n else:\\n check_highlight_style(highlight_style)\\n pdcmd.append(highlight_style)\\n\\n if not no_number_sections:\\n pdcmd.append('--number-sections')\\n\\n if no_titlepage:\\n pdcmd.set_m('titlepage', 'false')\\n\\n logo = logo or os.environ.get('MD2PDF_LOGO')\\n pdcmd.set_v('logo', logo)\\n\\n logo_width = logo_width or os.environ.get('MD2PDF_LOGO_WIDTH')\\n pdcmd.set_v('logo-width', logo_width)\\n\\n pdcmd.set_m('email', email)\\n\\n if not no_toc:\\n pdcmd.append('--toc')\\n\\n pdcmd.extend(mdfiles)\\n\\n if debug:\\n print(' '.join(pdcmd.pandoc))\\n\\n\\n pdcmd.run()\",\n \"def create_input_file(self, polymer_identifier, format, outpath):\\n\\n\\t\\tsmiles = self.get_smiles_from_identifier(polymer_identifier)\\n\\t\\t\\n\\t\\tresult = generate_input_files(smiles, format)\\n\\t\\twith open(outpath, 'w+') as f:\\n\\t\\t\\tf.write(result)\",\n \"def read_templates(folder):\\n output = []\\n for path, subdirs, files in os.walk(folder):\\n for name in files:\\n if name.endswith('.yml'):\\n tpl = yaml.load(open(os.path.join(path, name)).read())\\n tpl['template_name'] = name\\n\\n # Test if all required fields are in template:\\n assert 'keywords' in tpl.keys(), 'Missing keywords field.'\\n required_fields = ['date', 'amount', 'invoice_number']\\n assert len(set(required_fields).intersection(tpl['fields'].keys())) == len(required_fields), \\\\\\n 'Missing required key in template {} {}. Found {}'.format(name, path, tpl['fields'].keys())\\n \\n # Keywords as list, if only one.\\n if type(tpl['keywords']) is not list:\\n tpl['keywords'] = [tpl['keywords']]\\n\\n output.append(InvoiceTemplate(tpl))\\n return output\",\n \"def main(unused_argv):\\n\\n # Read the scene file.\\n with open(FLAGS.scene_path, 'r') as file_id:\\n scenes = json.load(file_id)\\n\\n # Read the synonyms file.\\n with open(FLAGS.synonym_path, 'r') as file_id:\\n synonyms = json.load(file_id)\\n sorter = lambda x: len(x[0].split(' '))\\n\\n # Read the metainformation file.\\n with open(FLAGS.metainfo_path, 'r') as file_id:\\n gvars.METAINFO = json.load(file_id)\\n tag_inv_map = {attr: tag for tag, attr in gvars.METAINFO['tag_map'].items()\\n if tag != '<P>'}\\n gvars.METAINFO['tag_inv_map'] = tag_inv_map\\n gvars.METAINFO['synonym_keys'] = sorted(synonyms.items(),\\n key=sorter, reverse=True)\\n\\n # Add ids to objects.\\n scenes = utils.add_object_ids(scenes)\\n scenes = utils.clean_object_attributes(scenes)\\n\\n # Read the caption templates.\\n template_paths = os.listdir(FLAGS.caption_template_root)\\n cap_templates = []\\n for ii in template_paths:\\n with open(os.path.join(FLAGS.caption_template_root, ii), 'r') as file_id:\\n cur_templates = json.load(file_id)\\n cap_templates.extend(cur_templates)\\n #utils.pretty_print_templates(cap_templates, 1)\\n\\n # Read the question templates.\\n template_paths = os.listdir(FLAGS.question_template_root)\\n ques_templates = []\\n for ii in template_paths:\\n with open(os.path.join(FLAGS.question_template_root, ii), 'r') as file_id:\\n cur_templates = json.load(file_id)\\n ques_templates.extend(cur_templates)\\n #utils.pretty_print_templates(ques_templates, 1)\\n\\n # 1. Check if there a scene_id_file specified.\\n # 2. Check if num_images is -1\\n if FLAGS.scene_id_file != '':\\n with open(FLAGS.scene_id_file, 'r') as file_id:\\n missing_ids = [int(ii.strip('\\\\n')) for ii in file_id.readlines()]\\n print('Dialogs missing for scenes: %d' % len(missing_ids))\\n\\n # Create a image_index -> scenes list index dictionary\\n image_list_id_dict = {ii['image_index']: index\\n for index, ii in enumerate(scenes['scenes'])}\\n scenes_subset = [scenes['scenes'][image_list_id_dict[scene_id]]\\n for scene_id in missing_ids]\\n\\n elif FLAGS.num_images == -1:\\n scenes_subset = scenes['scenes']\\n\\n else:\\n scenes_subset = scenes['scenes'][0: FLAGS.num_images]\\n\\n # BFS for each scene.\\n if FLAGS.num_workers == 1:\\n # Single thread version.\\n dialogs = []\\n for index, scene in enumerate(scenes_subset):\\n cur_time = time.strftime('%a-%d%b%y-%X', time.gmtime())\\n print('Generating [ %s ] [ Worker: %d, Progress: %d/%d Scene: %d ]' %\\\\\\n (cur_time, 0, index, len(scenes_subset), scene['image_index']))\\n gen_dialog = generate_dialog_bfs(scene, cap_templates, ques_templates)\\n dialogs.append(gen_dialog)\\n\\n else:\\n # Multithread version.\\n output_q = multiprocessing.Queue()\\n jobs = []\\n for worker_id in range(FLAGS.num_workers):\\n allotment = scenes_subset[worker_id::FLAGS.num_workers]\\n inputs = (allotment, cap_templates, ques_templates)\\n inputs += (worker_id, output_q)\\n\\n process = multiprocessing.Process(target=worker, args=inputs)\\n jobs.append(process)\\n process.start()\\n\\n # Wait for all the jobs to finish and collect the output.\\n final_results = {}\\n for _ in jobs:\\n final_results.update(output_q.get())\\n for job in jobs:\\n job.join()\\n\\n # Flatten and sort.\\n final_results = [jj for _, ii in final_results.items() for jj in ii]\\n dialogs = sorted(final_results, key=lambda x: x['image_index'])\\n # utils.pretty_print_dialogs(dialogs)\\n\\n # Save the dialogs.\\n print('Saving dialog at: %s' % FLAGS.save_path)\\n with open(FLAGS.save_path, 'w') as file_id:\\n json.dump(dialogs, file_id)\",\n \"def _download_inputs(inputs: Dict[str, str]) -> Dict[str, Path]:\\n in_paths = dict()\\n for name, endpoint in inputs.items():\\n target_dir = _BASE_PATH / name\\n target_dir.mkdir()\\n target_file = target_dir / 'data.json'\\n r = requests.get('{}/data.json'.format(endpoint))\\n with target_file.open('wb') as f:\\n f.write(r.content)\\n in_paths[name] = target_file\\n return in_paths\",\n \"def __fill_all_templates__(self,configs):\\n template_dir = configs['system'].get('Common_directories','template')\\n sample_template = os.path.join(template_dir,configs['pipeline'].get('Template_files','sample'))\\n system_template = os.path.join(template_dir,configs['pipeline'].get('Template_files','system'))\\n qsub_template = os.path.join(template_dir,configs['pipeline'].get('Template_files','bcbio'))\\n self.__fill_template__(sample_template,self.sample_file)\\n self.__fill_template__(system_template,self.systems_file)\\n self.__fill_template__(qsub_template,self.qsub_file)\",\n \"def read_input_files(self):\\r\\n\\r\\n for input_file in self.list_of_input_files:\\r\\n input_file.read_header_of_file()\\r\\n self.list_of_header_objects.extend(input_file.list_of_header_objects)\\r\\n self.list_of_header_objects_without_ID.extend(input_file.list_of_header_objects_without_ID)\\r\\n self.list_of_contigs.extend(input_file.list_of_contigs)\\r\\n\\r\\n self.list_of_header_objects = list(toolz.unique(self.list_of_header_objects, key=lambda x: x.tag_and_ID))\\r\\n self.list_of_header_objects_without_ID = list(\\r\\n toolz.unique(self.list_of_header_objects_without_ID, key=lambda x: x.line))\\r\\n self.list_of_contigs = list(toolz.unique(self.list_of_contigs, key=lambda x: x.line))\\r\\n self.list_of_header_objects.extend(self.list_of_header_objects_without_ID)\\r\\n self.list_of_header_objects.sort(key=lambda x: x.line)\\r\\n self.list_of_header_objects.extend(self.list_of_contigs)\\r\\n self.list_of_header_objects.sort(key=lambda x: x.tag, reverse=False)\\r\\n self.create_body_header_line_for_output()\\r\\n self.write_header_in_output_file()\\r\\n\\r\\n list_of_chrom = list(self.indices.keys())\\r\\n list_of_chrom.sort(key=lambda x: self.alphanum_key(x))\\r\\n for chrom in list_of_chrom:\\r\\n self.list_of_body_objects.clear()\\r\\n for input_file in self.list_of_input_files:\\r\\n input_file.read_specific_chrom_body_of_file(chrom)\\r\\n self.list_of_body_objects.extend(input_file.list_of_body_objects)\\r\\n\\r\\n self.adjust_body_records_to_samples()\\r\\n self.list_of_body_objects = list(toolz.unique(self.list_of_body_objects, key=lambda x: x.line))\\r\\n self.list_of_body_objects.sort(key=lambda x: self.alphanum_key(x.line))\\r\\n self.verify_and_merge_body_records()\\r\\n self.write_specific_chrom_in_output_file()\",\n \"def write_complete_data():\\n for file_name in os.listdir(SOURCE_PATH):\\n if file_name in [\\\"root.json\\\", \\\"es-419.json\\\"]:\\n # \\\"root\\\" is not a language, \\\"es-419\\\" doesn't contain spell-out rules\\n continue\\n full_source_path = os.path.join(SOURCE_PATH, file_name)\\n full_target_path = os.path.join(TARGET_PATH, file_name.split(\\\".\\\")[0] + \\\".py\\\")\\n full_supplementary_path = os.path.join(SUPPLEMENTARY_PATH, file_name)\\n\\n language_data = {key: {} for key in REQUIRED_NUMBERS_DATA}\\n ordered_language_data = {key: {} for key in REQUIRED_NUMBERS_DATA}\\n with open(full_source_path, \\\"r\\\") as source:\\n data = json.load(source)\\n try:\\n requisite_data = data[\\\"rbnf\\\"][\\\"rbnf\\\"][\\\"SpelloutRules\\\"]\\n except KeyError:\\n logging.error(\\n f\\\"\\\\\\\"['rbnf']['rbnf']['SpelloutRules']\\\\\\\" doesn't exist in {file_name}\\\"\\n )\\n continue\\n\\n for keys, vals in requisite_data.items():\\n if _is_valid(keys):\\n for key, val in vals.items():\\n # Removing soft-hyphens from the source file.\\n val = val.replace(\\\"\\\\xad\\\", \\\"\\\")\\n _extract_information(key, val, language_data)\\n\\n with open(full_supplementary_path, \\\"r\\\") as supplementary_data:\\n data = json.load(supplementary_data)\\n for keys in REQUIRED_NUMBERS_DATA:\\n language_data[keys].update(data[keys])\\n sorted_tuples = sorted(\\n language_data[keys].items(), key=lambda x: (x[1], x[0])\\n )\\n for items in sorted_tuples:\\n word, number = items[0], items[1]\\n ordered_language_data[keys][word] = int(number)\\n ordered_language_data[\\\"SKIP_TOKENS\\\"] = sorted(data[\\\"SKIP_TOKENS\\\"])\\n try:\\n ordered_language_data[\\\"USE_LONG_SCALE\\\"] = data[\\\"USE_LONG_SCALE\\\"]\\n except KeyError:\\n logging.error(f\\\"long_scale information missing in {file_name}\\\")\\n\\n translation_data = json.dumps(\\n ordered_language_data, indent=4, ensure_ascii=False\\n )\\n # Overwriting boolean value with capitalized form\\n translation_data = re.sub(r\\\"\\\\bfalse\\\\b\\\", \\\"False\\\", translation_data)\\n translation_data = re.sub(r\\\"\\\\btrue\\\\b\\\", \\\"True\\\", translation_data)\\n out_text = \\\"info = \\\" + translation_data + \\\"\\\\n\\\"\\n with open(full_target_path, \\\"w+\\\") as target_file:\\n target_file.write(out_text)\",\n \"def test_parse_directory_and_make_json(self):\\n parsed = [i for i in parse_directory(\\\"./test_data/repo\\\")]\\n martial = [\\n item for item in parsed if str(item[0].urn) == \\\"urn:cts:latinLit:textgroup.work.version-lat1\\\"\\n ][0]\\n french = [\\n item for item in parsed if str(item[0].urn) == \\\"urn:cts:latinLit:groupe.oeuvre.version-lat1\\\"\\n ][0]\\n json_obj, filename = make_json(*martial)\\n json_parsed = json.loads(json_obj)\\n self.assertEqual(\\n json_parsed[\\\"text\\\"][\\\"0\\\"][\\\"0\\\"][\\\"0\\\"], \\\"Spero me secutum in libellis meis tale temperamen-\\\",\\n \\\"Text passages should be parsed correctly\\\"\\n )\\n self.assertEqual(\\n filename, \\\"textgroup__work__lat.json\\\",\\n \\\"Filename should be created in a stable and understandable manner\\\"\\n )\\n\\n json_obj, filename = make_json(*french)\\n json_parsed = json.loads(json_obj)\\n self.assertIn(\\n \\\"cit, nobis magno consensu vitia\\\", json_parsed[\\\"text\\\"][\\\"0\\\"][\\\"0\\\"],\\n \\\"Text passages should be parsed correctly\\\"\\n )\\n self.assertEqual(\\n filename, \\\"groupe_de_texte__oeuvre__lat.json\\\",\\n \\\"Filename should be created in a stable and understandable manner\\\"\\n )\",\n \"def load_template(\\n dataset: DatasetManager, template_dir: str, template_name: str\\n) -> NexusTemplate:\\n if template_name == \\\"linear\\\":\\n return LinearNexusTemplate()\\n\\n fullpath = os.path.join(template_dir, template_name)\\n with open(fullpath + \\\".json\\\", \\\"r\\\") as fdata:\\n data = json.load(fdata)\\n\\n level_doors = []\\n other_doors = []\\n for eid, door_data in data[\\\"doors\\\"].items():\\n if door_data[\\\"level\\\"] in dataset.levels:\\n level_doors.append(eid)\\n else:\\n other_doors.append(eid)\\n\\n return NexusTemplate(fullpath, template_name, data, level_doors, other_doors)\",\n \"def generate_examples(file_name):\\n for line in read_file(file_name):\\n yield json.loads(line)\",\n \"def main(args):\\n args = parse_args(args)\\n setup_logging(args.loglevel)\\n _logger.debug(\\\"Generating NUFEB simulation files\\\")\\n\\n # create nutrients\\n light = Nutrient(1e-1, None, None, \\\"g\\\", \\\"nn\\\")\\n co2 = Nutrient(float(args.co2), 1.9e-09, 44.01, \\\"l\\\", \\\"nn\\\")\\n o2 = Nutrient(0.28125, 2.30e-9, 32, \\\"l\\\", \\\"nn\\\")\\n sucrose = Nutrient(float(args.sucrose), 5.2e-10, 342.3, \\\"l\\\", \\\"nn\\\")\\n gco2 = Nutrient(0, None, 44.01, \\\"g\\\", \\\"nn\\\")\\n TEMPLATES_DIR = (Path(__file__).parent) / \\\"templates\\\"\\n\\n captureRate = round(1000 / args.timestep)\\n # define dump parameters\\n dump_list = {\\n \\\"vtk_dump\\\": f\\\"dump atom_vtk all vtk {captureRate} dump*.vtu id type diameter vx vy vz fx fy fz \\\\n dump grid_vtk all grid/vtk {captureRate} dump_%_*.vti con\\\",\\n \\\"image_dump\\\": f\\\"dump du_image all image {captureRate} image.*.jpg type diameter zoom 2 bacillus type size 1280 720 view 45 60 \\\\n dump_modify du_image acolor 1 green acolor 2 red\\\",\\n \\\"movie_dump\\\": f\\\"dump du_mov all movie {captureRate} movie.avi type diameter zoom 1.5 bacillus type size 1280 720 view 0 0 \\\\n dump_modify du_mov acolor 1 green acolor 2 red\\\",\\n \\\"hdf_dump\\\": f\\\"dump du_h5 all nufeb/hdf5 {captureRate} dump.h5 id type x y z vx vy vz fx fy fz radius conc reac\\\",\\n }\\n\\n dumps = defaultdict(list)\\n for i in range(4):\\n tmp = [\\\"vtk_dump\\\", \\\"image_dump\\\", \\\"movie_dump\\\", \\\"hdf_dump\\\"]\\n dumps[tmp[i]]\\n\\n for dump, dump_var in zip(\\n [args.vtk, args.img, args.movie, args.hdf],\\n [\\\"vtk_dump\\\", \\\"image_dump\\\", \\\"movie_dump\\\", \\\"hdf_dump\\\"],\\n ):\\n if dump is True or dump == \\\"True\\\":\\n dumps[dump_var] = dump_list[dump_var]\\n else:\\n dumps[dump_var] = \\\"\\\"\\n\\n ## Species-specific parameters\\n\\n # check for runs folder\\n if not os.path.isdir(\\\"runs\\\"):\\n os.mkdir(\\\"runs\\\")\\n x = float(args.dims.split(\\\",\\\")[0])\\n y = float(args.dims.split(\\\",\\\")[1])\\n z = float(args.dims.split(\\\",\\\")[2])\\n for n in range(1, int(args.num) + 1):\\n culture = Culture(args)\\n atoms_list = []\\n bacilli_list = []\\n # Create list of atoms and bacilli for atom definition file\\n for cell in culture.cells:\\n atoms_list.append(cell.Atom())\\n bacilli_list.append(cell.Bacillus())\\n # make atom definition file\\n for r in range(1, int(args.reps) + 1):\\n L = [\\n \\\" NUFEB Simulation\\\\r\\\\n\\\\n\\\",\\n f\\\" {args.cells_init} atoms \\\\n\\\",\\n f\\\" {len(culture.cell_types)} atom types \\\\n\\\",\\n f\\\" {args.cells_init} bacilli \\\\n\\\\n\\\",\\n f\\\" 0.0e-4 {x :.2e} xlo xhi \\\\n\\\",\\n f\\\" 0.0e-4 {y :.2e} ylo yhi \\\\n\\\",\\n f\\\" 0.0e-4 {z :.2e} zlo zhi \\\\n\\\\n\\\",\\n \\\" Atoms \\\\n\\\\n\\\",\\n ]\\n atoms = L + atoms_list\\n atoms.append(\\\"\\\\n\\\")\\n atoms.append(\\\" Bacilli \\\\n\\\\n\\\")\\n atoms = atoms + bacilli_list\\n # write atom definition file\\n f = open(\\n f\\\"runs/atom_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{r}.in\\\",\\n \\\"w+\\\",\\n )\\n f.writelines(atoms)\\n RUN_DIR = (\\n Path(\\\"runs\\\")\\n / f\\\"Run_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{args.reps}\\\"\\n )\\n if not os.path.isdir(RUN_DIR):\\n os.mkdir(RUN_DIR)\\n # os.mkdir(f'runs/Run_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{args.reps}')\\n # write initial conditions json file\\n dumpfile = open(RUN_DIR / \\\"metadata.json\\\", \\\"w\\\")\\n # dumpfile = open(f\\\"/runs/Run_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{args.reps}/metadata.json\\\",'w')\\n json.dump(CellInfo, dumpfile, indent=6)\\n dumpfile.close()\\n ###\\n\\n # write Inputscript\\n # open the file\\n filein = open(TEMPLATES_DIR / \\\"bacillus.txt\\\")\\n # filein = resources.read_text(\\\"nufeb_tools.templates\\\", \\\"Bacillus.txt\\\")\\n # read it\\n src = Template(filein.read())\\n # do the substitution\\n result = src.safe_substitute(\\n {\\n \\\"n\\\": args.cells_init,\\n \\\"SucRatio\\\": culture.SucRatio,\\n \\\"SucPct\\\": culture.SucPct,\\n \\\"n_cyanos\\\": culture.n_cyanos,\\n \\\"n_ecw\\\": culture.n_ecw,\\n \\\"Replicates\\\": args.reps,\\n \\\"Timesteps\\\": args.ntimesteps,\\n \\\"ts\\\": args.timestep,\\n \\\"CYANOGroup\\\": culture.cyGroup,\\n \\\"ECWGroup\\\": culture.ecwGroup,\\n \\\"Zheight\\\": float(args.dims.split(\\\",\\\")[2]),\\n \\\"CYANODiv\\\": culture.cyDiv,\\n \\\"ECWDiv\\\": culture.ecwDiv,\\n \\\"light\\\": light.concentration,\\n \\\"co2\\\": co2.concentration,\\n \\\"o2\\\": o2.concentration,\\n \\\"sucrose\\\": sucrose.concentration,\\n \\\"gco2\\\": gco2.concentration,\\n \\\"CYANOMonod\\\": culture.cyMonod,\\n \\\"ECWMonod\\\": culture.ecwMonod,\\n \\\"CYANOcount\\\": culture.cyanoCount,\\n \\\"ECWcount\\\": culture.ecwCount,\\n \\\"v_ncyano\\\": culture.vcyano,\\n \\\"v_necw\\\": culture.vecw,\\n \\\"vtk_dump\\\": dumps[\\\"vtk_dump\\\"],\\n \\\"image_dump\\\": dumps[\\\"image_dump\\\"],\\n \\\"movie_dump\\\": dumps[\\\"movie_dump\\\"],\\n \\\"hdf_dump\\\": dumps[\\\"hdf_dump\\\"],\\n }\\n )\\n f = open(\\n f\\\"./runs/Inputscript_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}.lmp\\\",\\n \\\"w+\\\",\\n )\\n f.writelines(result)\\n\\n # write local run script\\n # open the file\\n filein = open(TEMPLATES_DIR / \\\"local.txt\\\")\\n # filein = resources.read_text(\\\"nufeb_tools.templates\\\", \\\"local.txt\\\")\\n # read it\\n src = Template(filein.read())\\n # do the substitution\\n result = src.safe_substitute(\\n {\\n \\\"n\\\": n,\\n \\\"SucRatio\\\": culture.SucRatio,\\n \\\"SucPct\\\": culture.SucPct,\\n \\\"n_cyanos\\\": culture.n_cyanos,\\n \\\"n_ecw\\\": culture.n_ecw,\\n \\\"Reps\\\": args.reps,\\n }\\n )\\n f = open(\\n f\\\"./runs/local_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}.sh\\\", \\\"w+\\\"\\n )\\n f.writelines(result)\\n # write slurm script\\n # open the file\\n filein = open(TEMPLATES_DIR / \\\"slurm_dev.txt\\\")\\n # filein = resources.read_text(\\\"nufeb_tools.templates\\\", \\\"Slurm.txt\\\")\\n # read it\\n src = Template(filein.read())\\n # do the substitution\\n result = src.safe_substitute(\\n {\\n \\\"n\\\": args.cells_init,\\n \\\"job\\\": f\\\"NUFEB_cyano{n}\\\",\\n \\\"USER\\\": args.user,\\n \\\"Replicates\\\": args.reps,\\n \\\"SucPct\\\": culture.SucPct,\\n \\\"n_cyanos\\\": culture.n_cyanos,\\n \\\"n_ecw\\\": culture.n_ecw,\\n }\\n )\\n _logger.info(\\\"Script ends here\\\")\",\n \"def test_json():\\n schemas = {\\n 'schema-languages': 'bible/languages.json',\\n 'schema-book-metadata': 'bible/book-metadata.json',\\n 'schema-bible': 'bible/bible-*.json'\\n }\\n for schema_name, data_path_glob in schemas.items():\\n schema_path = 'schemas/{}.json'.format(schema_name)\\n with open(schema_path) as schema_file:\\n schema = json.load(schema_file)\\n data_paths = glob.iglob(data_path_glob)\\n for data_path in data_paths:\\n with open(data_path) as data_file:\\n data = json.load(data_file)\\n yield jsonschema.validate, data, schema\",\n \"def local_metadata(paths):\\n\\n # Update template directory\\n image_graph = network.load_graph(paths.image_network)\\n\\n template_paths = {}\\n\\n def template_selection(path_listing):\\n for node in path_listing:\\n if os.path.exists(paths.resource_pack + '\\\\\\\\' + os.path.join(*(node.split(os.path.sep)[1:]))):\\n image_data = dict(image_graph.nodes(data=True))[node]\\n print(image_data)\\n template_paths[os.path.split(image_data['group_name'])[1]] = node\\n return\\n\\n for bunch in connected_component_subgraphs(image_graph):\\n sorted_bunch = network.connectivity_sort(bunch.nodes(), bunch)\\n\\n if len(sorted_bunch) == 1:\\n continue\\n\\n template_selection(sorted_bunch)\\n\\n print(str(len(list(template_paths.values()))) + ' templates identified.')\\n\\n with open(paths.binding_identifiers, 'w') as json_binding_ids:\\n json.dump(template_paths, json_binding_ids, sort_keys=True, indent=2)\\n\\n bindings.build(paths, template_paths.values())\",\n \"def generate_hyperoptimize_json_arrest(path_json: str, model_type: str):\\n tmaps: Dict[str, TensorMap] = {}\\n\\n sliding_window_params = [\\n (24, 2),\\n (24, 4),\\n (24, 6),\\n (48, 2),\\n (48, 4),\\n (48, 6),\\n (72, 2),\\n (72, 4),\\n (72, 6),\\n ]\\n outcome = [\\n (12, 1),\\n (12, 2),\\n (6, 1),\\n (6, 2),\\n (3, 1),\\n (3, 0),\\n ]\\n signals = [\\n \\\"blood_pressure_systolic_value\\\",\\n \\\"blood_pressure_diastolic_value\\\",\\n \\\"respirations_value\\\",\\n \\\"pulse_value\\\",\\n \\\"temperature_value\\\",\\n \\\"urine_output_value\\\",\\n \\\"calcium_value\\\",\\n \\\"sodium_value\\\",\\n \\\"potassium_value\\\",\\n \\\"chloride_value\\\",\\n \\\"bun_value\\\",\\n \\\"creatinine_value\\\",\\n \\\"wbc_value\\\",\\n \\\"hgb_value\\\",\\n \\\"glucose_value\\\",\\n \\\"anion_gap_value\\\",\\n \\\"ppi_value\\\",\\n \\\"plt_value\\\",\\n ]\\n features = [\\\"min\\\", \\\"max\\\", \\\"mean\\\", \\\"std\\\", \\\"first\\\", \\\"last\\\", \\\"count\\\"]\\n\\n input_tensors_set: List[List[str]] = []\\n output_tensors_set: List[List[str]] = []\\n for window, step in sliding_window_params:\\n input_tmaps = []\\n sliding_window = (\\n f\\\"{window}_hrs_sliding_window_admin_date_to_arrest_start_date_\\\"\\n f\\\"{step}_hrs_step\\\"\\n )\\n\\n for signal in signals:\\n for feature in features:\\n input_tmaps.append(f\\\"{signal}_{sliding_window}_{feature}\\\")\\n # input_tmaps.append(\\\"age_first_visit_arrest_start_date_double\\\")\\n # input_tmaps.append(f\\\"length_of_stay_{T1}_hrs_pre_arrest_start_date\\\")\\n input_tensors_set.append(input_tmaps)\\n\\n for prediction, gap in outcome:\\n output_tmaps = []\\n output_tmaps.append(\\n f\\\"{sliding_window}_{prediction}_hrs_prediction_{gap}_hrs_gap\\\",\\n )\\n output_tensors_set.append(output_tmaps)\\n\\n for tmap_list in input_tensors_set + output_tensors_set:\\n for tmap_name in tmap_list:\\n try:\\n tmaps = update_tmaps(tmap_name=tmap_name, tmaps=tmaps)\\n except Exception as e:\\n raise ValueError(f\\\"Unable to create tmap {tmap_name}\\\") from e\\n\\n parameters: Dict[str, List[Any]] = generate_model_dict(model_type)\\n parameters.update(\\n {\\n \\\"input_tensors\\\": input_tensors_set,\\n \\\"output_tensors\\\": output_tensors_set,\\n \\\"patient_csv\\\": [\\n \\\"/media/ml4c3/cohorts_lists/rr-and-codes.csv\\\",\\n ],\\n },\\n )\\n\\n generate_hyperoptimize_json(parameters=parameters, path_json=path_json)\",\n \"def _parse_additional_json(dir_name: Path) -> Dict[str, Any]:\\n additional_json = {}\\n for filename in dir_name.glob(\\\"*.json*\\\"):\\n key = filename.name.split(\\\".\\\")[0]\\n if key not in (\\\"custodian\\\", \\\"transformations\\\"):\\n additional_json[key] = loadfn(filename, cls=None)\\n return additional_json\",\n \"def main():\\n os.makedirs(PATH)\\n fetch_data()\\n convert_to_json(model_list, 'models.json', is_model=True)\\n convert_to_json(backend_list, 'backends.json')\\n convert_to_json(type_list, 'types.json')\\n convert_to_json(featurizer_list, 'featurizers.json')\",\n \"def create_file(output_json):\\n folder = \\\"data/\\\"\\n filename = datetime.now().strftime(\\\"%d-%m-%Y\\\") + \\\"-moisture-read.json\\\"\\n filepath = folder+filename\\n\\n # Create Local folder\\n try:\\n os.mkdir(folder)\\n except OSError:\\n pass\\n #print(\\\"Directory already created or a failure occured on directory (%s)\\\" % folder)\\n\\n # Create Empty Json file if it doesnt exists\\n if(Path(filepath)).exists():\\n pass\\n else:\\n try:\\n f = open(filepath, \\\"a\\\")\\n f.write('{\\\\n\\\"moisture_iot_project\\\":[]\\\\n}')\\n f.close()\\n except Exception as e:\\n print(\\\"Failure occured creating the JSON file (%s)\\\" % e)\\n\\n # Open Json file to append current structure\\n with open(filepath) as outfile:\\n data = json.load(outfile)\\n\\n # Get list with all dictionaries\\n temp = data['moisture_iot_project']\\n\\n # Append current structure\\n temp.append(output_json)\\n\\n # Reorganize List values and re-write to JSON file\\n data['moisture_iot_project'] = temp\\n write_json(data, filepath)\",\n \"def data_gen(path):\\n files = glob.glob(path + \\\"//*.json\\\")\\n final_data = []\\n tot_sents = 0\\n for file in files:\\n if \\\"processed_data.json\\\" in file or \\\"merged_data.json\\\" in file or \\\"result.json\\\" in file:\\n print(file)\\n continue\\n # if \\\"holiday\\\" not in file.lower():\\n # continue\\n if \\\"merged\\\" not in file.lower():\\n continue\\n # if \\\"holiday\\\" in file.lower() or \\\"merged\\\" in file.lower():\\n # continue\\n logger.info(\\\"Processing \\\" + file)\\n data = json.load(open(file, \\\"r\\\", encoding=\\\"UTF-8\\\"))\\n for (i, datai) in enumerate(data):\\n try:\\n if \\\"Results\\\"in datai.keys():\\n ents = datai[\\\"Results\\\"]\\n else:\\n # the whole sentence is an entity\\n ents = [datai]\\n datai[\\\"Input\\\"] = datai[\\\"Text\\\"]\\n\\n sent_ents = []\\n for (i, ent) in enumerate(ents):\\n # make up lost tokens\\n if \\\"Start\\\" not in ent.keys():\\n ent[\\\"Start\\\"] = datai[\\\"Input\\\"].find(ent[\\\"Text\\\"])\\n #logger.warning(\\\"Can't find Start in original, find one according to the entity text\\\")\\n if \\\"Length\\\" not in ent.keys():\\n ent[\\\"Length\\\"] = len(ent[\\\"Text\\\"])\\n #logger.warning(\\\"Can't find Length in original, find one according to the entity text\\\")\\n\\n # extract key information as a entity\\n ent_type = ent[\\\"Type\\\"] if \\\"Type\\\" in ent.keys() else (ent[\\\"TypeName\\\"] if \\\"TypeName\\\" in ent.keys() else ent[\\\"Typename\\\"])\\n # convert datetimeV2.* to *\\n ent_type = ent_type.split(\\\".\\\")[-1] if \\\"datetimeV2\\\" in ent_type else ent_type\\n # convert ordinal.* to ordinal\\n ent_type = ent_type.split(\\\".\\\")[0] if \\\"ordinal\\\" in ent_type else ent_type\\n \\n # remove entities with null typename\\n if len(ent_type) == 0:\\n logger.warning(\\\"Null entities occured in \\\"+str(ents))\\n continue\\n \\n # find entity resolutions\\n if \\\"Value\\\" in ent.keys() and \\\"Resolution\\\" not in ent.keys():\\n ent[\\\"Resolution\\\"] = ent[\\\"Value\\\"]\\n if \\\"Resolution\\\" in ent.keys():\\n if type(ent[\\\"Resolution\\\"])==str:\\n assert ent[\\\"Resolution\\\"] == \\\"not resolved\\\"\\n value = \\\"\\\"\\n else:\\n if \\\"values\\\" in ent[\\\"Resolution\\\"].keys():\\n if \\\"timex\\\" in ent[\\\"Resolution\\\"][\\\"values\\\"][0].keys():\\n value = \\\";\\\".join([v[\\\"timex\\\"] for v in ent[\\\"Resolution\\\"][\\\"values\\\"]])\\n else:\\n value = \\\";\\\".join([v[\\\"value\\\"] for v in ent[\\\"Resolution\\\"][\\\"values\\\"]])\\n elif \\\"offset\\\" in ent[\\\"Resolution\\\"].keys():\\n value = ent[\\\"Resolution\\\"][\\\"offset\\\"]\\n elif \\\"Timex\\\" in ent[\\\"Resolution\\\"].keys():\\n value = ent[\\\"Resolution\\\"][\\\"Timex\\\"]\\n elif \\\"timex\\\" in ent[\\\"Resolution\\\"].keys():\\n value = ent[\\\"Resolution\\\"][\\\"timex\\\"]\\n elif \\\"TimeZoneResolution\\\" in ent[\\\"Resolution\\\"].keys():\\n value = ent[\\\"Resolution\\\"][\\\"TimeZoneResolution\\\"]\\n else:\\n value = ent[\\\"Resolution\\\"][\\\"value\\\"]\\n else:\\n value = \\\"\\\"\\n\\n # filter out unwanted entitiy types\\n # get rid of number from number entities\\n if ent_type.lower() not in [\\\"number\\\",\\\"ip\\\",\\\"quotedtext\\\",\\\"url\\\"]:\\n # keep only number entities\\n # if ent_type.lower() in [\\\"number\\\"]:\\n sent_ents.append({\\n \\\"Text\\\":\\n ent[\\\"Text\\\"],\\n \\\"Type\\\":\\n ent_type,\\n \\\"Start\\\":\\n ent[\\\"Start\\\"],\\n \\\"End\\\":\\n ent[\\\"End\\\"] if \\\"End\\\" in ent.keys() else ent[\\\"Start\\\"] + ent[\\\"Length\\\"] - 1,\\n \\\"Resolution\\\":\\n value,\\n })\\n except Exception as e:\\n # in case of any un-expected formats\\n print(file)\\n print(datai)\\n print(ent)\\n print(ent[\\\"Resolution\\\"].keys())\\n raise e\\n # find context\\n if \\\"Context\\\" in datai.keys():\\n context = datai[\\\"Context\\\"][\\\"ReferenceDateTime\\\"]\\n max_len = len(\\\"2017-09-27T17:25:54\\\")\\n context = context[:max_len]\\n else:\\n context = \\\"\\\"\\n final_data.append({\\\"Text\\\": datai[\\\"Input\\\"], \\\"Entities\\\": sent_ents,\\\"Context\\\": context})\\n tot_sents += len(data)\\n assert len(final_data) == tot_sents\\n\\n # robustness check and get basic statistics about current dataset\\n data_analysis(final_data)\\n # dump the processed data\\n final_data = json.dumps(final_data, indent=4, ensure_ascii=False)\\n new_file = open(path + \\\"//processed_data.json\\\", \\\"w+\\\", encoding=\\\"UTF-8\\\")\\n new_file.writelines(final_data)\",\n \"def on_get(self, req, resp):\\n resp.set_header('Content-Type', 'text/json')\\n diaries_paths = encode.get_files_in_directory(DIARIES_TO_CREATE_DIR, \\\".pdf\\\")\\n\\n def extract_file_name(path): return os.path.basename(path)\\n resp.body = json.dumps({\\\"templates_file_names\\\": list(map(extract_file_name, diaries_paths)),\\n \\\"templates_paths\\\": diaries_paths})\",\n \"def test_make_json_advanced(self):\\n resources = get_test_resources()\\n output, filename = make_json(commit=\\\"1245\\\", exclude=[\\\"tei:note\\\", \\\"tei:orig\\\"], credit=\\\"PerseusDL\\\", **resources)\\n output = json.loads(output)\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"0\\\"][\\\"0\\\"][\\\"0\\\"], \\\"Spero me secutum in libellis meis tale temperamen-\\\",\\n \\\"Text passages should be parsed correctly\\\"\\n )\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"1\\\"][\\\"0\\\"][\\\"1\\\"], \\\"Et comites longae quaeris habere viae, \\\",\\n \\\"Text passages should be parsed correctly and note removed\\\"\\n )\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"1\\\"][\\\"1\\\"][\\\"3\\\"], \\\"Crede mihi, nimium Martia turba sapit. \\\",\\n \\\"Text passages should be parsed correctly and note removed\\\"\\n )\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"1\\\"][\\\"0\\\"][\\\"0\\\"], \\\"Qui tecum cupis esse meos ubicumque libellos \\\",\\n \\\"Text passages should be parsed correctly\\\"\\n )\\n self.assertEqual(\\n filename, \\\"textgroup__work__lat.json\\\",\\n \\\"Filename should be created in a stable and understandable manner\\\"\\n )\\n self.assertEqual(\\n output[\\\"original-urn\\\"], \\\"urn:cts:latinLit:textgroup.work.version-lat1\\\",\\n \\\"Original URN should be fed\\\"\\n )\\n self.assertEqual(\\n output[\\\"urn\\\"], \\\"urn:cts:latinLit:textgroup.work.version-lat1-simple\\\",\\n \\\"CLTK URN should be suffixed\\\"\\n )\\n self.assertEqual(\\n output[\\\"credit\\\"], \\\"PerseusDL\\\",\\n \\\"Credit should be empty by default\\\"\\n )\\n self.assertEqual(\\n output[\\\"meta\\\"], \\\"book-poem-line\\\",\\n \\\"meta should reflect the citation scheme\\\"\\n )\\n self.assertEqual(\\n output[\\\"author\\\"], \\\"textgroup\\\",\\n \\\"Author name should be the English textgroup name\\\"\\n )\\n self.assertEqual(\\n output[\\\"work\\\"], \\\"work\\\",\\n \\\"Work name should be the English work name\\\"\\n )\\n self.assertEqual(\\n output[\\\"edition\\\"], \\\"description\\\",\\n \\\"We should have the English description\\\"\\n )\\n self.assertEqual(\\n output[\\\"commit\\\"], \\\"1245\\\",\\n \\\"We should have the commit information\\\"\\n )\",\n \"def _writeInputJSON(self, tstep):\\n\\n # update json based on the Properties:\\n # print(\\\"Property keys:\\\")\\n for key in self.properties.index:\\n # print(key)\\n prop = self.properties[key]\\n\\n if(key[0] == PropertyID.PID_RefractiveIndex and\\n key[2] == tstep and key[1] == objID.OBJ_CONE):\\n print(\\\"PID_RefractiveIndex, \\\", prop.getValue())\\n parent = self._jsondata['materials']\\n parent[3][\\\"refractiveIndex\\\"] = prop.getValue()\\n\\n elif(key[0] == PropertyID.PID_NumberOfRays and\\n key[2] == tstep):\\n print(\\\"PID_NumberOfRays, \\\", prop.getValue())\\n parent = self._jsondata['sources']\\n for item in parent:\\n item[\\\"rays\\\"] = prop.getValue()\\n\\n elif(key[0] == PropertyID.PID_ChipSpectrum and\\n key[2] == tstep):\\n print(\\\"PID_ChipSpectrum, \\\", prop.getValue())\\n parent = self._jsondata['sources']\\n for item in parent:\\n item[\\\"wavelengths\\\"] = prop.getValue()[\\n \\\"wavelengths\\\"].tolist()\\n item[\\\"intensities\\\"] = prop.getValue()[\\n \\\"intensities\\\"].tolist()\\n\\n elif(key[0] == PropertyID.PID_ParticleNumberDensity and\\n key[2] == tstep):\\n print(\\\"PID_ParticleNumberDensity, \\\", prop.getValue())\\n parent = self._jsondata['materials']\\n if prop.getValueType() is ValueType.Scalar:\\n parent[3][\\\"particleDensities\\\"] = [prop.getValue()]\\n else:\\n parent[3][\\\"particleDensities\\\"] = prop.getValue()\\n\\n elif(key[0] == PropertyID.PID_ScatteringCrossSections and\\n key[2] == tstep):\\n pass\\n elif(key[0] == PropertyID.PID_InverseCumulativeDist and\\n key[2] == tstep):\\n pass\\n # Datafiles:\\n parent = self._jsondata['materials']\\n\\n n_particle_key = (\\n PropertyID.PID_NumberOfFluorescentParticles, objID.OBJ_CONE, tstep)\\n n_particles = self.properties[n_particle_key]\\n parent[3]['numberOfFluorescentParticles'] = n_particles.getValue()\\n print(\\\"n_particles=\\\", n_particles.getValue(),\\n parent[3]['numberOfFluorescentParticles'])\\n\\n # Phosphor efficiences:\\n if PropertyID.PID_PhosphorEfficiency in\\\\\\n self.properties.index.get_level_values('propertyID'):\\n effs = self.properties.xs(\\n (PropertyID.PID_PhosphorEfficiency, tstep), level=('propertyID', 'tstep'))\\n\\n efflist = []\\n for i, row in effs.iteritems():\\n p = row.getValue()\\n efflist.extend([p])\\n\\n parent[3][\\\"phosphorEfficiencies\\\"] = efflist\\n if len(efflist) != n_particles.getValue():\\n raise APIError.APIError(\\\"Number of phosphor efficiencies \\\\\\n (%d) does not match with number of \\\\\\n fluorescent particles (%d)\\\" %\\n (len(efflist),\\n n_particles.getValue())\\n )\\n else:\\n raise APIError.APIError(\\n \\\"Did not find phosphor efficiencies in Properties!\\\")\\n\\n # Properties containing emission spectrums\\n if PropertyID.PID_EmissionSpectrum in\\\\\\n self.properties.index.get_level_values('propertyID'):\\n em = self.properties.xs((PropertyID.PID_EmissionSpectrum, tstep),\\n level=('propertyID', 'tstep'))\\n\\n em_fname = []\\n for i, row in em.iteritems():\\n p = row.getValue()\\n fname = 'InvCumul_EM_%d.dat' % i\\n gS.writeEmissionSpectrumFile(p[\\\"wavelengths\\\"],\\n p[\\\"intensities\\\"],\\n fname)\\n em_fname.extend([fname])\\n\\n parent[3][\\\"cumulativeEmissionSpectrumFilenames\\\"] = em_fname\\n if len(em_fname) != n_particles.getValue():\\n raise APIError.APIError(\\\"Number of em spectrum file names \\\\\\n (%d) does not match with number of \\\\\\n fluorescent particles (%d)\\\" %\\n (len(em_fname),\\n n_particles.getValue())\\n )\\n else:\\n raise APIError.APIError(\\n \\\"Did not find em spectrum file names in Properties!\\\")\\n\\n # Excitation spectrum property\\n if PropertyID.PID_ExcitationSpectrum in\\\\\\n self.properties.index.get_level_values('propertyID'):\\n ex = self.properties.xs((PropertyID.PID_ExcitationSpectrum, tstep),\\n level=('propertyID', 'tstep'))\\n\\n ex_fname = []\\n for i, row in ex.iteritems():\\n p = row.getValue()\\n fname = 'InvCumul_EX_%d.dat' % i\\n gS.writeExAbsSpectrumFile(p[\\\"wavelengths\\\"],\\n p[\\\"intensities\\\"],\\n fname)\\n ex_fname.extend([fname])\\n parent[3][\\\"excitationSpectrumFilenames\\\"] = ex_fname\\n\\n if len(ex_fname) != n_particles.getValue():\\n raise APIError.APIError(\\\"Number of ex spectrum file names \\\\\\n (%d) does not match with number of \\\\\\n fluorescent particles (%d)\\\" %\\n (len(ex_fname),\\n n_particles.getValue())\\n )\\n else:\\n raise APIError.APIError(\\n \\\"Did not find ex spectrum file names in Properties!\\\")\\n\\n # Absorption spectrum property\\n if PropertyID.PID_AsorptionSpectrum in\\\\\\n self.properties.index.get_level_values('propertyID'):\\n aabs = self.properties.xs((PropertyID.PID_AsorptionSpectrum,\\n tstep),\\n level=('propertyID', 'tstep'))\\n\\n aabs_fname = []\\n for i, row in aabs.iteritems():\\n p = row.getValue()\\n fname = 'InvCumul_ABS_%d.dat' % i\\n gS.writeExAbsSpectrumFile(p[\\\"wavelengths\\\"],\\n p[\\\"intensities\\\"],\\n fname)\\n aabs_fname.extend([fname])\\n parent[3][\\\"absorptionSpectrumFilenames\\\"] = aabs_fname\\n if len(aabs_fname) != n_particles.getValue():\\n raise APIError.APIError(\\\"Number of abs spectrum \\\\\\n file names (%d) does not match \\\\\\n with number of fluorescent \\\\\\n particles (%d)\\\" %\\n (len(aabs_fname),\\n n_particles.getValue()))\\n else:\\n raise APIError.APIError(\\n \\\"Did not find abs spectrum file names in Properties!\\\")\\n\\n # write the json file:\\n f = open('input.json', 'w')\\n f.write(json.dumps(self._jsondata))\\n f.close()\",\n \"def main():\\n\\n # Set up argument parser.\\n parser = argparse.ArgumentParser(\\n description='Removes duplicate key-value pairs from JSON files.')\\n parser.add_argument('--suffix', default='',\\n help='optional suffix for output files; '\\n 'if empty, files will be changed in place')\\n parser.add_argument('files', nargs='+', help='input files')\\n args = parser.parse_args()\\n\\n # Iterate over files.\\n for filename in args.files:\\n # Read in json using Python libraries. This eliminates duplicates.\\n print('Processing ' + filename + '...')\\n try:\\n with codecs.open(filename, 'r', 'utf-8') as infile:\\n j = json.load(infile)\\n except ValueError as e:\\n print('Error reading ' + filename)\\n raise InputError(filename, str(e))\\n\\n # Built up output strings as an array to make output of delimiters easier.\\n output = []\\n for key in j:\\n if key != '@metadata':\\n output.append('\\\\t\\\"' + key + '\\\": \\\"' +\\n j[key].replace('\\\\n', '\\\\\\\\n') + '\\\"')\\n\\n # Output results.\\n with codecs.open(filename + args.suffix, 'w', 'utf-8') as outfile:\\n outfile.write('{\\\\n')\\n outfile.write(',\\\\n'.join(output))\\n outfile.write('\\\\n}\\\\n')\",\n \"def test_extract_configs():\\n extract_config_dir = os.path.join(\\n settings.BASE_DIR, \\\"extract_configs\\\", \\\"templates\\\"\\n )\\n for ft, obj in FILE_TYPES.items():\\n ec_file = obj[\\\"template\\\"]\\n if not ec_file:\\n continue\\n ec_path = os.path.join(extract_config_dir, ec_file)\\n print(f\\\"Testing extract config: {ec_path}\\\")\\n assert os.path.exists(ec_path)\\n df = make_template_df(ft)\\n Extractor().extract(df, ec_path)\",\n \"def task_reformat_data():\\n\\n for data_type in data_sets:\\n yield {\\n 'actions': ['python reformat_weather_data.py %(dependencies)s > %(targets)s'],\\n 'file_dep': ['UK_{}_data.txt'.format(data_type)],\\n 'targets': ['UK_{}_data.reformatted.txt'.format(data_type)],\\n }\",\n \"def unit_test_obj_mk_obj_template(p, rname, inputs):\\n # define name and arguments\\n name = 'obj_mk_obj_template'\\n arg_names = ['night_name', 'files']\\n arg_types = [str, list]\\n\\n # get arguments\\n args = get_args(p, name, rname, inputs, arg_names, arg_types)\\n return args, name\",\n \"def download_json_files(ori, des, date, hredep, args):\\n\\n print(\\\"======================================\\\")\\n print(\\\"= Extracting JSON files from OTP API =\\\")\\n print(\\\"======================================\\\")\\n i = 0\\n for id in ori.keys(): # just so we can get all the ids (could have been des.keys() or hredep.keys())\\n if download_json:\\n # don't retrieve the data from OTP API if the user specifies it\\n url = build_url(ori[id]['orilon'], ori[id]['orilat'],\\n des[id]['deslon'], des[id]['deslat'],\\n date[id]['year'], date[id]['month'], date[id]['day'],\\n hredep[id]['hour'], hredep[id]['minute'],\\n args[id])\\n try :\\n extract_json(url, id, make_dir(json_output))\\n except OSError:\\n print(\\\"ERROR : OTP is not currently running on the given port\\\")\\n exit();\\n\\n printrp('( ' + str(i) + ' / ' + str(len(ori)) + ' )') if found_CmdPrinter else print(i)\\n i += 1\\n if download_json:\\n print('( ' + str(i) + ' / ' + str(len(ori)) + ' )')\\n else:\\n print(\\\"Already downloaded\\\")\",\n \"def task_generate_tasks():\\n \\n yield {\\n 'basename': 'generate_tasks',\\n 'name': None,\\n # 'doc': 'docs for X',\\n 'watch': ['trains/'],\\n 'task_dep': ['create_folders'],\\n }\\n \\n for root, dirs, files in os.walk('trains/',topdown=False):\\n for f in files:\\n #print(f)\\n yield template_train_model(os.path.join(root,f))\",\n \"def _generate_examples(self, filepath, split):\\r\\n if self.config.name == \\\"trex\\\":\\r\\n paths = filepath\\r\\n relations_path = paths[0]\\r\\n paths = paths[1:]\\r\\n all_rels = {}\\r\\n with open(relations_path, encoding=\\\"utf-8\\\") as f:\\r\\n for row in f:\\r\\n data = json.loads(row)\\r\\n all_rels[data[\\\"relation\\\"]] = data\\r\\n id_ = -1\\r\\n for filepath in paths:\\r\\n with open(filepath, encoding=\\\"utf-8\\\") as f:\\r\\n for row in f:\\r\\n data = json.loads(row)\\r\\n pred = all_rels.get(data[\\\"predicate_id\\\"], {})\\r\\n for evidences in data[\\\"evidences\\\"]:\\r\\n id_ += 1\\r\\n yield id_, {\\r\\n \\\"uuid\\\": str(data[\\\"uuid\\\"]),\\r\\n \\\"obj_uri\\\": str(data[\\\"obj_uri\\\"]),\\r\\n \\\"obj_label\\\": str(data[\\\"obj_label\\\"]),\\r\\n \\\"sub_uri\\\": str(data[\\\"sub_uri\\\"]),\\r\\n \\\"sub_label\\\": str(data[\\\"sub_label\\\"]),\\r\\n \\\"predicate_id\\\": str(data[\\\"predicate_id\\\"]),\\r\\n \\\"sub_surface\\\": str(evidences[\\\"sub_surface\\\"]),\\r\\n \\\"obj_surface\\\": str(evidences[\\\"obj_surface\\\"]),\\r\\n \\\"masked_sentence\\\": str(evidences[\\\"masked_sentence\\\"]),\\r\\n \\\"template\\\": str(pred.get(\\\"template\\\", \\\"\\\")),\\r\\n \\\"template_negated\\\": str(pred.get(\\\"template_negated\\\", \\\"\\\")),\\r\\n \\\"label\\\": str(pred.get(\\\"label\\\", \\\"\\\")),\\r\\n \\\"description\\\": str(pred.get(\\\"description\\\", \\\"\\\")),\\r\\n \\\"type\\\": str(pred.get(\\\"type\\\", \\\"\\\")),\\r\\n }\\r\\n elif self.config.name == \\\"conceptnet\\\":\\r\\n id_ = -1\\r\\n with open(filepath, encoding=\\\"utf-8\\\") as f:\\r\\n for row in f:\\r\\n data = json.loads(row)\\r\\n if data.get(\\\"negated\\\") is not None:\\r\\n for masked_sentence, negated in zip(data[\\\"masked_sentences\\\"], data[\\\"negated\\\"]):\\r\\n id_ += 1\\r\\n yield id_, {\\r\\n \\\"uuid\\\": str(data[\\\"uuid\\\"]),\\r\\n \\\"sub\\\": str(data.get(\\\"sub\\\", \\\"\\\")),\\r\\n \\\"obj\\\": str(data.get(\\\"obj\\\", \\\"\\\")),\\r\\n \\\"pred\\\": str(data[\\\"pred\\\"]),\\r\\n \\\"obj_label\\\": str(data[\\\"obj_label\\\"]),\\r\\n \\\"masked_sentence\\\": str(masked_sentence),\\r\\n \\\"negated\\\": str(negated),\\r\\n }\\r\\n else:\\r\\n for masked_sentence in data[\\\"masked_sentences\\\"]:\\r\\n id_ += 1\\r\\n yield id_, {\\r\\n \\\"uuid\\\": str(data[\\\"uuid\\\"]),\\r\\n \\\"sub\\\": str(data.get(\\\"sub\\\", \\\"\\\")),\\r\\n \\\"obj\\\": str(data.get(\\\"obj\\\", \\\"\\\")),\\r\\n \\\"pred\\\": str(data[\\\"pred\\\"]),\\r\\n \\\"obj_label\\\": str(data[\\\"obj_label\\\"]),\\r\\n \\\"masked_sentence\\\": str(masked_sentence),\\r\\n \\\"negated\\\": str(\\\"\\\"),\\r\\n }\\r\\n elif self.config.name == \\\"squad\\\":\\r\\n id_ = -1\\r\\n with open(filepath, encoding=\\\"utf-8\\\") as f:\\r\\n for row in f:\\r\\n data = json.loads(row)\\r\\n for masked_sentence in data[\\\"masked_sentences\\\"]:\\r\\n id_ += 1\\r\\n yield id_, {\\r\\n \\\"id\\\": str(data[\\\"id\\\"]),\\r\\n \\\"sub_label\\\": str(data[\\\"sub_label\\\"]),\\r\\n \\\"obj_label\\\": str(data[\\\"obj_label\\\"]),\\r\\n \\\"negated\\\": str(data.get(\\\"negated\\\", \\\"\\\")),\\r\\n \\\"masked_sentence\\\": str(masked_sentence),\\r\\n }\\r\\n elif self.config.name == \\\"google_re\\\":\\r\\n id_ = -1\\r\\n paths = filepath\\r\\n for filepath in paths:\\r\\n # from https://github.com/facebookresearch/LAMA/blob/master/scripts/run_experiments.py\\r\\n if \\\"place_of_birth\\\" in filepath:\\r\\n pred = {\\r\\n \\\"relation\\\": \\\"place_of_birth\\\",\\r\\n \\\"template\\\": \\\"[X] was born in [Y] .\\\",\\r\\n \\\"template_negated\\\": \\\"[X] was not born in [Y] .\\\",\\r\\n }\\r\\n elif \\\"date_of_birth\\\" in filepath:\\r\\n pred = {\\r\\n \\\"relation\\\": \\\"date_of_birth\\\",\\r\\n \\\"template\\\": \\\"[X] (born [Y]).\\\",\\r\\n \\\"template_negated\\\": \\\"[X] (not born [Y]).\\\",\\r\\n }\\r\\n else:\\r\\n pred = {\\r\\n \\\"relation\\\": \\\"place_of_death\\\",\\r\\n \\\"template\\\": \\\"[X] died in [Y] .\\\",\\r\\n \\\"template_negated\\\": \\\"[X] did not die in [Y] .\\\",\\r\\n }\\r\\n with open(filepath, encoding=\\\"utf-8\\\") as f:\\r\\n for row in f:\\r\\n data = json.loads(row)\\r\\n for masked_sentence in data[\\\"masked_sentences\\\"]:\\r\\n id_ += 1\\r\\n yield id_, {\\r\\n \\\"pred\\\": str(data[\\\"pred\\\"]),\\r\\n \\\"sub\\\": str(data[\\\"sub\\\"]),\\r\\n \\\"obj\\\": str(data[\\\"obj\\\"]),\\r\\n \\\"evidences\\\": str(data[\\\"evidences\\\"]),\\r\\n \\\"judgments\\\": str(data[\\\"judgments\\\"]),\\r\\n \\\"sub_w\\\": str(data[\\\"sub_w\\\"]),\\r\\n \\\"sub_label\\\": str(data[\\\"sub_label\\\"]),\\r\\n \\\"sub_aliases\\\": str(data[\\\"sub_aliases\\\"]),\\r\\n \\\"obj_w\\\": str(data[\\\"obj_w\\\"]),\\r\\n \\\"obj_label\\\": str(data[\\\"obj_label\\\"]),\\r\\n \\\"obj_aliases\\\": str(data[\\\"obj_aliases\\\"]),\\r\\n \\\"uuid\\\": str(data[\\\"uuid\\\"]),\\r\\n \\\"masked_sentence\\\": str(masked_sentence),\\r\\n \\\"template\\\": str(pred[\\\"template\\\"]),\\r\\n \\\"template_negated\\\": str(pred[\\\"template_negated\\\"]),\\r\\n }\",\n \"def read_json(self):\\n # read in all json files in the input_path, that match the\\n # algorithm_name and are not outputs\\n for f in os.listdir(self.input_path):\\n if(os.path.splitext(f)[1] == \\\".json\\\") and (os.path.basename(f).startswith(self.algorithm_name)) and (not os.path.basename(f).startswith(\\\"_\\\")):\\n self.__input_jsons += [json.load(open(self.input_path + f))]\",\n \"def create_input_file():\\n\\n entries = {}\\n entries['items'] = []\\n\\n with open('data.json', 'w') as outfile:\\n dump(entries, outfile, indent=4)\\n\\n print('Created a new data.json file...')\",\n \"def test_make_json_simple(self):\\n resources = get_test_resources()\\n output, filename = make_json(**resources)\\n output = json.loads(output)\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"0\\\"][\\\"0\\\"][\\\"0\\\"], \\\"Spero me secutum in libellis meis tale temperamen-\\\",\\n \\\"Text passages should be parsed correctly\\\"\\n )\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"1\\\"][\\\"0\\\"][\\\"0\\\"], \\\"Qui tecum cupis esse meos ubicumque libellos \\\",\\n \\\"Text passages should be parsed correctly\\\"\\n )\\n\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"1\\\"][\\\"0\\\"][\\\"1\\\"], \\\"Et comites longae quaeris habere viae, Something\\\",\\n \\\"Text passages should be parsed correctly and note kept\\\"\\n )\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"1\\\"][\\\"1\\\"][\\\"3\\\"], \\\"Crede slug. mihi, nimium Martia turba sapit. \\\",\\n \\\"Text passages should be parsed correctly and abbr kept\\\"\\n )\\n self.assertEqual(\\n filename, \\\"textgroup__work__lat.json\\\",\\n \\\"Filename should be created in a stable and understandable manner\\\"\\n )\\n self.assertEqual(\\n output[\\\"original-urn\\\"], \\\"urn:cts:latinLit:textgroup.work.version-lat1\\\",\\n \\\"Original URN should be fed\\\"\\n )\\n self.assertEqual(\\n output[\\\"urn\\\"], \\\"urn:cts:latinLit:textgroup.work.version-lat1-simple\\\",\\n \\\"CLTK URN should be suffixed\\\"\\n )\\n self.assertEqual(\\n output[\\\"credit\\\"], \\\"\\\",\\n \\\"Credit should be empty by default\\\"\\n )\\n self.assertEqual(\\n output[\\\"meta\\\"], \\\"book-poem-line\\\",\\n \\\"meta should reflect the citation scheme\\\"\\n )\\n self.assertEqual(\\n output[\\\"author\\\"], \\\"textgroup\\\",\\n \\\"Author name should be the English textgroup name\\\"\\n )\\n self.assertEqual(\\n output[\\\"work\\\"], \\\"work\\\",\\n \\\"Work name should be the English work name\\\"\\n )\\n self.assertEqual(\\n output[\\\"edition\\\"], \\\"description\\\",\\n \\\"We should have the English description\\\"\\n )\",\n \"def get_files_io():\\n if GC.conf['general']['training']:\\n files_zip = {\\n 'raw': os.path.join(COOKED_DATA, 'train.txt'),\\n 'new': os.path.join(COOKED_DATA, 'train_new.txt'),\\n 'norm': os.path.join(COOKED_DATA, 'train_norm.txt'),\\n 'manu': os.path.join(RAW_DATA, 'others', 'temp_updt_manu.txt'),\\n 'labels': os.path.join(TRAIN_DATA, 'train_norm.txt_labels.pkl'),\\n 'segll': os.path.join(TRAIN_DATA, 'train_norm.txt_seginf_loglab.pkl'),\\n 'segdl': os.path.join(TRAIN_DATA, 'train_norm.txt_seginf_deeplog.pkl'),\\n 'struct': os.path.join(TRAIN_DATA, 'train_norm.txt_structured.csv'),\\n 'output': TRAIN_DATA\\n }\\n else:\\n files_zip = {\\n 'raw': os.path.join(COOKED_DATA, 'test.txt'),\\n 'new': os.path.join(COOKED_DATA, 'test_new.txt'),\\n 'norm': os.path.join(COOKED_DATA, 'test_norm.txt'),\\n 'labels': os.path.join(TEST_DATA, 'test_norm.txt_labels.pkl'),\\n 'segll': os.path.join(TEST_DATA, 'test_norm.txt_seginf_loglab.pkl'),\\n 'segdl': os.path.join(TEST_DATA, 'test_norm.txt_seginf_deeplog.pkl'),\\n 'map_norm_raw': os.path.join(TEST_DATA, 'map_norm_raw.pkl'),\\n 'map_norm_rcv': os.path.join(TEST_DATA, 'map_norm_rcv.pkl'),\\n 'norm_rcv': os.path.join(TEST_DATA, 'test_norm_rcv.txt'),\\n 'struct': os.path.join(TEST_DATA, 'test_norm.txt_structured.csv'),\\n 'struct_rcv': os.path.join(TEST_DATA, 'test_norm_rcv.txt_structured.csv'),\\n 'top': os.path.join(TEST_DATA, 'analysis_summary_top.txt'),\\n 'sum': os.path.join(TEST_DATA, 'analysis_summary.csv'),\\n 'rst_llab': os.path.join(TEST_DATA, 'results_loglab.csv'),\\n 'rst_dlog': os.path.join(TEST_DATA, 'results_deeplog.txt'),\\n 'rst_llzr': os.path.join(TEST_DATA, 'results_loglizer.csv'),\\n 'dbg': os.path.join(TEST_DATA, 'debug.csv'),\\n 'output': TEST_DATA\\n }\\n return files_zip\",\n \"def test_files(self, location):\\n for filename in os.listdir(location):\\n with open(location + '/' + filename) as json_file:\\n data = json.load(json_file)\\n self.test_data(data)\",\n \"def _template_formatting(field, inputs, inputs_dict_st):\\n from .specs import MultiInputObj, MultiOutputFile\\n\\n # if a template is a function it has to be run first with the inputs as the only arg\\n template = field.metadata[\\\"output_file_template\\\"]\\n if callable(template):\\n template = template(inputs)\\n\\n # as default, we assume that keep_extension is True\\n keep_extension = field.metadata.get(\\\"keep_extension\\\", True)\\n\\n inp_fields = re.findall(r\\\"{\\\\w+}\\\", template)\\n inp_fields_fl = re.findall(r\\\"{\\\\w+:[0-9.]+f}\\\", template)\\n inp_fields += [re.sub(\\\":[0-9.]+f\\\", \\\"\\\", el) for el in inp_fields_fl]\\n if len(inp_fields) == 0:\\n return template\\n\\n val_dict = {}\\n file_template = None\\n\\n for fld in inp_fields:\\n fld_name = fld[1:-1] # extracting the name form {field_name}\\n if fld_name not in inputs_dict_st:\\n raise AttributeError(f\\\"{fld_name} is not provided in the input\\\")\\n fld_value = inputs_dict_st[fld_name]\\n if fld_value is attr.NOTHING:\\n # if value is NOTHING, nothing should be added to the command\\n return attr.NOTHING\\n else:\\n # checking for fields that can be treated as a file:\\n # have type File, or value that is path like (including str with extensions)\\n if isinstance(fld_value, os.PathLike) or (\\n isinstance(fld_value, str) and \\\".\\\" in fld_value\\n ):\\n if file_template:\\n raise Exception(\\n f\\\"can't have multiple paths in {field.name} template,\\\"\\n f\\\" but {template} provided\\\"\\n )\\n else:\\n file_template = (fld_name, fld_value)\\n else:\\n val_dict[fld_name] = fld_value\\n\\n # if field is MultiOutputFile and some elements from val_dict are lists,\\n # each element of the list should be used separately in the template\\n # and return a list with formatted values\\n if field.type is MultiOutputFile and any(\\n [isinstance(el, (list, MultiInputObj)) for el in val_dict.values()]\\n ):\\n # all fields that are lists\\n keys_list = [\\n k for k, el in val_dict.items() if isinstance(el, (list, MultiInputObj))\\n ]\\n if any(\\n [len(val_dict[key]) != len(val_dict[keys_list[0]]) for key in keys_list[1:]]\\n ):\\n raise Exception(\\n f\\\"all fields used in {field.name} template have to have the same length\\\"\\n f\\\" or be a single value\\\"\\n )\\n formatted_value = []\\n for ii in range(len(val_dict[keys_list[0]])):\\n val_dict_el = copy(val_dict)\\n # updating values to a single element from the list\\n for key in keys_list:\\n val_dict_el[key] = val_dict[key][ii]\\n\\n formatted_value.append(\\n _element_formatting(\\n template, val_dict_el, file_template, keep_extension=keep_extension\\n )\\n )\\n else:\\n formatted_value = _element_formatting(\\n template, val_dict, file_template, keep_extension=keep_extension\\n )\\n return formatted_value\",\n \"def main(self, verbose=0):\\n indepdict=self.scan_for_loop(self.indeploop)\\n pegdict1 = self.scan_for_loop(self.pegloop1)\\n pegdict2 = self.scan_for_loop(self.pegloop2)\\n if len(indepdict.keys()) == 0 and len(pegdict1.keys()) == 0 and len(pegdict2.keys()) == 0:\\n return dict()\\n alldict = dict(indepdict)\\n alldict.update(pegdict1)\\n alldict.update(pegdict2)\\n indepcomb=self.get_combo_list(indepdict, 0)\\n pegcomb1=self.get_combo_list(pegdict1, 1)\\n pegcomb2=self.get_combo_list(pegdict2, 1)\\n allcombs = self.combine_three_combo_lists(indepcomb, pegcomb1, pegcomb2)\\n datasets = self.prepare_looped_datasets(alldict, allcombs)\\n createdfiles = self.create_input_files(datasets)\\n if verbose == 1:\\n self.print_list(indepcomb)\\n self.print_list(pegcomb1)\\n self.print_list(pegcomb2)\\n self.print_list(allcombs)\\n for datakey in datasets:\\n self.print_list(datasets[datakey])\\n return createdfiles\",\n \"def main():\\n\\targs = getArgs()\\n\\tid_question = args.id_question\\n\\tlang = args.language\\n\\tdir_cp = None\\n\\twith open('config.json') as json_file:\\n\\t\\tconfig_data = json.load(json_file)\\n\\t\\tdir_cp = config_data['dir_cp']\\n\\n\\t\\n\\t\\n\\t# sample_io = GetData(args.id_question).get_uri_io_sample()\\n\\ttemplate = FileUtil(id_question, dir_cp['path'], lang)\\n\\ttemplate.write_template()\\n\\t# print(sample_io)\",\n \"def _build_resources_template(self, output_filename=\\\"{}_r.json\\\"):\\n\\n template = self._base_troposphere_template()\\n\\n for resource_type, resource_cls in six.iteritems(AVAILABLE_RESOURCES):\\n resource_cls.register_type_resources_template(self, template)\\n for r in self.get_resources(resource_type):\\n r.register_resources_template(template)\\n\\n template = utils.fix_troposphere_references(template)\\n\\n if template and template.resources:\\n output_filename = output_filename.format(self._get_next_build_sequence_id())\\n self.puts(colored.cyan(output_filename))\\n with open(os.path.join(self.build_path, output_filename), 'w') as f:\\n f.write(template.to_json())\",\n \"def process_singles(pk_type, single_files_path, out_path, skip_lines, encoding):\\n if single_files_path.startswith(\\\".\\\"):\\n return\\n\\n if os.path.isdir(single_files_path):\\n for path, _, files in os.walk(single_files_path):\\n for file_name in files:\\n if file_name.endswith(\\\".json\\\") or file_name.endswith(\\\".DS_Store\\\"):\\n continue\\n json_pk = collections.OrderedDict()\\n if file_name:\\n extension = file_name[file_name.rfind(\\\".\\\") + 1:]\\n if (hasattr(pk_type, \\\"pk_formats\\\") and\\n extension not in pk_type.pk_formats):\\n continue\\n filepath = os.path.join(path, file_name)\\n json_pk = create_script_dict(pk_type, filepath, file_name, skip_lines,\\n encoding)\\n write_out_scripts(json_pk, filepath, out_path)\\n else:\\n file_name = os.path.basename(single_files_path)\\n json_pk = create_script_dict(pk_type, single_files_path, file_name, skip_lines,\\n encoding)\\n write_out_scripts(json_pk, single_files_path, out_path)\",\n \"def return_template_output(base_dir,filename,data_dict):\\n templateLoader = jinja2.FileSystemLoader( searchpath=base_dir)\\n templateEnv = jinja2.Environment( loader=templateLoader )\\n template = templateEnv.get_template(filename)\\n output = template.render(data_dict)\\n return output\",\n \"def genConvOnboardingInfoJsonFile( sztpOnboardingInfo, onboardingFileJson ):\\n template = {\\n \\\"boot-image\\\": {\\n \\\"os-name\\\": str,\\n \\\"os-version\\\": str,\\n \\\"download-uri\\\": list, # of uri strings\\n \\\"image-verification\\\": [ {\\n \\\"hash-algorithm\\\": str,\\n \\\"hash-value\\\": str } ],\\n },\\n \\\"configuration-handling\\\": str,\\n \\\"pre-configuration-script\\\": str,\\n \\\"configuration\\\": str,\\n \\\"post-configuration-script\\\": str\\n }\\n\\n def verifyBootImage( template, sztpBootImage ):\\n \\\"\\\"\\\"Verify boot image is correct\\\"\\\"\\\"\\n def verifyImageVerification( imageVerification ):\\n \\\"\\\"\\\"Verify instance of image-verification is correct\\\"\\\"\\\"\\n if \\\"hash-algorithm\\\" in imageVerification:\\n assert imageVerification[ \\\"hash-algorithm\\\" ] == \\\\\\n \\\"ietf-sztp-conveyed-info:sha-256\\\",\\\\\\n \\\"Unsupported hash-algorithm\\\"\\n assert \\\"hash-value\\\" in imageVerification, \\\\\\n \\\"Expected hash-value not present\\\"\\n hashValue = imageVerification[ \\\"hash-value\\\" ]\\n # Verify hashValue appears to be a yang:hex-string\\n assert len( hashValue ) == 32 * 3 - 1 and \\\\\\n all( c == ':' or c in string.hexdigits for c in hashValue ), \\\\\\n \\\"hash-value invalid\\\"\\n\\n def verifyImageVerificationList( template, sztpImageVerification ):\\n \\\"\\\"\\\"Verify image-verification list is correct\\\"\\\"\\\"\\n assert isinstance( sztpImageVerification, list ), \\\\\\n \\\"Expected list\\\"\\n for imageVer in sztpImageVerification:\\n assert verifyDictTypes( template, imageVer ), \\\"Unexpected value types\\\"\\n assert set( imageVer.keys() ).issubset( set( template.keys() ) ), \\\\\\n \\\"Unexpected keys in dict\\\"\\n verifyImageVerification( imageVer )\\n\\n mandatory = [ \\\"download-uri\\\" ]\\n assert isinstance( sztpBootImage, dict ), \\\"Expected dict\\\"\\n assert set( sztpBootImage.keys() ).issubset( template.keys() ), \\\\\\n \\\"Unexpected keys in dict\\\"\\n assert verifyDictTypes( template, sztpBootImage ), \\\\\\n \\\"Unexpected value types\\\"\\n assert set( mandatory ).issubset( sztpBootImage ), \\\\\\n \\\"Mandatory keys not present\\\"\\n if \\\"image-verification\\\" in sztpBootImage:\\n verifyImageVerificationList( template[ \\\"image-verification\\\" ][ 0 ],\\n sztpBootImage[ \\\"image-verification\\\" ] )\\n\\n # verify onboarding-info dict is correctly constructed\\n assert isinstance( sztpOnboardingInfo, dict ), \\\"Expected dict\\\"\\n assert set( sztpOnboardingInfo.keys() ).issubset( template.keys() ), \\\\\\n \\\"Unexpected keys in dict\\\"\\n assert verifyDictTypes( template, sztpOnboardingInfo ), \\\\\\n \\\"Unexpected values types\\\"\\n assert sztpOnboardingInfo[ \\\"configuration-handling\\\" ] == \\\"replace\\\", \\\\\\n \\\"Unsupported configuration-handling value\\\"\\n if \\\"boot-image\\\" in sztpOnboardingInfo:\\n verifyBootImage( template[ \\\"boot-image\\\" ],\\n sztpOnboardingInfo[ \\\"boot-image\\\" ] )\\n\\n # construct outer dictionary and convert to json\\n ietfOnboardingInfo = { \\\"ietf-sztp-conveyed-info:onboarding-information\\\":\\n sztpOnboardingInfo }\\n jsonIetfOnboardingInfo = json.dumps( ietfOnboardingInfo, indent=4 )\\n\\n # save to file\\n with open( onboardingFileJson, \\\"w\\\" ) as tmpFile:\\n tmpFile.write( jsonIetfOnboardingInfo )\",\n \"def extract_template(temp_dir, fea_type):\\n kps = []\\n descriptors = np.array([])\\n in_path = temp_dir + 'imgs/' # images\\n names = os.listdir(in_path)\\n for i, name in enumerate(names):\\n img = cv2.imread(in_path + name, 0)\\n if any(np.array(img.shape) > 1000):\\n img = cv2.resize(img, None, fx=0.5, fy=0.5, interpolation=cv2.INTER_CUBIC)\\n print(img.shape)\\n kp, des = get_des(fea_type, img)\\n if descriptors.size == 0:\\n kps = kp\\n descriptors = des\\n else:\\n kps.extend(kp)\\n descriptors = np.vstack((descriptors, des))\\n\\n print(\\\"template descriptors shape: \\\" + str(descriptors.shape))\\n with open(temp_dir + fea_type + '_template_0.pickle', 'wb') as ff:\\n pickle.dump(descriptors, ff)\\n\\n # with open(temp_dir + fea_type + '_template_0.pickle', 'rb') as f:\\n # template = pickle.load(f)\\n\\n return\",\n \"def generate_terraform_script(tf_dir):\\n\\n tf_dir = Path(tf_dir)\\n if not tf_dir.is_dir():\\n raise TypeError\\n\\n tf_files = [\\n \\\"main\\\",\\n \\\"variables\\\",\\n \\\"backend\\\",\\n \\\"output\\\"\\n ]\\n\\n for file in tf_files:\\n tpl_file = Path(tf_dir, file + \\\".tf.tpl\\\")\\n tf_file = Path(tf_dir, file + \\\".tf\\\")\\n if tpl_file.exists():\\n tpl = jinja2.Template(tpl_file.read_text(encoding=\\\"utf-8\\\"))\\n content = tpl.render(config=config)\\n tf_file.write_text(content, encoding=\\\"utf-8\\\")\",\n \"def process(filename, exclude_dirs=['unittest','test',]):\\n print(\\\"Generating {}\\\".format(filename))\\n nb = 0\\n nb_err = 0\\n _main_root = os.path.dirname(filename)\\n _VFS = {}\\n for _mydir in (\\\"libs\\\", \\\"Lib\\\"):\\n for _root, _dir, _files in os.walk(os.path.join(_main_root, _mydir)):\\n #if _root.endswith('lib_migration'):\\n _flag=False\\n for _exclude in exclude_dirs:\\n if _exclude in _root: #_root.endswith(_exclude):\\n _flag=True\\n continue\\n if _flag:\\n continue # skip these modules\\n if '__pycache__' in _root:\\n continue\\n nb += 1\\n\\n for _file in _files:\\n _ext = os.path.splitext(_file)[1]\\n if _ext not in ('.js', '.py'):\\n continue\\n nb += 1\\n\\n with open(os.path.join(_root, _file), \\\"r\\\") as file_with_data:\\n _data = file_with_data.read()\\n \\n if len(_data) == 0:\\n print('no data for %s' % _file)\\n _data = unicode('')\\n print(_data, type(_data))\\n else:\\n _data = _data.decode('utf-8')\\n\\n if _ext in '.js':\\n if js_minify is not None:\\n try:\\n _data = js_minify(_data)\\n except Exception as error:\\n print(error)\\n elif _ext == '.py' and len(_data) > 0:\\n try:\\n _data = pyminifier.remove_comments_and_docstrings(_data)\\n _data = pyminifier.dedent(_data)\\n except Exception as error:\\n print(error)\\n nb_err += 1\\n\\n _vfs_filename = os.path.join(_root, _file).replace(_main_root, '')\\n _vfs_filename = _vfs_filename.replace(\\\"\\\\\\\\\\\", \\\"/\\\")\\n\\n if _vfs_filename.startswith('/libs/crypto_js/rollups/'):\\n if _file not in ('md5.js', 'sha1.js', 'sha3.js',\\n 'sha224.js', 'sha384.js', 'sha512.js'):\\n continue\\n\\n mod_name = _vfs_filename[len(_mydir) + 2:].replace('/', '.')\\n mod_name, ext = os.path.splitext(mod_name)\\n is_package = mod_name.endswith('__init__')\\n if is_package:\\n mod_name = mod_name[:-9]\\n _VFS[mod_name] = [ext, _data, 1]\\n else:\\n _VFS[mod_name] = [ext, _data]\\n print((\\\"adding %s %s\\\" % (mod_name, _vfs_filename)))\\n print('%s files, %s errors' % (nb, nb_err))\\n with open(filename, \\\"w\\\") as file_to_write_VFS:\\n file_to_write_VFS.write('__BRYTHON__.use_VFS = true;\\\\n')\\n file_to_write_VFS.write('__BRYTHON__.VFS=%s;\\\\n\\\\n' % json.dumps(_VFS))\",\n \"def generate_merged_file(json_path:str) -> dict:\\n filenames = os.listdir(json_path)\\n content_map = defaultdict(dict)\\n\\n for filename in filenames:\\n with open(os.path.join(json_path, filename)) as json_file:\\n data = json.load(json_file)\\n patientID = str(data['patient']['PatientID'])\\n studyUID = str(data['study']['StudyInstanceUID'])\\n studyDetails = data['study']\\n seriesDetails = data['series']\\n seriesInstanceUID = data['series']['SeriesInstanceUID']\\n\\n if(studyUID not in content_map[patientID]) :\\n content_map[patientID][studyUID]=studyDetails\\n \\n if('Series' not in content_map[patientID][studyUID] ):\\n content_map[patientID][studyUID]['Series']={}\\n content_map[patientID][studyUID]['Series'][seriesInstanceUID]=seriesDetails\\n content_map[patientID][studyUID]['Series'][seriesInstanceUID]['path'] = data['path']\\n content_map[patientID][studyUID]['Series'][seriesInstanceUID]['files'] = data['files']\\n\\n return content_map\",\n \"def generate_code_files(code_list: List[str], base: str) -> None:\\n for code in code_list:\\n parts = code.split(' ')\\n status = parts[0]\\n name = \\\" \\\".join(parts[1:])\\n path = os.path.join('codes', base, f'{status[0]}XX', f'{status}.json')\\n data = {\\n 'code': int(status),\\n 'name': name,\\n 'messages': []\\n }\\n with open(path, 'w') as jsonfile:\\n json.dump(data, jsonfile, indent=4)\",\n \"def transform(item_paths, output_dir, experiment_code, compresslevel=0):\\n aliquots_emitter = emitter('aliquot', output_dir=output_dir)\\n for line in reader('{}/sample.json'.format(output_dir)):\\n assert 'submitter_id' in line, line\\n aliquots_emitter.write(default_aliquot(line['submitter_id'], project_id=DEFAULT_PROJECT_ID))\\n aliquots_emitter.close()\",\n \"def load_umi_template(json_template):\\n if os.path.isfile(json_template):\\n with open(json_template) as f:\\n dicts = json.load(f, object_pairs_hook=OrderedDict)\\n\\n return [{key: json_normalize(value)} for key, value in dicts.items()]\\n else:\\n raise ValueError(\\\"File {} does not exist\\\".format(json_template))\",\n \"def processTemplates(self, tk, templateFile = '', id = '', shotNum = '', inprogressBar = ''):\\r\\n ## Now fetch all the template paths from shotgun\\r\\n getTemplatePaths = tk.paths_from_template(templateFile, {'Step' : 'Light', 'id' : id, 'Shot' : shotNum})\\r\\n debug(app = self, method = 'processTemplates', message = 'getTemplatePaths: %s' % getTemplatePaths, verbose = False)\\r\\n \\r\\n ## Now look for each assets template path: \\r\\n xmlFile = max(getTemplatePaths) \\r\\n debug(app = self, method = 'processTemplates', message = 'Max Version xmlFile.... %s' % xmlFile, verbose = False)\\r\\n \\r\\n ## Now if versions has stuff in it..\\r\\n if not xmlFile:\\r\\n debug(app = self, method = 'processTemplates', message = 'Can not find any xml files for %s' % shotNum, verbose = False)\\r\\n pass\\r\\n else:\\r\\n \\r\\n debug(app = self, method = 'processTemplates', message = 'PathTo: %s' % os.path.isfile(xmlFile.replace(os.path.sep, \\\"/\\\")), verbose = False)\\r\\n if os.path.isfile(xmlFile.replace(os.path.sep, \\\"/\\\")):## is this a valid xml file!?\\r\\n inprogressBar.updateProgress(percent = 10, doingWhat = 'createAll shaders...')\\r\\n self._createAllShaders(XMLPath = xmlFile.replace(os.path.sep, \\\"/\\\"), Namespace = '', Root = 'MaterialNodes')\\r\\n \\r\\n inprogressBar.updateProgress(percent = 30, doingWhat = 'connectAll shaders...')\\r\\n self._connectAllShaders(XMLPath = xmlFile.replace(os.path.sep, \\\"/\\\"), Namespace = '', Root = 'MaterialNodes')\\r\\n else:\\r\\n debug(app = self, method = 'processTemplates', message = 'FAILED Can not find a valid published xml file for %s ...' % os.path.isfile(xmlFile.replace(os.path.sep, \\\"/\\\")), verbose = False)\\r\\n pass\",\n \"def make_phys():\\n for rn in dcm_dict.keys():\\n # PPG\\n if not dcm_dict[rn]['ppg_file'] == 'File missing':\\n # Files\\n ppg_tsv = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.tsv.gz')\\n ppg_json = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.json')\\n # TSV\\n gzip_file(dcm_dict[rn]['ppg_file'],ppg_tsv)\\n # JSON\\n data = OrderedDict()\\n data['SamplingFrequency'] = 100.0\\n data['StartTime'] = -30.0\\n data['Columns'] = 'cardiac'\\n with open(ppg_json, 'w') as ff:\\n json.dump(data, ff,sort_keys=False, indent=4)\\n # Respiration\\n if not dcm_dict[rn]['resp_file'] == 'File missing':\\n # Files\\n resp_tsv = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-respiratory.tsv.gz')\\n resp_json = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-respiratory.json')\\n # TSV\\n gzip_file(dcm_dict[rn]['resp_file'],resp_tsv)\\n # JSON\\n data = OrderedDict()\\n data['SamplingFrequency'] = 25.0\\n data['StartTime'] = -30.0\\n data['Columns'] = 'respiratory'\\n with open(resp_json, 'w') as ff:\\n json.dump(data, ff,sort_keys=False, indent=4)\\n # ECG\\n # What to do if they have PPG and ECG?\\n if not dcm_dict[rn]['ecg_file'] == 'File missing':\\n # Files\\n ecg_tsv = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.tsv.gz')\\n ecg_json = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.json')\\n # TSV\\n gzip_file(dcm_dict[rn]['resp_file'],resp_tsv)\\n # JSON\\n data = OrderedDict()\\n data['SamplingFrequency'] = 1000.0\\n data['StartTime'] = -30.0\\n data['Columns'] = 'cardiac'\\n with open(resp_json, 'w') as ff:\\n json.dump(data, ff,sort_keys=False, indent=4)\",\n \"def main():\\n\\t# import training data\\n\\tfiles = [INPATH + f for f in os.listdir(INPATH) if \\\".json\\\" in f]\\n\\n\\t# import books\\n\\tprint(\\\"Loading training data...\\\")\\n\\tbookList = loadBooks(files)\\n\\tprint(\\\"Load complete.\\\")\\n\\n\\t# loop through element types and store data structure\\n\\tfor key, value in ELEMENTS.items():\\n\\t\\tprint(\\\"Generating: %s\\\" % key)\\n\\n\\t\\t# set file outpath\\n\\t\\toutfile = \\\"%s.json\\\" % key\\n\\t\\toutpath = OUTPATH % outfile\\n\\n\\t\\tgenerateTrain(bookList, key, value, outpath)\",\n \"def main():\\n print \\\"=\\\" * 78\\n print \\\"%s %s\\\" % (__prog_name__, __version__)\\n debug, input_file_names = check_cli()\\n if not input_file_names:\\n _error(\\\"No input file name found!\\\\n\\\\n%s\\\" % __help__)\\n for input_file_name in input_file_names:\\n print \\\"* Reading\\\", input_file_name\\n file_base_name = os.path.splitext(os.path.basename(input_file_name))[0]\\n file_dir_name = os.path.dirname(input_file_name)\\n sections = {}\\n tex_map = {}\\n with open(input_file_name, 'rU') as in_fd:\\n sections = get_sections(in_fd.read())\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"sec\\\",\\n {\\\"sections\\\": sections})\\n\\n if not sections:\\n _error(\\\"Nothing could be read from '%s'.\\\\nIs this an Oolite .dat file?\\\" \\\\\\n % input_file_name)\\n\\n # Magically call the 'check' functions\\n for name in sections.keys():\\n f_name = \\\"check_%s\\\" % name.lower()\\n if f_name in globals().keys():\\n if not globals()[f_name](sections):\\n _error(\\\"Number of entries in '%s' section is different as declared!\\\" % name)\\n\\n def get_data(name, sections=sections):\\n \\\"\\\"\\\"Returns the 'data' object from the 'name' one found in the\\n 'sections' one.\\n :sections: dictionary: Object returned by 'get_sections'.\\n :name: string: The name of the section to get the 'data'.\\n Returns a list of 'lines'.\\n \\\"\\\"\\\"\\n return sections.get(name, {}).get(\\\"data\\\", [])\\n\\n oti_file_name = build_file_path(file_dir_name, file_base_name, \\\"oti\\\")\\n tex_map = parse_names(get_data(\\\"NAMES\\\"), oti_file_name)\\n\\n tex_refs, tex_lines_out = parse_textures(get_data(\\\"TEXTURES\\\"))\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"tex\\\",\\n {\\\"tex_refs\\\": tex_refs,\\n \\\"tex_lines_out\\\": tex_lines_out})\\n\\n # Update the tex_map object if textures indexes and names are both\\n # used in 'TEXTURES'.\\n if sorted(tex_map.keys()) != sorted(tex_refs.get(\\\"named\\\").keys()):\\n tex_map = update_tex_map(tex_map,\\n set(tex_refs[\\\"named\\\"].keys()).difference(tex_map.keys()))\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"txm\\\",\\n {\\\"tex_map\\\": tex_map})\\n\\n n_verts, vertex_lines_out = parse_vertex(get_data(\\\"VERTEX\\\"))\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"ver\\\",\\n {\\\"n_verts\\\": n_verts,\\n \\\"vertex_lines_out\\\": vertex_lines_out})\\n\\n n_normals, normals_lines_out = parse_normals(get_data(\\\"NORMALS\\\"))\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"nor\\\",\\n {\\\"n_normals\\\": n_normals,\\n \\\"normals_lines_out\\\": normals_lines_out})\\n\\n n_faces, faces_groups = parse_faces(get_data(\\\"FACES\\\"), tex_refs,\\n normals_lines_out)\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"fac\\\",\\n {\\\"n_faces\\\": n_faces,\\n \\\"faces_groups\\\": faces_groups})\\n\\n output_file_name = build_file_path(file_dir_name,\\n file_base_name, 'obj')\\n material_file_name = build_file_path(file_dir_name,\\n file_base_name, 'mtl')\\n mtl_lib_file = os.path.basename(material_file_name)\\n\\n write_obj(output_file_name, file_base_name, mtl_lib_file,\\n tex_lines_out, tex_map, n_verts, vertex_lines_out,\\n n_normals, normals_lines_out, n_faces, faces_groups)\\n\\n write_mtl(material_file_name, tex_map)\\n\\n _exit(\\\"* Done\\\")\",\n \"def run(xml_files, gold_files, json_output):\\n result = harvest_multi(xml_files, gold_files)\\n with open(json_output, 'w') as writer:\\n writer.write(json.dumps(result, indent=4))\",\n \"def generate_template():\\n date = input(\\\"What day is the template for? dd/mm/yy: \\\")\\n day = input(\\\"What day of the week is this?: \\\")\\n if \\\"/\\\" not in date:\\n date_components = [date[0:2], date[2:4], date[4:]]\\n else:\\n date_components = date.split(\\\"/\\\")\\n file_name = \\\"{}{}{}.table\\\".format(date_components[0], date_components[1], date_components[2])\\n try:\\n template_file = open(\\\"templates/{}_template.table\\\".format(day), \\\"r\\\")\\n except IOError:\\n print(\\\"source template not found\\\")\\n else:\\n source_lines = []\\n output_file = open(file_name, \\\"w\\\")\\n for line in template_file:\\n source_lines.append(line)\\n output_file.write(line)\\n print(\\\"template generated successfully for: {} on date: {}\\\".format(day, date))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6439445","0.6329011","0.6317232","0.6279043","0.62260956","0.60334027","0.60176724","0.60137415","0.60113746","0.59920955","0.59756476","0.5974208","0.59657097","0.5964929","0.596335","0.59502697","0.5911967","0.58968824","0.5894371","0.5880914","0.5866251","0.58544195","0.58524317","0.58441496","0.58436096","0.583087","0.58117115","0.58018965","0.57854754","0.57762945","0.57761085","0.5768995","0.5759922","0.5734327","0.57248074","0.5706267","0.56916857","0.56593627","0.5651359","0.56511825","0.56452835","0.5628107","0.56221753","0.56066215","0.5604287","0.56030786","0.5597787","0.55963796","0.55944","0.5588766","0.5585057","0.55739784","0.5558292","0.555253","0.5550544","0.5547165","0.5545617","0.5540452","0.5525974","0.5521792","0.5520457","0.55140394","0.5507637","0.5506572","0.5505393","0.5500769","0.54970646","0.5485269","0.54832536","0.54603773","0.5442154","0.5435592","0.54355514","0.5431945","0.54274845","0.5427051","0.5423942","0.5420298","0.54143894","0.54129344","0.54091245","0.5407957","0.54066634","0.53957635","0.5389391","0.53835183","0.53804857","0.5377209","0.53699195","0.53621966","0.53544056","0.53528774","0.5346677","0.5346578","0.5343472","0.5340717","0.5323621","0.53207374","0.5318976","0.5318526"],"string":"[\n \"0.6439445\",\n \"0.6329011\",\n \"0.6317232\",\n \"0.6279043\",\n \"0.62260956\",\n \"0.60334027\",\n \"0.60176724\",\n \"0.60137415\",\n \"0.60113746\",\n \"0.59920955\",\n \"0.59756476\",\n \"0.5974208\",\n \"0.59657097\",\n \"0.5964929\",\n \"0.596335\",\n \"0.59502697\",\n \"0.5911967\",\n \"0.58968824\",\n \"0.5894371\",\n \"0.5880914\",\n \"0.5866251\",\n \"0.58544195\",\n \"0.58524317\",\n \"0.58441496\",\n \"0.58436096\",\n \"0.583087\",\n \"0.58117115\",\n \"0.58018965\",\n \"0.57854754\",\n \"0.57762945\",\n \"0.57761085\",\n \"0.5768995\",\n \"0.5759922\",\n \"0.5734327\",\n \"0.57248074\",\n \"0.5706267\",\n \"0.56916857\",\n \"0.56593627\",\n \"0.5651359\",\n \"0.56511825\",\n \"0.56452835\",\n \"0.5628107\",\n \"0.56221753\",\n \"0.56066215\",\n \"0.5604287\",\n \"0.56030786\",\n \"0.5597787\",\n \"0.55963796\",\n \"0.55944\",\n \"0.5588766\",\n \"0.5585057\",\n \"0.55739784\",\n \"0.5558292\",\n \"0.555253\",\n \"0.5550544\",\n \"0.5547165\",\n \"0.5545617\",\n \"0.5540452\",\n \"0.5525974\",\n \"0.5521792\",\n \"0.5520457\",\n \"0.55140394\",\n \"0.5507637\",\n \"0.5506572\",\n \"0.5505393\",\n \"0.5500769\",\n \"0.54970646\",\n \"0.5485269\",\n \"0.54832536\",\n \"0.54603773\",\n \"0.5442154\",\n \"0.5435592\",\n \"0.54355514\",\n \"0.5431945\",\n \"0.54274845\",\n \"0.5427051\",\n \"0.5423942\",\n \"0.5420298\",\n \"0.54143894\",\n \"0.54129344\",\n \"0.54091245\",\n \"0.5407957\",\n \"0.54066634\",\n \"0.53957635\",\n \"0.5389391\",\n \"0.53835183\",\n \"0.53804857\",\n \"0.5377209\",\n \"0.53699195\",\n \"0.53621966\",\n \"0.53544056\",\n \"0.53528774\",\n \"0.5346677\",\n \"0.5346578\",\n \"0.5343472\",\n \"0.5340717\",\n \"0.5323621\",\n \"0.53207374\",\n \"0.5318976\",\n \"0.5318526\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.80537117"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93199,"cells":{"query":{"kind":"string","value":"Renames .json files for height files that have too steep gradients for driving. Due to tunnels in mountatin roads, sometimes the surface elevation at a road does not correspond to the actual road elevation. Therefore, the heightmap may be that of a road trying to climb an _actual_ mountain. This is undesired behaviour (well, unless we have a part car/part mounatin goat) and these heighmaps should be seeded out. This function renames the .json files with too steep height map files."},"document":{"kind":"string","value":"def seed_out_too_steep(config_folder_path, max_gradient):\n\n import pathlib\n import os\n\n path_to_match = pathlib.Path(config_folder_path)\n\n for config_file in path_to_match.glob(\"*.json\"):\n config_filename = str(config_file)\n json_config = get_inputs_from_file(config_filename)\n try:\n elevation_file = json_config[\"elevation_file\"]\n elev_list, dist_list = get_lists_from_file(elevation_file)\n elev_list, dist_list = average_double_pts(elev_list, dist_list)\n if exceeds_max_gradient(elev_list, dist_list, max_gradient):\n print(\"Too steep slope in {}, renaming\".format(config_file))\n os.rename(config_filename, config_filename + \"_too_steep_slope\")\n else:\n print(\"{} is ok\".format(config_file))\n\n except (AttributeError, KeyError) as e:\n print('No attribute \"elevation file\" for {}. Skipping with exception:\\n {}'.format(config_file, e))\n except (FileNotFoundError) as e:\n print(\"File not found, exception:\\n {}\".format(e))\n except Exception as e:\n print(\"some odd exception :( \\n {}\".format(e))"},"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 renamefile(filename):\n new_data_list = []\n with open(filename, 'r') as f:\n data_list = f.read().split('\\n')\n\n print('Generating new data list..')\n for data in tqdm(data_list):\n if len(data) == 0:\n continue\n data_info = data.split(' ')\n\n #data_info[0] = data_info[0].replace('jpg', 'png')\n #data_info[1] = data_info[1].replace('jpg', 'png')\n for it, name in enumerate(data_info):\n data_info[it] = '/'.join(name.split('/')[1:])\n if data_info[2].find('extras') == -1:\n new_data_list.append(' '.join(data_info))\n\n with open(filename, 'w') as f:\n print('writing new data names..')\n\n for it, data in tqdm(enumerate(new_data_list)):\n if len(data) == 0:\n continue\n\n if it == len(new_data_list)-1:\n f.write(data)\n else:\n f.write(data+'\\n')\n\n print('Done.')","def rename_water_atoms( pdb_filename, O_name = 'O', H1_name = 'H1', H2_name = 'H2' ):\n\n parmed = import_(\"parmed\")\n\n pdb = parmed.load_file( pdb_filename )\n\n #Find waters and rename\n for residue in pdb.residues:\n if len(residue)==3:\n #Build list of atom types (PDB files don't store these) from names after stripping off digits\n types = []\n for atom in residue.atoms:\n name = atom.name\n while name[-1].isdigit():\n name = name[:-1]\n types.append(name)\n #See if it's water and, if so, rename\n if 'O' in types and types.count('H')==2:\n hct = 0\n for atom in residue.atoms:\n if 'O' in atom.name:\n atom.name = O_name\n elif 'H' in atom.name:\n if hct==0:\n atom.name = H1_name\n else:\n atom.name = H2_name\n hct+=1\n\n #Write file\n pdb.write_pdb( pdb_filename )","def _change_name(self, suff, info_extra):\n if 'cable-ring' in self.path:\n i1 = info_extra['convex_hull_area']\n i2 = info_extra['best_possible_area']\n f = i1 / i2\n suff = suff.replace('.png',\n f'-area-{i1:0.3f}-best-{i2:0.3f}-FRAC-{f:0.3f}.png')\n elif 'cloth-flat' in self.path:\n i1 = info_extra['cloth_coverage']\n suff = suff.replace('.png', f'-coverage-{i1:0.3f}.png')\n elif 'bag-alone' in self.path:\n i1 = info_extra['convex_hull_area']\n i2 = info_extra['best_possible_area']\n suff = suff.replace('.png', f'-area-{i1:0.3f}-best-{i2:0.3f}.png')\n else:\n pass\n return suff","def minify_json(self) -> None:\n print(f\"[FileManager: INFO] Minifing file {self.path}\")\n file_data = open(self.path, \"r\", encoding=\"utf-8\").read()\n json_data = json.loads(file_data) \n json_string = json.dumps(json_data, separators=(',', \":\")) \n path = str(self.path).replace(\".json\", \"\")\n new_path = \"{0}_min.json\".format(path)\n open(new_path, \"w+\", encoding=\"utf-8\").write(json_string)","def fix_jsons_in(bids_dir: Path):\n\n print(\"Finalizing task json files.\")\n\n for path in bids_dir.rglob(\"func/*_task-*.json\"):\n append_to_json_file(key=\"TaskName\", value=task_name_of(path), path_to_json=path)\n\n print(\"Appending echo times to phase difference json files.\")\n\n for path in bids_dir.rglob(\"fmap/*_phasediff.json\"):\n magnitude1_path = the_path_that_matches(pattern=\"sub-*_magnitude1.json\", in_directory=path.parent)\n magnitude2_path = the_path_that_matches(pattern=\"sub-*_magnitude2.json\", in_directory=path.parent)\n echo_time1 = value_of_key_in_json_file(\"EchoTime\", magnitude1_path)\n echo_time2 = value_of_key_in_json_file(\"EchoTime\", magnitude2_path)\n append_to_json_file(key=\"EchoTime1\", value=echo_time1, path_to_json=path)\n append_to_json_file(key=\"EchoTime2\", value=echo_time2, path_to_json=path)\n\n print(\"Setting targets of fieldmap json files.\")\n\n for path in bids_dir.rglob(\"fmap/*.json\"):\n func_dir = path.parent.parent / \"func\"\n trimmed_func_paths = [\"func/\" + func_path.name for func_path in func_dir.glob(\"*.nii\")]\n append_to_json_file(key=\"IntendedFor\", value=trimmed_func_paths, path_to_json=path)","def fileRenameandReplace(filename,newfilename):\n try:\n os.rename(filename,newfilename)\n logging.info(\"Json file renamed in PD path\")\n except Exception as er:\n print (\"Not able to rename the json file \")\n return False","def waste_water(osm_path): \n return (retrieve(osm_path,'multipolygons',['man_made'],**{'man_made':[\"='wastewater_plant'\"]})).rename(columns={'man_made': 'asset'})","def rename_outputs(size, i, format):\n for k in range(size):\n src_name = 'out' + str(k) + '.png'\n dst_name = 'objective' + str(i) + '_' + format + '.png'\n os.rename(src_name, dst_name)","def process_files_json():\n # chdir into beep root\n pwd = os.getcwd()\n os.chdir(os.environ.get(\"BEEP_ROOT\", \"/\"))\n\n meta_list = list(filter(lambda x: '_Metadata.csv' in x, os.listdir(SRC_DIR)))\n file_list = list(filter(lambda x: '.csv' in x if x not in meta_list else None, os.listdir(SRC_DIR)))\n all_list = list(filter(lambda x: '.csv' in x, os.listdir(SRC_DIR)))\n\n all_list = sorted(all_list)\n dumpfn(all_list, \"all_files.json\")\n\n [file_id, mapdf] = init_map(PROJECT_NAME, DEST_DIR)\n\n new_file_index = file_id\n\n for filename in tqdm(sorted(file_list)):\n # If the file has already been renamed another entry should not be made\n if mapdf['filename'].str.contains(filename).sum() > 0:\n continue\n old_file = os.path.join(SRC_DIR, filename)\n new_path = os.path.join(DEST_DIR, PROJECT_NAME)\n shutil.copy(old_file, new_path) # copy main data file\n shutil.copy(old_file.replace(\".csv\", '_Metadata.csv'), new_path) # copy meta data file\n\n if PROJECT_NAME == 'FastCharge':\n [date, channel_no, strname, protocol] = get_parameters_fastcharge(filename, SRC_DIR)\n elif PROJECT_NAME == 'ClosedLoopOED':\n [date, channel_no, strname, protocol] = get_parameters_oed(filename, SRC_DIR)\n else:\n raise ValueError(\"Unsupported PROJECT_NAME: {}\".format(PROJECT_NAME))\n\n df_dup = mapdf.set_index(['protocol', 'date'])\n if (protocol, date) in df_dup.index:\n row = mapdf[(mapdf['protocol'] == protocol) & (mapdf['date'] == date)]\n file_id = row['fid'].iloc[0]\n protocol = row['protocol'].iloc[0]\n date = row['date'].iloc[0]\n strname = row['strname'].iloc[0]\n else:\n file_id = new_file_index\n new_file_index = new_file_index + 1\n\n new_name = \"{}_{}_{}\".format(PROJECT_NAME, f'{file_id:06}', channel_no)\n new_file = os.path.join(DEST_DIR, PROJECT_NAME, \"{}.csv\".format(new_name))\n\n new_row = pd.DataFrame([[file_id, protocol, channel_no, date, strname,\n os.path.abspath(old_file),\n os.path.abspath(new_file)]],\n columns=METADATA_COLUMN_NAMES)\n mapdf = mapdf.append(new_row)\n\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename), new_file)\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename).replace(\".csv\", \"_Metadata.csv\"),\n new_file.replace(\".csv\", \"_Metadata.csv\"))\n\n mapdf.to_csv(os.path.join(DEST_DIR, PROJECT_NAME, PROJECT_NAME + \"map.csv\"), index=False)\n mapdf = mapdf.reset_index(drop=True)\n os.chdir(pwd)\n return json.dumps(mapdf.to_dict(\"list\"))","def update_mapper_file(model_name):\n # only update female array, males always die :(\n with open('../src/mapper/mapper.py', 'w') as output_file:\n with open('../src/mapper/mapper_template.py', 'r') as input_file:\n for line in input_file:\n if \"female_survival_table =\" in line:\n insert_string = \" female_survival_table = \"\n if model_name == \"model2\":\n insert_string += (\"[[0, 0, 1, 1],\" +\n \" [0, 1, 1, 1], [1, 1, 0, 0]]\\n\")\n else:\n insert_string += (\"[[1, 1, 1, 1],\" +\n \" [1, 1, 1, 1], [1, 1, 1, 1]]\\n\")\n output_file.write(insert_string)\n else:\n output_file.write(line)","def changeFilenames(reduced, path, input):\n file = path + '/' + input\n data = open(file, 'r').readlines()\n os.remove(file)\n\n fh = open(file, 'w')\n for line in data:\n if 'includegraphics' in line:\n for key in reduced:\n if key in line:\n new = line.replace(key, reduced[key])\n fh.write(new)\n\n logging.debug('Changed {0:>s} to {1:>s} '.format(line, new))\n else:\n fh.write(line)\n\n fh.close()","def rename(source_dir,dest_dir):\n keep_going(text=\"This script will backup the original folder to dest_dir/Source/** and remove the original folder. It will make copies of the original files and rename them in directories called Darks, Flats, etc. Do you wish to continue? Answer Y or N.\")\n\n ## Backup Original Source Folder\n dir_util.copy_tree(source_dir, dest_dir + '/Source')\n\n data = []\n for file in os.listdir(\"./\" + source_dir): # put in your path directory\n if file.endswith(\".fits\"): # what does the file end with?\n data.append(os.path.join(source_dir, file))\n\n n = len(data)\n obj, itime, filt, renamed, datemod, count, flatmod, mod = ([] for i in range(8))\n for i in range(0, n):\n header = fits.getheader(data[i])\n Name, Date, Number, Ext = data[i].split(\".\")\n obj.append(header['OBJECT'])\n itime.append(header['ITIME'])\n filt.append(header['FWINAME'])\n mod.append((header['OBJECT'] + header['FWINAME']))\n flatmod.append((header['OBJECT'] + header['FWINAME'] + Date))\n datemod.append(datetime.strptime(Date, \"%Y%m%d\").date())\n if flatmod[i] in flatmod:\n count = flatmod.count(flatmod[i])\n if ('Lamp' in obj[i] or 'Flat' in obj[i]):\n renamed.append((dest_dir + '/Flats/' + str(datemod[i]) + '/' + 'K' + header['OBJECT'] + str(count) + \".fits\"))\n os.makedirs(os.path.dirname(dest_dir + '/Flats/' + str(datemod[i]) + '/'), exist_ok=True)\n elif ('Dark' in obj[i]) or ('dark' in obj[i]):\n renamed.append((dest_dir + '/Darks/' + str(datemod[i]) + '/' + 'K' + header['OBJECT'] + str(count) + \".fits\"))\n os.makedirs(os.path.dirname(dest_dir + '/Darks/' + str(datemod[i]) + '/'), exist_ok=True)\n elif ('Sky' in obj[i]) or ('sky' in obj[i]):\n renamed.append((dest_dir + '/Skys/' + str(datemod[i]) + '/' + 'K' + header['OBJECT'] + header['FWINAME'] + str(\n count) + \".fits\"))\n os.makedirs(os.path.dirname(dest_dir + '/Skys/' + str(datemod[i]) + '/'), exist_ok=True)\n else:\n renamed.append((dest_dir + '/Objects/' + header['OBJECT'].upper() + '/' + str(datemod[i]) + '/' + 'K' + list(header['CAMNAME'])[0].title() + header['OBJECT'].upper() +\n header['FWINAME'] + str(\n count) + \".fits\"))\n os.makedirs(os.path.dirname(dest_dir + '/Objects/' + header['OBJECT'].upper() + '/' + str(datemod[i]) + '/'), exist_ok=True)\n os.rename(data[i], renamed[i])\n\n ## REMOVE LEFT OVER original Folders\n shutil.rmtree(source_dir)\n\n lists = [data, mod, datemod, itime, flatmod, renamed]\n data_headers = pd.concat([pd.Series(x) for x in lists], axis=1)\n\n return data_headers","def map_county_data_difference(party_12, party_16, outname, county_svg):\n county_svg = open(county_svg, 'r').read()\n county_data = csv.reader(open('processed_data.csv'), delimiter = \",\")\n \n soup = BeautifulSoup(county_svg, \"html.parser\")\n paths = soup.findAll('path')\n blue_red = ['#999999','#EC0517','#DA092E','#C70E46','#B5135D','#A21774','#901C8B','#7D20A2','#6B25B9','#582AD1','#462EE8','#3333FF', '#FFFFFF']\n # County style\n path_style = 'font-size:12px;fill-rule:nonzero;stroke:#FFFFFF;stroke-opacity:1; stroke-width:0.1;stroke-miterlimit:4;stroke-dasharray:none;stroke-linecap:butt; marker-start:none;stroke-linejoin:bevel;fill:'\n\n for p in paths:\n if p['id'] not in ['State_Lines', 'separator']:\n #print(str(p['id']))\n try:\n rate = party_12[int(p['id'])]\n rate2 = party_16[int(p['id'])]\n except: \n continue\n if rate == 'red' and rate2 == 'blue':\n color_class = 9\n elif rate == 'blue' and rate2 == 'red':\n color_class = 1\n else:\n color_class = 0\n \n color = blue_red[color_class]\n p['style'] = path_style + color\n \n f = open(outname, 'w')\n f.write(soup.prettify())\n f.close()","def mark_bad(imgID_list, side='blue'):\r\n\r\n assert (side in ['blue', 'red'])\r\n try:\r\n for num in imgID_list:\r\n name = '{:s}{:04d}.fits'.format(side, num)\r\n os.rename(name, name+'.bad')\r\n except TypeError:\r\n # single number\r\n num = imgID_list\r\n name = '{:s}{:04d}.fits'.format(side, num)\r\n os.rename(name, name+'.bad')","def anonymize(data_dir):\n\n for root, dirs, files in os.walk(dst_data_dir, topdown=False):\n for dir_name in sorted(dirs):\n dir_path = os.path.join(root, dir_name)\n json_path = os.path.join(root, dir_name, 'data.json')\n print(json_path)\n\n with open(json_path) as f:\n data = json.load(f)\n\n data.pop('user_email')\n data.pop('user_name')\n data.pop('survey_data')\n\n with open(json_path, 'w') as f:\n json.dump(data, f)","def cmip6_renaming_dict():\n # I could probably simplify this with a generalized single dict, \n # which has every single possible `wrong` name and then for each model\n # the renaming function just goes through them...\n dim_name_dict = {\n \"AWI-CM-1-1-MR\":{},\n \"BCC-CSM2-MR\": {\n \"x\": \"lon\",\n \"y\": \"lat\",\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"bnds\":\"bnds\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n \"vertex\": None,\n 'time_bounds': \"time_bnds\",\n },\n \"BCC-ESM1\": {\n \"x\": \"lon\",\n \"y\": \"lat\",\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"bnds\":\"bnds\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n \"vertex\": \"vertex\",\n 'time_bounds': \"time_bnds\",\n },\n \"CAMS-CSM1-0\": {\n \"x\": [\"i\", 'lon'],\n \"y\": [\"j\", 'lat'],\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": None,\n \"lat_bounds\": None,\n \"vertex\": 'vertices',\n 'time_bounds': \"time_bnds\",\n },\n \"CanESM5\": {\n \"x\": [\"i\", 'lon'],\n \"y\": [\"j\", 'lat'],\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": None,\n \"lat_bounds\": None,\n \"time_bounds\": \"time_bnds\",\n \"vertex\": \"vertices\",\n },\n \"CanESM5-CanOE\": {\n \"x\": \"i\",\n \"y\": \"j\",\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": 'vertices_longitude',\n \"lat_bounds\": 'vertices_latitude',\n \"vertex\": \"vertices\",\n },\n \"CNRM-CM6-1\": {\n \"x\": [\"x\", 'lon'],\n \"y\": [\"y\", 'lat'],\n \"lon\": \"lon\",\n \"lat\": \"lat\",\n \"lev\": \"lev\",\n \"bnds\": \"axis_nbounds\",\n \"lev_bounds\": \"lev_bounds\",\n \"lon_bounds\": \"bounds_lon\",\n \"lat_bounds\": \"bounds_lat\",\n 'vertex': \"nvertex\",\n 'time_bounds': \"time_bnds\",\n },\n \"CNRM-ESM2-1\": {\n \"x\": [\"x\", \"lon\"],\n \"y\": [\"y\", \"lat\"],\n \"lon\": \"lon\",\n \"lat\": \"lat\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bounds\",\n \"lon_bounds\": \"bounds_lon\",\n \"lat_bounds\": \"bounds_lat\",\n \"bnds\":\"axis_nbounds\",\n 'vertex': None,\n 'time_bounds': \"time_bnds\",\n },\n \"E3SM-1-0\": {\n \"x\": \"lon\",\n \"y\": \"lat\",\n \"lon\": None,\n \"lat\": None,\n \"lev\": \"lev\",\n \"bnds\":\"bnds\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n \"time_bounds\":\"time_bounds\",\n 'vertex': None,\n },\n \"E3SM-1-1\": {\n \"x\": \"lon\",\n \"y\": \"lat\",\n \"lon\": None,\n \"lat\": None,\n \"lev\": \"lev\",\n \"bnds\":\"bnds\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n \"time_bounds\":\"time_bounds\",\n 'vertex': None,\n },\n \"E3SM-1-1-ECA\": {\n \"x\": \"lon\",\n \"y\": \"lat\",\n \"lon\": None,\n \"lat\": None,\n \"lev\": \"lev\",\n \"bnds\":\"bnds\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n \"time_bounds\":\"time_bounds\",\n 'vertex': None,\n },\n \"EC-Earth3-LR\": {\n \"x\": [\"i\", 'lon'],\n \"y\": [\"j\", 'lat'],\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": None,\n \"lat_bounds\": None,\n 'time_bounds': \"time_bnds\",\n # 'vertex': 'vertices',\n # 'dzt': 'thkcello',\n },\n \"EC-Earth3-Veg\": {\n \"x\": [\"i\", 'lon'],\n \"y\": [\"j\", 'lat'],\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": None,\n \"lat_bounds\": None,\n 'vertex': 'vertices',\n 'time_bounds': \"time_bnds\",\n # 'dzt': 'thkcello',\n },\n \"EC-Earth3\": {\n \"x\": [\"i\", 'lon'],\n \"y\": [\"j\", 'lat'],\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": None,\n \"lat_bounds\": None,\n 'time_bounds': \"time_bnds\",\n # 'vertex': 'vertices',\n # 'dzt': 'thkcello',\n },\n \"FGOALS-f3-L\": {\n \"x\": [\"i\", 'lon'],\n \"y\": [\"j\", 'lat'],\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": None,\n \"lat_bounds\": None,\n 'time_bounds': \"time_bnds\",\n # 'vertex': 'vertices',\n # 'dzt': 'thkcello',\n },\n \"NICAM16-7S\": {\n \"x\": \"lon\",\n \"y\": \"lat\",\n \"lon\": None,\n \"lat\": None,\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n \"time_bounds\": \"time_bnds\",\n 'vertex': 'vertices',\n },\n \"MIROC-ES2L\": {\n \"x\": [\"x\", 'lon'],\n \"y\": [\"y\", 'lat'],\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": [\"lev\", \"zlev\"],\n \"lev_bounds\": [\"lev_bnds\", \"zlev_bnds\"],\n \"lon_bounds\": \"x_bnds\",\n \"lat_bounds\": \"y_bnds\",\n \"time_bounds\": \"time_bnds\",\n 'vertex': 'vertices',\n },\n \"MIROC6\": {\n \"x\": [\"x\", 'lon'],\n \"y\": [\"y\", 'lat'],\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"x_bnds\",\n \"lat_bounds\": \"y_bnds\",\n 'time_bounds': \"time_bnds\",\n },\n \"HadGEM3-GC31-LL\": {\n \"x\": [\"i\", 'lon'],\n \"y\": [\"j\", 'lat'],\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bounds\",\n \"lon_bounds\": None,\n \"lat_bounds\": None,\n 'time_bounds': \"time_bnds\",\n },\n \"HadGEM3-GC31-MM\": {\n \"x\": [\"i\", 'lon'],\n \"y\": [\"j\", 'lat'],\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bounds\",\n \"lon_bounds\": None,\n \"lat_bounds\": None,\n 'time_bounds': \"time_bnds\",\n },\n \"UKESM1-0-LL\": {\n \"x\": [\"i\", 'lon'],\n \"y\": [\"j\", 'lat'],\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": None,\n \"lat_bounds\": None,\n \"time_bounds\":\"time_bnds\",\n # 'vertex': 'vertices',\n # 'dzt': 'thkcello',\n },\n 'GISS-E2-2-G': { \n \"x\": \"lon\",\n \"y\": \"lat\",\n \"lon\": None,\n \"lat\": None,\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n 'vertex': None,\n 'time_bounds': \"time_bnds\",\n },\n \"GISS-E2-1-G-CC\": {\n \"x\": \"lon\",\n \"y\": \"lat\",\n \"lon\": None,\n \"lat\": None,\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n 'vertex': None,\n 'time_bounds': \"time_bnds\",\n },\n \"GISS-E2-1-G\": {\n \"x\": \"lon\",\n \"y\": \"lat\",\n \"lon\": None,\n \"lat\": None,\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n 'vertex': None,\n 'time_bounds': \"time_bnds\",\n },\n \"GISS-E2-1-H\": {\n \"x\": \"lon\",\n \"y\": \"lat\",\n \"lon\": None,\n \"lat\": None,\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n 'vertex': None,\n 'time_bounds': \"time_bnds\",\n },\n \"CESM1-1-CAM5-CMIP5\": {\n \"x\": [\"nlon\", \"lon\"],\n \"y\": [\"nlat\", \"lat\"],\n \"lon\": \"lon\",\n \"lat\": \"lat\",\n \"lev\": \"lev\",\n \"bnds\":\"d2\",\n \"time_bounds\":\"time_bnds\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n 'vertex': 'vertices',\n },\n \"CESM2-WACCM\": {\n \"x\": [\"nlon\", \"lon\"],\n \"y\": [\"nlat\", \"lat\"],\n \"lon\": \"lon\",\n \"lat\": \"lat\",\n \"lev\": \"lev\",\n \"bnds\":\"d2\",\n \"time_bounds\":\"time_bnds\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n 'vertex': 'vertices',\n },\n \"CESM2-WACCM-FV2\": {\n \"x\": [\"nlon\", \"lon\"],\n \"y\": [\"nlat\", \"lat\"],\n \"lon\": \"lon\",\n \"lat\": \"lat\",\n \"lev\": \"lev\",\n \"bnds\":\"d2\",\n \"time_bounds\":\"time_bnds\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n 'vertex': 'vertices',\n },\n \"CESM2\": {\n \"x\": [\"nlon\", \"lon\"],\n \"y\": [\"nlat\", \"lat\"],\n \"lon\": \"lon\",\n \"lat\": \"lat\",\n \"lev\": \"lev\",\n \"bnds\":'d2',\n \"time_bounds\":\"time_bnds\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n 'vertex': 'vertices',\n },\n \"CESM2-FV2\": {\n \"x\": [\"nlon\", \"lon\"],\n \"y\": [\"nlat\", \"lat\"],\n \"lon\": \"lon\",\n \"lat\": \"lat\",\n \"lev\": \"lev\",\n \"bnds\":'d2',\n \"time_bounds\":\"time_bnds\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n 'vertex': 'vertices',\n },\n \"GFDL-CM4\": {\n \"x\": [\"x\",\"lon\"],\n \"y\": [\"y\", \"lat\"],\n \"lon\": \"lon\",\n \"lat\": \"lat\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n \"time_bounds\": \"time_bnds\",\n # 'vertex': 'vertex',\n # 'dzt': 'thkcello',\n },\n \"GFDL-OM4p5B\": {\n \"x\": [\"x\",\"lon\"],\n \"y\": [\"y\", \"lat\"],\n \"lon\": \"lon\",\n \"lat\": \"lat\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n \"time_bounds\": \"time_bnds\",\n # 'vertex': 'vertex',\n # 'dzt': 'thkcello',\n },\n \"GFDL-ESM4\": {\n \"x\": [\"x\",\"lon\"],\n \"y\": [\"y\", \"lat\"],\n \"lon\": \"lon\",\n \"lat\": \"lat\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n \"time_bounds\": \"time_bnds\",\n # 'vertex': 'vertex',\n # 'dzt': 'thkcello',\n },\n \"NESM3\": {\n \"x\": ['i', \"lon\"],\n \"y\": ['j', \"lat\"],\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": None,\n \"lat_bounds\": None,\n 'vertex': 'vertices',\n 'time_bounds': \"time_bnds\",\n # 'dzt': 'thkcello',\n },\n \"MRI-ESM2-0\": {\n \"x\": ['x', \"lon\"],\n \"y\": ['y', \"lat\"],\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"bnds\":'bnds',\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": [\"x_bnds\", 'lon_bnds'],\n \"lat_bounds\": [\"y_bnds\", 'lat_bnds'],\n \"time_bounds\": \"time_bnds\",\n 'vertex': 'vertices',\n },\n \"SAM0-UNICON\": {\n \"x\": [\"i\", 'lon'],\n \"y\": [\"j\", 'lat'],\n \"lon\": \"longitude\",\n \"lat\": \"latitude\",\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": None,\n \"lat_bounds\": None,\n 'vertex': 'vertices',\n 'time_bounds': \"time_bnds\",\n # 'dzt': 'thkcello',\n },\n \"MCM-UA-1-0\": {\n \"x\": \"longitude\",\n \"y\": \"latitude\",\n \"lon\": None,\n \"lat\": None,\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n 'time_bounds': \"time_bnds\",\n # 'vertex': 'vertices',\n # 'dzt': 'thkcello',\n }, \n 'IPSL-CM6A-LR': {\n \"x\": ['x', \"lon\"],\n \"y\": ['y', \"lat\"],\n \"lon\": 'nav_lon',\n \"lat\": 'nav_lat',\n \"lev\": [\"lev\",\"deptht\", \"olevel\"],\n \"lev_bounds\": [\"lev_bounds\", \"deptht_bounds\",'olevel_bounds'],\n \"lon_bounds\": \"bounds_nav_lon\",\n \"lat_bounds\": \"bounds_nav_lat\",\n 'vertex': 'nvertex',\n \"bnds\":\"axis_nbounds\",\n 'time_bounds': \"time_bnds\",\n # 'dzt': 'thkcello',\n },\n 'NorCPM1': {\n \"x\": [\"i\", 'lon'],\n \"y\": [\"j\", 'lat'],\n \"lon\": 'longitude',\n \"lat\": 'latitude',\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": None,\n \"lat_bounds\": None,\n 'vertex': 'vertices',\n 'time_bounds': \"time_bnds\",\n },\n 'NorESM1-F': {\n \"x\": [\"i\", 'lon'],\n \"y\": [\"j\", 'lat'],\n \"lon\": 'longitude',\n \"lat\": 'latitude',\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": 'vertices_longitude',\n \"lat_bounds\": 'vertices_latitude',\n 'vertex': 'vertices',\n 'time_bounds': \"time_bnds\",\n },\n 'NorESM2-LM': {\n \"x\": \"i\",\n \"y\": \"j\",\n \"lon\": 'longitude',\n \"lat\": 'latitude',\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": 'vertices_longitude',\n \"lat_bounds\": 'vertices_latitude',\n 'vertex': 'vertices',\n 'time_bounds': \"time_bnds\",\n },\n 'NorESM2-MM': {\n \"x\": \"i\",\n \"y\": \"j\",\n \"lon\": 'longitude',\n \"lat\": 'latitude',\n \"lev\": \"lev\", # i leave this here because the names are the same as for the other Nor models.\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": 'vertices_longitude',\n \"lat_bounds\": 'vertices_latitude',\n 'vertex': 'vertices',\n 'time_bounds': \"time_bnds\",\n },\n \n 'MPI-ESM1-2-HR': {\n \"x\": [\"i\", 'lon'],\n \"y\": [\"j\", 'lat'],\n \"lon\": 'longitude',\n \"lat\": 'latitude',\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": 'vertices_longitude',\n \"lat_bounds\": 'vertices_latitude',\n 'vertex': 'vertices',\n 'time_bounds': \"time_bnds\",\n },\n 'MPI-ESM1-2-LR': {\n \"x\": \"i\",\n \"y\": \"j\",\n \"lon\": 'longitude',\n \"lat\": 'latitude',\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": 'vertices_longitude',\n \"lat_bounds\": 'vertices_latitude',\n 'vertex': 'vertices',\n 'time_bounds': \"time_bnds\",\n },\n 'MPI-ESM-1-2-HAM': {\n \"x\": \"i\",\n \"y\": \"j\",\n \"lon\": 'longitude',\n \"lat\": 'latitude',\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": 'vertices_longitude',\n \"lat_bounds\": 'vertices_latitude',\n 'vertex': 'vertices',\n 'time_bounds': \"time_bnds\",\n },\n 'CNRM-CM6-1-HR': {\n \"x\": \"x\",\n \"y\": \"y\",\n \"lon\": 'lon',\n \"lat\": 'lat',\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bounds\",\n \"lon_bounds\": \"bounds_lon\",\n \"lat_bounds\": \"bounds_lat\",\n 'vertex': None,\n 'time_bounds': \"time_bounds\",\n },\n 'FIO-ESM-2-0': {\n \"x\": \"i\",\n \"y\": \"j\",\n \"lon\": 'longitude',\n \"lat\": 'latitude',\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"vertices_longitude\",\n \"lat_bounds\": \"vertices_latitude\",\n 'vertex': 'vertices',\n 'time_bounds': \"time_bnds\",\n },\n 'ACCESS-ESM1-5': {\n \"x\": \"i\",\n \"y\": \"j\",\n \"lon\": 'longitude',\n \"lat\": 'latitude',\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"vertices_longitude\",\n \"lat_bounds\": \"vertices_latitude\",\n 'vertex': 'vertices',\n 'time_bounds': \"time_bnds\",\n },\n 'ACCESS-CM2': {\n \"x\": \"i\",\n \"y\": \"j\",\n \"lon\": 'longitude',\n \"lat\": 'latitude',\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"vertices_longitude\",\n \"lat_bounds\": \"vertices_latitude\",\n 'vertex': 'vertices',\n 'time_bounds': \"time_bnds\",\n },\n 'INM-CM4-8': { # this is a guess.\n \"x\": \"lon\",\n \"y\": \"lat\",\n \"lon\": None,\n \"lat\": None,\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n 'vertex': None,\n 'time_bounds': \"time_bnds\",\n },\n 'INM-CM5-0': { # this is a guess.\n \"x\": \"lon\",\n \"y\": \"lat\",\n \"lon\": None,\n \"lat\": None,\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"lon_bnds\",\n \"lat_bounds\": \"lat_bnds\",\n 'vertex': None,\n 'time_bounds': \"time_bnds\",\n },\n 'MRI-ESM2-0':{\n \"x\": \"x\",\n \"y\": \"y\",\n \"lon\": 'longitude',\n \"lat\": 'latitude',\n \"lev\": \"lev\",\n \"lev_bounds\": \"lev_bnds\",\n# \"lon_bounds\": 'x_bnds',\n# \"lat_bounds\": 'y_bnds',\n# 'vertex': None, # this is a mess. there is yet another convention. Will have to deal with this once I wrap xgcm into here.\n 'time_bounds': \"time_bnds\",\n },\n 'CIESM': { # this is a guess.\n \"x\": \"i\",\n \"y\": \"j\",\n \"lon\": 'longitude',\n \"lat\": 'latitude',\n# \"lev\": \"lev\", # no 3d data available as of now\n# \"lev_bounds\": \"lev_bnds\",\n \"lon_bounds\": \"vertices_longitude\",\n \"lat_bounds\": \"vertices_latitude\",\n 'vertex': 'vertices',\n 'time_bounds': \"time_bnds\",\n },\n 'KACE-1-0-G': { # this is a guess.\n \"x\": \"lon\",\n \"y\": \"lat\",\n \"lon\": 'longitude',\n \"lat\": 'latitude',\n# \"lev\": \"lev\", # no 3d data available as of now\n# \"lev_bounds\": \"lev_bnds\",\n# \"lon_bounds\": \"vertices_longitude\",\n# \"lat_bounds\": \"vertices_latitude\",\n# \"lon_bounds\": \"vertices_longitude\",\n# \"lat_bounds\": \"vertices_latitude\",\n 'vertex': 'vertices',\n 'time_bounds': \"time_bnds\",\n },\n \n }\n # cast all str into lists\n for model in dim_name_dict.keys():\n for field in dim_name_dict[model].keys():\n if isinstance(dim_name_dict[model][field], str) or dim_name_dict[model][field] is None :\n dim_name_dict[model][field] = [dim_name_dict[model][field]]\n# add 'lon' and 'lat' as possible logical indicies for all models. This should take care of all regridded ocean output and all atmosphere models.\n if 'x' in dim_name_dict[model].keys():\n if not 'lon' in dim_name_dict[model]['x']:\n dim_name_dict[model]['x'].append('lon')\n \n if 'y' in dim_name_dict[model].keys():\n if not 'lat' in dim_name_dict[model]['y']:\n dim_name_dict[model]['y'].append('lat') \n return dim_name_dict","def rewrite_hdf5(\n self, job_name=None, info=False, exclude_groups=None, exclude_nodes=None\n ):\n if job_name is not None:\n state.logger.warning(\n \"Specifying job_name is deprecated and ignored! Future versions will change signature.\"\n )\n file_name = self.file_name\n new_file = file_name + \"_rewrite\"\n\n self_hdf = FileHDFio(file_name=file_name)\n hdf_new = FileHDFio(file_name=new_file, h5_path=\"/\")\n\n old_logger_level = state.logger.level\n state.logger.level = 50\n hdf_new = self.hd_copy(self_hdf, hdf_new)\n state.logger.level = old_logger_level\n\n if info:\n print(\n \"compression rate from old to new: {}\".format(\n self.file_size(self_hdf) / self.file_size(hdf_new)\n )\n )\n print(\n \"data size vs file size: {}\".format(\n self.get_size(hdf_new) / self.file_size(hdf_new)\n )\n )\n self.remove_file()\n os.rename(hdf_new.file_name, file_name)","def sky_subtract_galaxy(name):\n spectra = get_object_spectra(name)\n sky_levels = get(name, 'sky')\n for spectrum in spectra:\n sky_level = sky_levels[spectrum]\n if not sky_level:\n sky_level = sky_subtract(name, spectrum)\n generate_sky(name, spectrum, sky_level)\n write(name, 'sky', sky_levels)","def fix_demand(city):\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + 'new_' + file, \"w\") as wf:\n writer = csv.writer(wf)\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file) as rf:\n reader = csv.reader(rf)\n for row in reader:\n writer.writerow([int(row[0]), int(row[1]), int(row[2]), float(row[3]), int(row[4]), int(row[5]), float(row[6]),\n int(row[1]) + int(row[4]), int(row[2]) + int(row[5]), (int(row[2]) + int(row[5]) - int(row[1]) - int(row[4])) / (int(row[2]) + int(row[5]))])\n\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\n if not file.startswith('new'):\n os.remove(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file)\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\n prefix = exp_data_path + os.sep + 'station' + os.sep + city\n os.rename(prefix + os.sep + file, prefix + os.sep + file[4:])","def corrector(file=\"\"):\n intermediate = str(file) + str(\"_intermediate\")\n\n # Lies den bisherigen Inhalt:\n with open(file, mode=\"r\") as source:\n content = source.read()\n\n # Tausche die Liniendefinition, grau gegen schwarz:\n gray_line = re.compile(\"stroke:#969696;\")\n substituted = str(gray_line.sub(\"stroke:#000000;\", content))\n\n # Tausche die Liniendefinition, keine Schattierung\n opacity = re.compile(\"stroke-opacity:\\d\\.?\\d*\")\n no_shadow = str(opacity.sub(\"stroke-opacity:1.0\", substituted))\n\n # Lege eine korrigierte Datei an:\n with open(intermediate, mode=\"w\") as newfile:\n # newfile.write(substituted)\n newfile.write(no_shadow)","def unpack_rename_data(self):\n for old, new in self.f_name_map.items():\n try:\n read_path = Path(os.environ[\"DATA_PATH\"]) / old\n write_path = Path(os.environ[\"DATA_PATH\"]) / new\n if \"ZIP\" in old:\n shutil.unpack_archive(read_path, write_path, \"zip\")\n else:\n shutil.unpack_archive(read_path, write_path)\n read_path.unlink() # delete original file\n except OSError:\n print(f\"Did not unpack {read_path}\")","def update_level_name(lumpname, bexdata, bexname):\n\tif bexname not in bexdata:\n\t\traise Exception('Level name %s not defined in '\n\t\t\t\t'DEHACKED lump!' % bexname)\n\t# Strip \"MAP01: \" or \"E1M2: \" etc. from start, if present:\n\tlevelname = re.sub('^\\w*\\d:\\s*', '', bexdata[bexname])\n\twhite_graphics[lumpname] = levelname","def bless_output(self):\n actual_output_file = path.splitext(self.source_name)[0] + \".actual\"\n expected_output_file = path.splitext(self.source_name)[0] + \".expected\"\n if path.exists(expected_output_file):\n os.unlink(expected_output_file)\n os.rename(actual_output_file, expected_output_file)","def updateCountryNames(self):\n try:\n with open('countryNameMapping.json', 'r') as file:\n name_mapping = json.loads(file.read())\n except:\n sys.exit('countryNameMapping.json file is unavailable in current directory.')\n \n for key, value in name_mapping.items():\n self.covid_df.replace(key, value, inplace=True)\n \n try:\n with open('countryNameISO2.json', 'r') as file:\n self.name_iso2_mapping = json.loads(file.read())\n except:\n print('countryNameISO2.json file is unavailable in current directory, creating file...')\n self.writeCountryCodeFile()\n print('Re-importing required JSONs...')\n self.updateCountryNames()","def rename(self, name, new_name):\n renames = {}\n if new_name in self._data.columns:\n msg = \"Cannot rename '{}' into '{}'. Column name already exists!\"\n raise ValueError(msg.format(name, new_name))\n\n self._in_blacklist(new_name)\n self._check_against_weak_dupes(new_name)\n\n if not self._dimensions_comp == 'ignore':\n self.undimensionize([name] + self.sources(name))\n name = self._dims_free_arr_name(name)\n\n for no, s in enumerate(self.sources(name), start=1):\n if '_' in s and s.split('_')[-1].isdigit():\n new_s_name = '{}_{}'.format(new_name, s.split('_')[-1])\n else:\n new_s_name = '{}_{}'.format(new_name, no)\n self._add_all_renames_to_mapper(renames, s, new_s_name)\n\n self._add_all_renames_to_mapper(renames, name, new_name)\n\n self.rename_from_mapper(renames)\n\n if self._dimensions_comp and not self._dimensions_comp == 'ignore':\n self.dimensionize(new_name)\n\n return None","def fix_path(self):\n paths = self.data['path'].tolist()\n prefixes = [re.findall(r'[A-Z\\-0-9]+', path) for path in paths]\n prefix_good = [str(prefix[0]) + \".json\" for prefix in prefixes]\n self.data['path'] = prefix_good","def fix_bad_column_blue():\r\n\r\n science = iraf.hselect('blue????.fits', '$I', 'TURRET == \"APERTURE\" & LAMPS == \"0000000\"', Stdout=1)\r\n if len(science) > 0:\r\n f = open('science_dump', 'w')\r\n for fn in science:\r\n f.write('%s\\n' % fn)\r\n f.close()\r\n science = iraf.hselect('@science_dump', '$I', 'TURRET == \"APERTURE\" & LAMPS == \"0000000\" & AIRMASS > 1.01', Stdout=1)\r\n if len(science)>0:\r\n os.unlink('science_dump')\r\n f = pyfits.open(science[0])\r\n bad_column = f[0].data[1608,:].argmin() + 1\r\n f.close()\r\n f = open('bluebpm', 'w')\r\n f.write('%d %d 1 2835\\n' % (bad_column, bad_column))\r\n f.close()\r\n iraf.fixpix('blue????.fits', \"bluebpm\")","def regenerate_heightmap(self):\n\n for x in range(16):\n for z in range(16):\n column = x * 16 + z\n for y in range(255, -1, -1):\n if self.get_block((x, y, z)):\n break\n\n self.heightmap[column] = y","def update_json(shell=False):\n\n surahs_modified = 0\n last_update = update_timestamp()\n if shell: tell.info(\"Updating JSON AST files.\")\n\n for surah in range(1, 115):\n\n source_path = \"source/surah{}.text\".format(surah)\n\n if last_modified(source_path) > last_update:\n\n if shell:\n tell.info(\"Rebuilding Surah `{}`.\".format(surah))\n surahs_modified += 1\n\n with open(source_path) as source_file:\n with open(\"json/surah{}.json\".format(surah), \"w\") as json_file:\n data = parse(source_file.read())\n json_file.write(json.dumps(data))\n\n if shell:\n if surahs_modified: tell.done(\"The JSON files are now up to date.\")\n else: tell.info(\"No edits were found in the source files.\")\n\n return surahs_modified","def update_best_model_json(updated):\n with open(qualify_full_filepath(f\"models.json\", HERE), \"w\") as outfile:\n json.dump(updated, outfile, sort_keys=True, indent=2)\n return None","def _handle_old_style_images(staging_path):\n file_num = 0\n for filename in ('snap.vhd', 'image.vhd', 'base.vhd'):\n path = os.path.join(staging_path, filename)\n if os.path.exists(path):\n _rename(path, os.path.join(staging_path, \"%d.vhd\" % file_num))\n file_num += 1","def recalc_names(\n input_path,\n config_file,\n linked_styles,\n exclude_namerecords,\n shorten_width,\n shorten_weight,\n shorten_italic,\n fix_cff,\n super_family,\n alt_uid,\n regular_italic,\n keep_regular,\n old_full_font_name,\n output_dir,\n recalc_timestamp,\n overwrite\n):\n\n files = getFontsList(input_path)\n if len(files) == 0:\n click.secho('\\nNo fonts found.', fg='red')\n sys.exit()\n\n if not config_file:\n config_file = getConfigPath(input_path)\n\n # If config.json doesn't exist, it has to be created before.\n if not os.path.exists(config_file):\n configHandler(config_file).resetConfig()\n click.secho('\\n{} didn\\'t exist and has been created'.format(\n config_file), fg='yellow')\n\n config = configHandler(config_file).getConfig()\n\n italics = config['italics']\n italics.sort(key=len)\n\n csv_file = getCsvPath(input_path)\n if not os.path.exists(csv_file):\n csvHandler(csv_file).resetCSV(config_file=config_file)\n data = csvHandler(csv_file).getData()\n\n # Checks if the file name is present in the CSV data. If the file name\n # is not present, the file is removed from the list of files and will\n # not be processed.\n csv_filenames = [row['file_name'] for row in data]\n files = [f for f in files if os.path.basename(f) in csv_filenames]\n\n shorten_width = [int(i) for i in shorten_width]\n shorten_weight = [int(i) for i in shorten_weight]\n shorten_italic = [int(i) for i in shorten_italic]\n exclude_namerecords = [int(i) for i in exclude_namerecords]\n\n # We convert the linked_styles tuple to a list and then sort it.\n linked_styles = tuple(set(linked_styles))\n linked_styles = list(linked_styles)\n linked_styles.sort()\n\n for f in files:\n try:\n font = TTFont(f, recalcTimestamp=recalc_timestamp)\n font_data = {}\n for row in data:\n if str(row['file_name']) == os.path.basename(f):\n font_data = row\n\n pyFont(font).recalcNames(\n font_data, italics,\n linked_styles=linked_styles, namerecords_to_ignore=exclude_namerecords,\n shorten_weight=shorten_weight, shorten_width=shorten_width, shorten_italic=shorten_italic,\n alt_uid=alt_uid, fixCFF=fix_cff, isSuperFamily=super_family, regular_italic=regular_italic, keep_regular=keep_regular, old_full_font_name=old_full_font_name)\n\n output_file = makeOutputFileName(\n f, outputDir=output_dir, overWrite=overwrite)\n font.save(output_file)\n click.secho('{} saved'.format(output_file), fg='green')\n except:\n click.secho('{} is not a valid font'.format(f), fg='red')\n pass","def rename_duplicates_across_vol(count, ggg1, ggg2, vol1='25', vol2='50', verbose=True):\n\n c2 = []\n for k,v in c1.items():\n if v == 0:\n c2.append(k)\n\n if verbose:\n print(\"Duplicated galnames between m{:} and m{:}: \".format(vol1, vol2))\n print(c2)\n\n if len(c2) > 0:\n overlapped = True\n p1 = pd.read_pickle('xxx' + vol1 + '/gal_catalog.pkl')\n\n import glob\n # renaming duplicates\n for i, old_n in enumerate(c2):\n\n if i == 0:\n lastind = int(ggg1[-1][ggg1[-1].find('s36_')+5:])\n\n newind = lastind + 1\n halo_name = old_n[:old_n.find('_')] # let's just keep the halo number from the first box, it's fine even tho it's not from the same halo as the second box, but we don't use that info in the future.\n new_name = halo_name + '_s36_G' + str(newind)\n lastind = newind\n\n ggg2.extend([new_name])\n ggg1.remove(old_n)\n\n # update name in pickle file\n iii = p1[p1['galnames'] == old_n].index.values\n old_files = glob.glob('xxx' + vol1 + '/z*' + old_n + '_sim.*')\n\n if len(iii) > 0 and len(old_files) > 0:\n p1['galnames'][int(iii)] = new_name\n p1.to_pickle('xxx' + vol1 + '/gal_catalog.pkl') # update\n\n for fff in old_files:\n basename = os.path.basename(fff)\n basename = basename[:basename.find('_')]\n extension = os.path.splitext(fff)[1]\n print('mv ' + fff + ' ' + 'xxx' + vol1 + '/' + basename + '_' + new_name + '_sim' + extension)\n os.system('mv ' + fff + ' ' + 'xxx' + vol1 + '/' + basename + '_' + new_name + '_sim' + extension)\n\n blah = os.system('ls ' + 'xxx' + vol1 + '/' + basename + '_' + new_name + '_sim' + extension)\n if blah != 0:\n import pdb; pdb.set_trace()\n # update galaxies/z6_extracted_gals_xxx file\n # CURRENTLY need to UPDATE MANUALLY\n\n else:\n # probably alraedy updated when we ran code before\n pass\n\n if not os.path.exists('xxx' + vol1 + vol2 + '/'):\n os.mkdir('xxx' + vol1 + vol2 + '/')\n p2 = pd.read_pickle('xxx' + vol2 + '/gal_catalog.pkl')\n # combine...\n results = {}\n for kk in p1.keys():\n results[kk] = np.hstack([p1[kk].values, p2[kk].values])\n results = pd.DataFrame(results)\n results.to_pickle('xxx' + vol1+vol2 +'/gal_catalog.pkl')\n\n # symlink simulation files\n os.chdir('xxx' + vol1 + vol2 + '/')\n os.system('rm *.dm *.star *.gas')\n\n for i in glob.glob('../xxx' + vol1 + '/*.dm'):\n basename, extension = os.path.splitext(i)\n os.system('cp ' + basename + '.dm .')\n os.system('cp ' + basename + '.gas .')\n os.system('cp ' + basename + '.star .')\n\n for i in glob.glob('../xxx' + vol2 + '/*.dm'):\n basename, extension = os.path.splitext(i)\n os.system('cp ' + basename + '.dm .')\n os.system('cp ' + basename + '.gas .')\n os.system('cp ' + basename + '.star .')\n os.chdir('../')\n\n else:\n overlapped = False\n\n return overlapped, ggg1, ggg2","def _replace_names_in_json_dict(jdict, renmap):\n if jdict:\n for k in list(jdict.keys()):\n nk = renmap.get(k)\n if nk:\n jdict[nk] = jdict[k]\n del jdict[k]","def reformat_json_file(infilename, outfilename, clobber=False):\n # open input json file\n with open(infilename) as json_file:\n json_string = json_file.read()\n json_data = json.loads(json_string)\n\n # see if output file already exists and determine course of action\n if os.path.exists(outfilename):\n if clobber:\n os.remove(outfilename)\n else:\n sys.exit(\"Error: output file {} already exists and would be overwritten!\".format(outfilename))\n\n # write out reformatted json file\n with open(outfilename, 'w') as f:\n json.dump(json_data, f, indent=4)","def smooth_images_toresolution(target_resolution,\n globs=[\"destripe*P[LMS]W*fits\",\n \"destripe*blue*fits\",\n \"destripe*red*fits\"],\n reject_regex='smooth|smregrid', verbose=True,\n skip_existing=True, regrid=True,\n target_header=None, regrid_order=1,\n clobber=False, **kwargs):\n\n for fn in [x for g in globs for x in glob.glob(g)\n if not re.search(reject_regex, x)]:\n if verbose:\n print(\"Reading file {0}\".format(fn),)\n\n outnum = int(target_resolution.to(u.arcsec).value)\n smoutfn = fn.replace(\".fits\", \"_smooth{0:d}.fits\".format(outnum))\n if os.path.exists(smoutfn):\n if skip_existing:\n if verbose:\n print(\"Skipping {0}\".format(fn))\n continue\n \n smhduL = smooth_image_toresolution(fn, smoutfn, target_resolution,\n verbose=verbose, clobber=clobber,\n **kwargs)\n smhdu = smhduL[0]\n\n if regrid:\n if target_header is None:\n raise ValueError(\"Must specify a target header if regridding.\")\n newimage = hcongrid(smhdu.data, smhdu.header, target_header,\n order=regrid_order)\n\n rgoutfn = fn.replace(\".fits\", \"_smregrid{0:d}.fits\".format(outnum))\n print(\"Regridding {0} to {1}\".format(smoutfn, rgoutfn))\n newhdu = fits.PrimaryHDU(data=newimage, header=target_header)\n newhdu.writeto(rgoutfn, clobber=clobber)","def correct_naming(obsid, inst):\n cobsid = str(int(float(obsid)))\n if len(cobsid) == 5:\n return \n\n lobsid = mcf.add_leading_zero(obsid, 5)\n \n for sdir in ['secondary', 'analysis']:\n\n cmd = 'ls /data/hrc/' + inst + '/' + lobsid + '/' + sdir + '/hrcf* >' + zspace\n os.system(cmd)\n\n data = mcf.read_data_file(zspace, remove=1)\n for ent in data:\n atemp = re.split('\\/', ent)\n fname = atemp[-1]\n mc = re.search(lobsid, fname)\n if mc is not None:\n continue\n else:\n atemp = re.split('hrcf', fname)\n btemp = re.split('_', atemp[1])\n sobs = btemp[0]\n new = fname.replace(sobs, lobsid)\n full = '/data/hrc/' + inst + '/' + lobsid + '/' + sdir + '/' + new\n\n cmd = 'mv ' + ent + ' ' + full\n os.system(cmd)","def change_column_names(filename, old_colnames, new_colnames):\n\tos.system('mv %s %s.copy' % (filename, filename))\n\tc = pyfits.open(filename+\".copy\")\n\ttbhdu = c[1]\n\tncol = len(tbhdu.data.columns)\n\tnewcols = []\n\tfor i in range(ncol):\n\t\tcolname = tbhdu.data.columns[i].name\n\t\tcolfmt = tbhdu.data.formats[i]\n\t\tcolarr = tbhdu.data.field(colname)\n\t\tfor j in range(len(old_colnames)):\n\t\t\tif tbhdu.data.columns[i].name == old_colnames[j]:\n\t\t\t\tcolname = new_colnames[j]\n\t\t\t\tbreak\n\t\t\t\t#print colname\n\t\tnewcols += [pyfits.Column(name=colname, format=colfmt, array=colarr)]\n\tnewcols = pyfits.ColDefs(newcols)\n\t#print newcols\n\tnewhdu = pyfits.new_table(newcols)\n\tnewhdu.writeto(filename)\n\tc.close()\n\tos.system('rm %s.copy' % filename)","def flareplot_json(df, clustdict, folderpath, flare_template = False):\n os.makedirs(folderpath, exist_ok = True)\n colors_auld = ['#800000', '#860000', '#8c0000', '#930000', '#990000', '#9f0000', '#a60000', '#ac0000', '#b20000', '#b90000', '#bf0000', '#c50000', '#cc0000', '#d20000', '#d80000', '#df0000', '#e50000', '#eb0000', '#f20000', '#f80000', '#ff0000', '#ff0700', '#ff0e00', '#ff1500', '#ff1c00', '#ff2300', '#ff2a00', '#ff3100', '#ff3800', '#ff3f00', '#ff4600', '#ff4d00', '#ff5400', '#ff5b00', '#ff6200', '#ff6900', '#ff7000', '#ff7700', '#ff7e00', '#ff8500', '#ff8c00', '#ff9100', '#ff9700', '#ff9d00', '#ffa300', '#ffa800', '#ffae00', '#ffb400', '#ffba00', '#ffbf00', '#ffc500', '#ffcb00', '#ffd100', '#ffd600', '#ffdc00', '#ffe200', '#ffe800', '#ffed00', '#fff300', '#fff900', '#ffff00', '#f2ff00', '#e5ff00', '#d8ff00', '#ccff00', '#bfff00', '#b2ff00', '#a5ff00', '#99ff00', '#8cff00', '#7fff00', '#72ff00', '#66ff00', '#59ff00', '#4cff00', '#3fff00', '#33ff00', '#26ff00', '#19ff00', '#0cff00', '#00ff00', '#0afc0a', '#15fa15', '#1ff81f', '#2af62a', '#34f434', '#3ff13f', '#49ef49', '#54ed54', '#5eeb5e', '#69e969', '#74e674', '#7ee47e', '#89e289', '#93e093', '#9ede9e', '#a8dba8', '#b3d9b3', '#bdd7bd', '#c8d5c8', '#d3d3d3']\n colors_ylorrd = ['#800026', '#850026', '#8a0026', '#8f0026', '#940026', '#990026', '#9e0026', '#a30026', '#a80026', '#ad0026', '#b20026', '#b70026', '#bd0026', '#c00225', '#c30424', '#c60623', '#c90822', '#cc0a21', '#d00d21', '#d30f20', '#d6111f', '#d9131e', '#dc151d', '#df171c', '#e31a1c', '#e51e1d', '#e7221e', '#e9271f', '#eb2b20', '#ed2f21', '#ef3423', '#f13824', '#f33c25', '#f54126', '#f74527', '#f94928', '#fc4e2a', '#fc532b', '#fc582d', '#fc5d2e', '#fc6330', '#fc6831', '#fc6d33', '#fc7234', '#fc7836', '#fc7d37', '#fc8239', '#fc873a', '#fd8d3c', '#fd903d', '#fd933e', '#fd9640', '#fd9941', '#fd9c42', '#fd9f44', '#fda245', '#fda546', '#fda848', '#fdab49', '#fdae4a', '#feb24c', '#feb54f', '#feb853', '#febb56', '#febf5a', '#fec25d', '#fec561', '#fec864', '#fecc68', '#fecf6b', '#fed26f', '#fed572', '#fed976', '#feda79', '#fedc7d', '#fede80', '#fedf84', '#fee187', '#fee38b', '#fee48e', '#fee692', '#fee895', '#fee999', '#feeb9c', '#ffeda0', '#ffeea3', '#fff0a7', '#fff1ab', '#fff3ae', '#fff4b2', '#fff6b6', '#fff7b9', '#fff9bd', '#fffac1', '#fffcc4', '#fffdc8', '#ffffcc']\n colors_grorrd = ['#800026', '#850026', '#8a0026', '#8f0026', '#940026', '#990026', '#9e0026', '#a30026', '#a80026', '#ad0026', '#b20026', '#b70026', '#bd0026', '#c00225', '#c30424', '#c60623', '#c90822', '#cc0a21', '#d00d21', '#d30f20', '#d6111f', '#d9131e', '#dc151d', '#df171c', '#e31a1c', '#e51e1d', '#e7221e', '#e9271f', '#eb2b20', '#ed2f21', '#ef3423', '#f13824', '#f33c25', '#f54126', '#f74527', '#f94928', '#fc4e2a', '#fc532b', '#fc582d', '#fc5d2e', '#fc6330', '#fc6831', '#fc6d33', '#fc7234', '#fc7836', '#fc7d37', '#fc8239', '#fc873a', '#fd8d3c', '#fd903d', '#fd933e', '#fd9640', '#fd9941', '#fd9c42', '#fd9f44', '#fda245', '#fda546', '#fda848', '#fdab49', '#fdae4a', '#feb24c', '#feb54f', '#feb853', '#febb56', '#febf5a', '#fec25d', '#fec561', '#fec864', '#fecc68', '#fecf6b', '#fed26f', '#fed572', '#fed976', '#feda79', '#fedc7d', '#fede80', '#fedf84', '#fee187', '#fee38b', '#fee48e', '#fee692', '#fee895', '#fee999', '#feeb9c', '#ffeda0', '#fbeaa4', '#f7e8a8', '#f4e6ac', '#f0e4b1', '#ece2b5', '#e9e0b9', '#e5ddbd', '#e1dbc2', '#ded9c6', '#dad7ca', '#d6d5ce', '#d3d3d3']\n colors_inferno = ['#000003', '#000004', '#000006', '#010007', '#010109', '#01010B', '#02010E', '#020210', '#030212', '#040314', '#040316', '#050418', '#06041B', '#07051D', '#08061F', '#090621', '#0A0723', '#0B0726', '#0D0828', '#0E082A', '#0F092D', '#10092F', '#120A32', '#130A34', '#140B36', '#160B39', '#170B3B', '#190B3E', '#1A0B40', '#1C0C43', '#1D0C45', '#1F0C47', '#200C4A', '#220B4C', '#240B4E', '#260B50', '#270B52', '#290B54', '#2B0A56', '#2D0A58', '#2E0A5A', '#300A5C', '#32095D', '#34095F', '#350960', '#370961', '#390962', '#3B0964', '#3C0965', '#3E0966', '#400966', '#410967', '#430A68', '#450A69', '#460A69', '#480B6A', '#4A0B6A', '#4B0C6B', '#4D0C6B', '#4F0D6C', '#500D6C', '#520E6C', '#530E6D', '#550F6D', '#570F6D', '#58106D', '#5A116D', '#5B116E', '#5D126E', '#5F126E', '#60136E', '#62146E', '#63146E', '#65156E', '#66156E', '#68166E', '#6A176E', '#6B176E', '#6D186E', '#6E186E', '#70196E', '#72196D', '#731A6D', '#751B6D', '#761B6D', '#781C6D', '#7A1C6D', '#7B1D6C', '#7D1D6C', '#7E1E6C', '#801F6B', '#811F6B', '#83206B', '#85206A', '#86216A', '#88216A', '#892269', '#8B2269', '#8D2369', '#8E2468', '#902468', '#912567', '#932567', '#952666', '#962666', '#982765', '#992864', '#9B2864', '#9C2963', '#9E2963', '#A02A62', '#A12B61', '#A32B61', '#A42C60', '#A62C5F', '#A72D5F', '#A92E5E', '#AB2E5D', '#AC2F5C', '#AE305B', '#AF315B', '#B1315A', '#B23259', '#B43358', '#B53357', '#B73456', '#B83556', '#BA3655', '#BB3754', '#BD3753', '#BE3852', '#BF3951', '#C13A50', '#C23B4F', '#C43C4E', '#C53D4D', '#C73E4C', '#C83E4B', '#C93F4A', '#CB4049', '#CC4148', '#CD4247', '#CF4446', '#D04544', '#D14643', '#D24742', '#D44841', '#D54940', '#D64A3F', '#D74B3E', '#D94D3D', '#DA4E3B', '#DB4F3A', '#DC5039', '#DD5238', '#DE5337', '#DF5436', '#E05634', '#E25733', '#E35832', '#E45A31', '#E55B30', '#E65C2E', '#E65E2D', '#E75F2C', '#E8612B', '#E9622A', '#EA6428', '#EB6527', '#EC6726', '#ED6825', '#ED6A23', '#EE6C22', '#EF6D21', '#F06F1F', '#F0701E', '#F1721D', '#F2741C', '#F2751A', '#F37719', '#F37918', '#F47A16', '#F57C15', '#F57E14', '#F68012', '#F68111', '#F78310', '#F7850E', '#F8870D', '#F8880C', '#F88A0B', '#F98C09', '#F98E08', '#F99008', '#FA9107', '#FA9306', '#FA9506', '#FA9706', '#FB9906', '#FB9B06', '#FB9D06', '#FB9E07', '#FBA007', '#FBA208', '#FBA40A', '#FBA60B', '#FBA80D', '#FBAA0E', '#FBAC10', '#FBAE12', '#FBB014', '#FBB116', '#FBB318', '#FBB51A', '#FBB71C', '#FBB91E', '#FABB21', '#FABD23', '#FABF25', '#FAC128', '#F9C32A', '#F9C52C', '#F9C72F', '#F8C931', '#F8CB34', '#F8CD37', '#F7CF3A', '#F7D13C', '#F6D33F', '#F6D542', '#F5D745', '#F5D948', '#F4DB4B', '#F4DC4F', '#F3DE52', '#F3E056', '#F3E259', '#F2E45D', '#F2E660', '#F1E864', '#F1E968', '#F1EB6C', '#F1ED70', '#F1EE74', '#F1F079', '#F1F27D', '#F2F381', '#F2F485', '#F3F689', '#F4F78D', '#F5F891', '#F6FA95', '#F7FB99', '#F9FC9D', '#FAFDA0', '#FCFEA4']\n colors_magma = ['#000003', '#000004', '#000006', '#010007', '#010109', '#01010B', '#02020D', '#02020F', '#030311', '#040313', '#040415', '#050417', '#060519', '#07051B', '#08061D', '#09071F', '#0A0722', '#0B0824', '#0C0926', '#0D0A28', '#0E0A2A', '#0F0B2C', '#100C2F', '#110C31', '#120D33', '#140D35', '#150E38', '#160E3A', '#170F3C', '#180F3F', '#1A1041', '#1B1044', '#1C1046', '#1E1049', '#1F114B', '#20114D', '#221150', '#231152', '#251155', '#261157', '#281159', '#2A115C', '#2B115E', '#2D1060', '#2F1062', '#301065', '#321067', '#341068', '#350F6A', '#370F6C', '#390F6E', '#3B0F6F', '#3C0F71', '#3E0F72', '#400F73', '#420F74', '#430F75', '#450F76', '#470F77', '#481078', '#4A1079', '#4B1079', '#4D117A', '#4F117B', '#50127B', '#52127C', '#53137C', '#55137D', '#57147D', '#58157E', '#5A157E', '#5B167E', '#5D177E', '#5E177F', '#60187F', '#61187F', '#63197F', '#651A80', '#661A80', '#681B80', '#691C80', '#6B1C80', '#6C1D80', '#6E1E81', '#6F1E81', '#711F81', '#731F81', '#742081', '#762181', '#772181', '#792281', '#7A2281', '#7C2381', '#7E2481', '#7F2481', '#812581', '#822581', '#842681', '#852681', '#872781', '#892881', '#8A2881', '#8C2980', '#8D2980', '#8F2A80', '#912A80', '#922B80', '#942B80', '#952C80', '#972C7F', '#992D7F', '#9A2D7F', '#9C2E7F', '#9E2E7E', '#9F2F7E', '#A12F7E', '#A3307E', '#A4307D', '#A6317D', '#A7317D', '#A9327C', '#AB337C', '#AC337B', '#AE347B', '#B0347B', '#B1357A', '#B3357A', '#B53679', '#B63679', '#B83778', '#B93778', '#BB3877', '#BD3977', '#BE3976', '#C03A75', '#C23A75', '#C33B74', '#C53C74', '#C63C73', '#C83D72', '#CA3E72', '#CB3E71', '#CD3F70', '#CE4070', '#D0416F', '#D1426E', '#D3426D', '#D4436D', '#D6446C', '#D7456B', '#D9466A', '#DA4769', '#DC4869', '#DD4968', '#DE4A67', '#E04B66', '#E14C66', '#E24D65', '#E44E64', '#E55063', '#E65162', '#E75262', '#E85461', '#EA5560', '#EB5660', '#EC585F', '#ED595F', '#EE5B5E', '#EE5D5D', '#EF5E5D', '#F0605D', '#F1615C', '#F2635C', '#F3655C', '#F3675B', '#F4685B', '#F56A5B', '#F56C5B', '#F66E5B', '#F6705B', '#F7715B', '#F7735C', '#F8755C', '#F8775C', '#F9795C', '#F97B5D', '#F97D5D', '#FA7F5E', '#FA805E', '#FA825F', '#FB8460', '#FB8660', '#FB8861', '#FB8A62', '#FC8C63', '#FC8E63', '#FC9064', '#FC9265', '#FC9366', '#FD9567', '#FD9768', '#FD9969', '#FD9B6A', '#FD9D6B', '#FD9F6C', '#FDA16E', '#FDA26F', '#FDA470', '#FEA671', '#FEA873', '#FEAA74', '#FEAC75', '#FEAE76', '#FEAF78', '#FEB179', '#FEB37B', '#FEB57C', '#FEB77D', '#FEB97F', '#FEBB80', '#FEBC82', '#FEBE83', '#FEC085', '#FEC286', '#FEC488', '#FEC689', '#FEC78B', '#FEC98D', '#FECB8E', '#FDCD90', '#FDCF92', '#FDD193', '#FDD295', '#FDD497', '#FDD698', '#FDD89A', '#FDDA9C', '#FDDC9D', '#FDDD9F', '#FDDFA1', '#FDE1A3', '#FCE3A5', '#FCE5A6', '#FCE6A8', '#FCE8AA', '#FCEAAC', '#FCECAE', '#FCEEB0', '#FCF0B1', '#FCF1B3', '#FCF3B5', '#FCF5B7', '#FBF7B9', '#FBF9BB', '#FBFABD', '#FBFCBF']\n colors_ylgnbl = ['#081d58', '#0a1e5d', '#0c2062', '#0f2267', '#11246c', '#142671', '#162876', '#182a7b', '#1b2c80', '#1d2e85', '#20308a', '#22328f', '#253494', '#243795', '#243b97', '#243e99', '#24429a', '#23459c', '#23499e', '#234c9f', '#2350a1', '#2253a3', '#2257a4', '#225aa6', '#225ea8', '#2162aa', '#2166ac', '#206aae', '#206fb0', '#1f73b2', '#1f77b4', '#1f7bb6', '#1e80b8', '#1e84ba', '#1d88bc', '#1d8cbe', '#1d91c0', '#2094c0', '#2397c0', '#269ac1', '#299dc1', '#2ca0c1', '#2fa3c2', '#32a6c2', '#35a9c2', '#38acc3', '#3bafc3', '#3eb2c3', '#41b6c4', '#46b7c3', '#4bb9c2', '#50bbc1', '#55bdc1', '#5abfc0', '#60c1bf', '#65c3be', '#6ac5be', '#6fc7bd', '#74c9bc', '#79cbbb', '#7fcdbb', '#85cfba', '#8bd1b9', '#91d4b9', '#97d6b8', '#9dd8b8', '#a3dbb7', '#a9ddb6', '#afdfb6', '#b5e2b5', '#bbe4b5', '#c1e6b4', '#c7e9b4', '#caeab3', '#cdebb3', '#d0ecb3', '#d3eeb3', '#d6efb2', '#daf0b2', '#ddf1b2', '#e0f3b2', '#e3f4b1', '#e6f5b1', '#e9f6b1', '#edf8b1', '#eef8b4', '#f0f9b7', '#f1f9bb', '#f3fabe', '#f4fac1', '#f6fbc5', '#f7fcc8', '#f9fccb', '#fafdcf', '#fcfdd2', '#fdfed5', '#ffffd9']\n colors_grorrd = ['#800026', '#850026', '#8a0026', '#8f0026', '#940026', '#990026', '#9e0026', '#a30026', '#a80026', '#ad0026', '#b20026', '#b70026', '#bd0026', '#c00225', '#c30424', '#c60623', '#c90822', '#cc0a21', '#d00d21', '#d30f20', '#d6111f', '#d9131e', '#dc151d', '#df171c', '#e31a1c', '#e51e1d', '#e7221e', '#e9271f', '#eb2b20', '#ed2f21', '#ef3423', '#f13824', '#f33c25', '#f54126', '#f74527', '#f94928', '#fc4e2a', '#fc532b', '#fc582d', '#fc5d2e', '#fc6330', '#fc6831', '#fc6d33', '#fc7234', '#fc7836', '#fc7d37', '#fc8239', '#fc873a', '#fd8d3c', '#fd903d', '#fd933e', '#fd9640', '#fd9941', '#fd9c42', '#fd9f44', '#fda245', '#fda546', '#fda848', '#fdab49', '#fdae4a', '#feb24c', '#feb54f', '#feb853', '#febb56', '#febf5a', '#fec25d', '#fec561', '#fec864', '#fecc68', '#fecf6b', '#fed26f', '#fed572', '#fed976', '#feda79', '#fedc7d', '#fede80', '#fedf84', '#fee187', '#fee38b', '#fee48e', '#fee692', '#fee895', '#fee999', '#feeb9c', '#ffeda0', '#fbeaa4', '#f7e8a8', '#f4e6ac', '#f0e4b1', '#ece2b5', '#e9e0b9', '#e5ddbd', '#e1dbc2', '#ded9c6', '#dad7ca', '#d6d5ce', '#d3d3d3']\n colors = colors_grorrd\n color_len = len(colors) -1\n for clust in clustdict.keys():\n\n # Select top interactions based on its mean frequency. Also asign color based on mean value\n df_clust = df.filter(items = clustdict[clust] + ['APosition1', 'APosition2', 'BPosition1', 'BPosition2','CPosition1', 'CPosition2','FPosition1', 'FPosition2',])\n df_clust['mean'] = df_clust.mean(axis = 1, numeric_only = True)\n mean_threshold = min(df_clust['mean'].nlargest(20).tolist())\n df_clust['color'] = df_clust['mean'].apply(lambda x: colors[color_len-round(x*color_len/100)]) #There are 101 colors avalible in list\n\n #Filter top 5 in df_clust\n df_clust = df_clust.nlargest(20,'mean')\n\n # 'Edge' entry for json file\n df_dict = pd.DataFrame(columns = [\"name1\", \"name2\", \"frames\"])\n df_dict['name1'] = df_clust['APosition1'] \n df_dict['name2'] = df_clust['APosition2']\n df_dict['frames'] = [[1]]*len(df_dict)\n df_dict['color'] = df_clust['color']\n df_dict['value'] = df_clust['mean']\n edges = df_dict.to_dict(orient=\"records\")\n\n # Appending edges to flare plot template, if any submitted\n if flare_template:\n flare_template['edges'] = edges\n jsondict = flare_template\n else:\n jsondict = { 'edges' : edges }\n\n #'Edge' multi-entries, based on the 4 GPCR nomenclatures\n for leter in ['A', 'B', 'C', 'F']:\n df_dict = pd.DataFrame(columns = [\"name1\", \"name2\", \"frames\"])\n df_dict['name1'] = df_clust[leter+'Position1'] \n df_dict['name2'] = df_clust[leter+'Position2']\n df_dict['frames'] = [[1]]*len(df_dict)\n df_dict['color'] = df_clust['color']\n df_dict['value'] = df_clust['mean']\n leter_edges = df_dict.to_dict(orient=\"records\")\n\n #Appending edges\n if flare_template:\n flare_template[leter+'edges'] = leter_edges\n jsondict = flare_template\n else:\n jsondict = { leter+'edges' : leter_edges }\n\n #Writing json\n jsonpath = folderpath + clust + \".json\"\n with open(jsonpath, 'w') as jsonfile:\n dump(jsondict, jsonfile, ensure_ascii=False, indent = 4)","def make_modified_json(num_urls):\n json_path = os.path.join(CHROMIUM_SRC, 'tools/perf/page_sets/data/')\n json_template = ('{{'\n '\"description\": \"Describes the Web Page Replay archives for a user '\n 'story set. Dont edit by hand! Use record_wpr for updating.\", '\n '\"archives\": {{ \"url{0}_page_set_000.wpr\": [\"url{0}\"]}}}}\\n')\n for i in range(num_urls):\n modified_name = str(i) + '_pc'\n file_name = 'url{0}_page_set.json'\n with open('{0}{1}'.format(json_path,\n file_name.format(modified_name)), 'wb') as f:\n f.write(json_template.format(modified_name))","def save_as_json(self, json_name):\r\n with open(json_name, \"w\") as outfile:\r\n json.dump(self.pet_file, outfile) # save create json file with current information\r\n self.pet_file_name = json_name # set name to passed name\r","def subtract_skydark(f):\n\n # Store these final products in a separate directory\n final_outdir = './final/'\n outfile = os.path.join(final_outdir, f.replace('.fits', '_skydarksub.fits'))\n if not os.path.isfile(outfile):\n # Get the skydark data\n skydark_ext1 = fits.getdata('skydark_ext_1_filtered.fits')\n skydark_ext4 = fits.getdata('skydark_ext_4_filtered.fits')\n\n # Subtract the skydark from each extension\n h = fits.open(f)\n data = np.copy(h[1].data)\n data = data - skydark_ext1\n h[1].data = data.astype('float32')\n data = np.copy(h[4].data)\n data = data - skydark_ext4\n h[4].data = data.astype('float32')\n h.writeto(outfile)\n h.close()\n else:\n print('{} already exists.'.format(outfile))","def write_snappy_dict(self):\n feature_list = []\n refinement_surface_dict = {}\n layer_dict = {}\n geom_dict = {}\n\n for part in self.geometries:\n geom = { part.filename : {'type':'triSurfaceMesh', 'name':part.name}}\n geom_dict.update(geom)\n\n file_dict = {'file' : '\"{}.eMesh\"'.format(part.name),\n 'level' : self.surfaceRefinement}\n feature_list.append(file_dict)\n\n refinement_surface = {part.name : {\n 'level' : [self.refinementSurfaceMin, self.refinementSurfaceMax]}}\n refinement_surface_dict.update(refinement_surface)\n\n layer = {part.name : {'nSurfaceLayers' : self.nSurfaceLayers}}\n layer_dict.update(layer)\n\n snappy_dict = {\n\n 'castellatedMesh' : self.castellate,\n 'snap' : self.snap,\n 'addLayers' : self.addLayers,\n 'geometry' :geom_dict,\n 'castellatedMeshControls' : {\n 'maxLocalCells' : self.maxLocalCells,\n 'maxGlobalCells' : self.maxGlobalCells,\n 'minRefinementCells' : self.minRefinementCells,\n 'maxLoadUnbalance' : self.maxLoadUnbalance,\n 'nCellsBetweenLevels' : self.nCellsBetweenLevels,\n 'features' : feature_list,\n 'refinementSurfaces': refinement_surface_dict,\n 'resolveFeatureAngle' : self.resolveFeatureAngle,\n 'refinementRegions' : {self.geometries[0].name :\n {'mode' : 'distance',\n 'levels' :([[(self.distanceRefinements[x],\\\n self.distanceLevels[x])] for x in\\\n range(len(self.distanceRefinements))])}},\n 'locationInMesh' : self.locationToKeep,\n 'allowFreeStandingZoneFaces' : self.allowFreeStandingFaces\n },\n 'snapControls' :\n {\n 'nSmoothPatch' : self.nSmoothPatch,\n 'tolerance' : self.snapTolerance,\n 'nRelaxIter' : self.nRelaxIter,\n 'nSolveIter' : self.nSolveIter,\n 'nFeatureSnapIter' : self.nFeatureSnapIter,\n 'implicitFeatureSnap' : self.implicitFeatureSnap,\n 'explicitFeatureSnap' : self.explicitFeatureSnap,\n 'multiRegionFeatureSnap' : self.multiRegionFeatureSnap,\n },\n 'addLayersControls' :\n {\n 'relativeSizes' : self.relativeSizes,\n 'expansionRatio' : self.expansionRatio,\n 'finalLayerThickness' : self.finalLayerThickness,\n 'minThickness' : self.minThickness,\n 'nGrow' : self.nGrow,\n 'layers': layer_dict,\n 'featureAngle' : self.featureAngle,\n 'slipFeatureAngle' : self.slipFeatureAngle,\n 'nRelaxIter' : self.nRelaxIter,\n 'nSmoothSurfaceNormals' : self.nSmoothSurfaceNormals,\n 'nSmoothNormals' : self.nSmoothNormals,\n 'nSmoothThickness' : self.nSmoothThickness,\n 'maxFaceThicknessRatio' : self.maxFaceThicknessratio,\n 'maxThicknessToMedialRatio' : self.maxThicknessToMedialRatio,\n 'minMedianAxisAngle' : self.minMedianAxisAngle,\n 'nBufferCellsNoExtrude' : self.nBufferCellsNoExtrude,\n 'nLayerIter' : self.nLayerIter\n },\n 'meshQualityControls' :\n {\n '#include' : '\"meshQualityDict\"'\n },\n 'mergeTolerance' : self.mergeTolerance\n }\n with self.case.mutable_data_file(FileName.SNAPPY_HEX_MESH) as d:\n d.update(snappy_dict)","def finalize(self, filename):\n with open(filename.replace('.json', '') + '-sprite.json', 'w') as outfile:\n json.dump(self.intra_dups_list, outfile)\n with open(filename.replace('.json', '') + '-project.json', 'w') as outfile:\n json.dump(self.project_dups_list, outfile)\n\n# count = sum([len(listElem) for listElem in self.intra_dups_list])\n count = len(self.intra_dups_list)\n result = (\"{} intra-sprite duplicate scripts found\\n\".format(count))\n result += (\"%d project-wide duplicate scripts found\\n\" % len(self.project_dups_list))\n\n return result","def test_rotate_filenames():\n tmpdir = os.path.join(tempfile.gettempdir(), \"jade-test-tmp87alkj8ew\")\n os.makedirs(tmpdir, exist_ok=True)\n\n data = {\"A\": 1, \"B\": 2}\n json_file1 = os.path.join(tmpdir, \"a1.json\")\n dump_data(data, json_file1)\n\n json_file2 = os.path.join(tmpdir, \"a2.json\")\n dump_data(data, json_file2)\n\n rotate_filenames(tmpdir, \".json\")\n\n if os.path.exists(tmpdir):\n shutil.rmtree(tmpdir)","def main(masklist, degrade, outfolder, outfileroot):\n maplist = []\n nsidelist = []\n\n # 1) Operating on individual masks\n for mask in masklist:\n path = mask['path']\n cut = mask['cut']\n invert = mask['invert']\n unseen = mask['unseen']\n\n hpmap = hp.read_map(path)\n nside = hp.get_nside(hpmap)\n nsidelist.append(nside)\n hp_seen = (hpmap != hp.UNSEEN)\n\n if cut is not None:\n hpmap = np.where((hpmap < cut) & hp_seen, 1, 0)\n else:\n assert np.all((hpmap[hp_seen] == 0) | (hpmap[hp_seen] == 1)), (\"\"+\n \"If there is no cut, the map must consist of zeros and ones\")\n if invert:\n hpmap[hp_seen] = np.where((hpmap[hp_seen] == 1), 0, 1)\n if unseen is not None:\n hpmap[~hp_seen] = unseen\n\n maplist.append(hpmap)\n del hpmap, nside\n\n # 2) Upgrading to common high resolution and merging\n n_hires = max(nsidelist)\n mask_hires = np.ones(hp.nside2npix(n_hires))\n for hpmap, nside in zip(maplist, nsidelist):\n if nside < n_hires:\n hpmap = hp.ud_grade(hpmap, n_hires)\n mask_hires *= hpmap\n del hpmap\n\n # 3) Save full mask\n try:\n os.makedirs(outfolder)\n except OSError as exception:\n if exception.errno != errno.EEXIST:\n raise\n\n outfile = outfileroot + \"_nside\" + str(n_hires) + \".fits\"\n outpath = os.path.join(outfolder, outfile)\n hp.write_map(outpath, mask_hires)\n\n # 4) Degrade resolution down to Nside = 128 and saving\n if degrade:\n pow2_hires = int(np.log2(n_hires))\n nsideiter = (2**i for i in xrange(7, pow2_hires)) # 7 --> Nside = 128\n for nside in nsideiter:\n mask_lores = hp.ud_grade(mask_hires, nside)\n outfile = (outfileroot + \"_degraded_nside\" + str(n_hires) +\n \"_to_\" + str(nside) + \".fits\")\n outpath = os.path.join(outfolder, outfile)\n hp.write_map(outpath, mask_lores)\n del mask_lores\n\n return None","def reSize(self, percent = 50, newName = '', force = False):\n\t\tnewFile = textureFile( self.dirPath + newName + self.extension )\n\t\tcmd = '\"' + self.path + '\" -resize ' + str( percent ) + '% \"' + newFile.path + '\"'\n\t\tif force or not newFile.exists:\n\t\t\tos.popen( IMAGEMAGICPATH + 'convert.exe ' + cmd )\n\t\treturn newFile","def map_county_data(percentage, outname, county_svg, dem = False):\n\n county_svg = open(county_svg, 'r').read()\n county_data = csv.reader(open('processed_data.csv'), delimiter = \",\")\n \n soup = BeautifulSoup(county_svg, \"html.parser\")\n paths = soup.findAll('path')\n red_colors = ['#FF0033', \"#FF4066\", \"#FF8099\", '#FFBFCC', '#FFFFFF']\n blue_colors = ['#3333FF', \"#6666FF\", \"#9999FF\", \"#CCCCFF\", \"#FFFFFF\"]\n \n path_style = 'font-size:12px;fill-rule:nonzero;stroke:#FFFFFF;stroke-opacity:1; stroke-width:0.1;stroke-miterlimit:4;stroke-dasharray:none;stroke-linecap:butt; marker-start:none;stroke-linejoin:bevel;fill:' \n \n if dem:\n colors = blue_colors\n else:\n colors = red_colors\n \n for p in paths:\n if p['id'] not in ['State_Lines', 'separator']:\n #print(str(p['id']))\n try:\n rate = percentage[int(p['id'])]\n except: \n continue\n \n if rate < 0.1:\n color_class = 4\n elif rate < 0.3: \n color_class = 3\n elif rate < 0.5: \n color_class = 2\n elif rate < 0.7: \n color_class = 1\n elif rate < 0.9: \n color_class = 0\n \n color = colors[color_class]\n p['style'] = path_style + color\n \n\n f = open(outname, 'w')\n f.write(soup.prettify())\n f.close()","def rename(self):\n\n # Remove any zero-padding from single-digit parameter names\n # This reverses any change applied by one of the CUDA writers\n for i in range(self.parser.comp-1, len(self.parser.parsedModel.parameterId)):\n old_name = self.parser.parsedModel.parameterId[i]\n num = old_name[len('parameter'):]\n if len(num) > 1 and num[0] == '0':\n new_name = 'parameter' + str(num[1:])\n self.parser.parsedModel.parameterId[i] = new_name\n self.parser.rename_everywhere(old_name, new_name)\n\n # Remove any zero-padding from single-digit species names\n # This reverses any change applied by one of the CUDA writers\n for i in range(len(self.parser.parsedModel.speciesId)):\n old_name = self.parser.parsedModel.speciesId[i]\n num = old_name[len('species'):]\n if len(num) > 1 and num[0] == '0':\n new_name = 'species' + str(num[1:])\n self.parser.parsedModel.speciesId[i] = new_name\n self.parser.rename_everywhere(old_name, new_name)","def remove_useless_file(rootPath):\n all_file_paddle_list = get_all_paddle_file(rootPath)\n ut_file_map_new = {}\n ut_file_map = \"%s/build/ut_file_map.json\" % rootPath\n with open(ut_file_map, 'r') as load_f:\n load_dict = json.load(load_f)\n for key in load_dict:\n if key in all_file_paddle_list:\n ut_file_map_new[key] = load_dict[key]\n\n with open(\"%s/build/ut_file_map.json\" % rootPath, \"w\") as f:\n json.dump(ut_file_map_new, f, indent=4)\n print(\"remove_useless_file ut_file_map success!!\")","def remap2json(xlsxfile,\n fs_stat_file,\n json_file = None,\n outfile = None,\n noscrape = False,\n force_update = False,\n ):\n import io\n import requests\n import json\n import pandas as pd\n import numpy as np\n import xlrd\n import socket\n\n # read in the xlxs file\n xls = pd.ExcelFile(xlsxfile)\n mapping = pd.read_excel(xls, 'Subcortical Volumes', header=[0,1])\n corticals = pd.read_excel(xls, 'Cortical Structures', header=[0,1])\n\n if not json_file:\n # creating a mapper and scraping definitions from the web is time-consuming.\n # Ideally, we want to do this only once. Therefore, we generate a base-remapper\n # that we take in as a default, and only update the definitions if none exists yet.\n try:\n with open ('segstats_jsonld/mapping_data/freesurfermap.json') as j:\n mapper = json.load(j)\n print('Found a base-remapper. To speed up the generation of the .json'\n 'mapping file, I will use the existing one and update it, if possible')\n json_file = 'segstats_jsonld/mapping_data/freesurfermap.json'\n except OSError as e:\n print(\"Could not find any base-remapper. Will generate one.\")\n\n if json_file:\n # if we have a user-supplied json mapper, check whats inside and only append new stuff\n # if necessary, update the file.\n with open(json_file) as j:\n mapper = json.load(j)\n\n # check whether we have an internet connection\n has_connection = test_connection()\n\n if not noscrape and has_connection:\n # if not existing in json mapper, rename the URIs so that they resolve, scrape definition\n definition_anat = []\n print(\"\"\"\n Scraping anatomical definitions from interlex. This might take a few minutes,\n depending on your internet connection.\n \"\"\")\n get_info = True\n for i, row in mapping.iterrows():\n if json_file:\n if row['Atlas Segmentation Label'].values[0] in mapper['Anatomy'].keys():\n # the term already exists in the mapper, lets check whether it has a definition\n get_info = False\n if mapper[\"Anatomy\"][row['Atlas Segmentation Label'].values[0]][\"definition\"] == 'NA':\n # there is no definition yet, lets try to get it\n get_info = True\n print('Checking for yet missing definition of label', row['Atlas Segmentation Label'].values[0])\n else:\n if not force_update:\n # append existing definition\n definition_anat.append(mapper[\"Anatomy\"][row['Atlas Segmentation Label'].values[0]][\"definition\"])\n if force_update:\n # override if we really want to check the definitions again\n get_info = True\n if get_info:\n # print('getting info for', row['Atlas Segmentation Label'].values[0])\n # get info only if json mapper does not exist yet\n if row['Federated DE']['URI'] is not np.nan:\n # this fixes the ilx link to resolve to scicrunch\n url = 'ilx_'.join(row['Federated DE']['URI'].split('ILX:')) + '.ttl'\n try:\n r = requests.get(url)\n file = io.StringIO(r.text)\n lines = file.readlines()\n for line in lines:\n if 'definition' in line[:14]:\n definition_anat.append(line.split('\"')[1])\n except socket.timeout:\n print('caught a timeout, appending \"\" to definitions')\n definition_anat.append(\"\")\n\n else:\n definition_anat.append('NA')\n\n definition_cort = []\n for i, row in corticals.iterrows():\n if json_file:\n if row['APARC Structures - Assuming Cortical Areas (not sulci)']['Label'] in mapper['Anatomy'].keys():\n # the term already exists in the mapper, lets check whether it has a definition\n get_info = False\n if mapper[\"Anatomy\"][row['APARC Structures - Assuming Cortical Areas (not sulci)']['Label']][\"definition\"] == 'NA':\n # there is no definition yet, lets try to get it\n get_info = True\n print('Checking for yet missing definition of label', row['APARC Structures - Assuming Cortical Areas (not sulci)']['Label'])\n else:\n # append existing definition\n if not force_update:\n definition_cort.append(\n mapper[\"Anatomy\"][row['APARC Structures - Assuming Cortical Areas (not sulci)']['Label']][\"definition\"])\n if force_update:\n get_info = True\n if get_info:\n # print('getting info for', row['APARC Structures - Assuming Cortical Areas (not sulci)']['Label'])\n if row['APARC Structures - Assuming Cortical Areas (not sulci)']['Interlex Label'] is not np.nan:\n url = row['APARC Structures - Assuming Cortical Areas (not sulci)']['URI'] + '.ttl'\n r = requests.get(url)\n file = io.StringIO(r.text)\n lines = file.readlines()\n for line in lines:\n if 'definition' in line[:14]:\n definition_cort.append(line.split('\"')[1])\n break\n elif line == lines[-1]:\n # some structures do not have definitions yet, append empty strings\n definition_cort.append(\"\")\n else:\n definition_cort.append('NA')\n\n elif noscrape or not has_connection:\n # if we can't or don't want scrape, append NA and print a warning? # TODO: is that sensible?\n print(\"\"\"\n Interlex definition of anatomical concepts will NOT be performed. If you did not\n specify this behaviour, this could be due to a missing internet connection\"\"\")\n if not json_file:\n # no definitions at all\n definition_anat = [\"\"] * len(mapping)\n definition_cort = [\"\"] * len(corticals)\n else:\n # append existing definitions from json\n if 'Left-Lateral-Ventricle' in mapper['Anatomy'].keys():\n definition_anat = [\n mapper['Anatomy'][r['Atlas Segmentation Label'].values[0]]['definition'] \\\n for (i, r) in mapping.iterrows()\n ]\n definition_anat = np.asarray(definition_anat)\n if 'bankssts' in mapper['Anatomy'].keys():\n definition_cort = [\n mapper['Anatomy'][r['APARC Structures - Assuming Cortical Areas (not sulci)']['Label']]['definition'] \\\n for (i, r) in corticals.iterrows()\n ]\n definition_cort = np.asarray(definition_cort)\n\n assert len(definition_cort) == len(corticals)\n assert len(definition_anat) == len(mapping)\n # append the definitions\n mapping['definition'] = definition_anat\n corticals['definition'] = definition_cort\n print(\"\"\"Done collecting definitions.\"\"\")\n d = {}\n print(\"\"\"creating json mapping from anatomicals...\"\"\")\n for i, row in mapping.iterrows():\n # store missing values as empty strings, not NaNs that json can't parse\n label = row['Atlas Segmentation Label'].values[0] if row['Atlas Segmentation Label'].values[0] is not np.nan else \"\"\n url = row['Structure']['URI'] if row['Structure']['URI'] is not np.nan else \"\"\n # the UBERON ID is currently listed as a string (e.g. UBERON:0014930) in the Excel file, we want\n # an URI such as http://purl.obolibrary.org/obo/UBERON_0014930\n # TODO: is the base URL correct here? (is it static and can be hardcoded?)\n isAbout = 'http://purl.obolibrary.org/obo/' + row['Structure']['Preferred'].replace(':', '_') \\\n if row['Structure']['Preferred'] is not np.nan else \"\"\n hasLaterality = row['Laterality']['ILX:0106135'] if row['Laterality']['ILX:0106135'] is not np.nan else \"\"\n l = row['Federated DE']['Name'] if row['Federated DE']['Name'] is not np.nan else \"\"\n # WIP: Added by DBK because I can't change the Name column or really edit the ReproNimCDEs.xlsx file at all\n # with my version of Excel (version 16.27 on Mac) without it mangling column B which is an IF statement\n # something to do with Excel so here I'm forcing the removal of \"left\" | \"right\" | \"volume\" from the Names\n l=l.replace('left','')\n l=l.replace('right','')\n l=l.replace('volume','').strip()\n d[label] = {\"url\": url,\n \"isAbout\": isAbout,\n \"hasLaterality\": hasLaterality,\n # WIP: Added by DBK, see comment above...\n # \"definition\": row['definition'][0],\n \"definition\": row['definition'][0].replace('left','').replace('right','').replace('volume','').strip(),\n \"label\": l\n }\n print(\"Done. Creating json mapping from cortical structures...\")\n for i, row in corticals.iterrows():\n label = row['APARC Structures - Assuming Cortical Areas (not sulci)']['Label'] \\\n if row['APARC Structures - Assuming Cortical Areas (not sulci)']['Label'] is not np.nan else \"\"\n url = row['APARC Structures - Assuming Cortical Areas (not sulci)']['URI'] \\\n if row['APARC Structures - Assuming Cortical Areas (not sulci)']['URI'] is not np.nan else \"\"\n isAbout = 'http://purl.obolibrary.org/obo/' + row['APARC Structures - Assuming Cortical Areas (not sulci)']['Preferred'].replace(':', '_') \\\n if row['APARC Structures - Assuming Cortical Areas (not sulci)']['Preferred'] is not np.nan else \"\"\n # TODO: The Laterality of the terms in aparc files is undefined yet. I think that should change\n hasLaterality = \"\"\n l = row['APARC Structures - Assuming Cortical Areas (not sulci)']['Interlex Label'] \\\n if row['APARC Structures - Assuming Cortical Areas (not sulci)']['Interlex Label'] is not np.nan else \"\"\n d[label] = {\"url\": url,\n \"isAbout\": isAbout,\n \"hasLaterality\": hasLaterality,\n \"definition\": row['definition'][0],\n \"label\": l\n }\n # read the measures output of a of a read_stats() call. Depending on the header in the file,\n # include present measures in json\n print(\"Reading in FS stat file...\")\n [header, tableinfo, measures] = read_stats(fs_stat_file)\n d2 = {}\n print(\"\"\"Creating measures json mapping...\"\"\")\n\n for fi, ind1, ind2 in [(mapping, 'Atlas Segmentation Label', 0),\n (corticals, 'APARC Structures - Assuming Cortical Areas (not sulci)', 'Label')]:\n for i, row in fi.iterrows():\n anatomical = row[ind1][ind2]\n for c in measures:\n if c['structure'] == anatomical:\n for dic in c['items']:\n # iterate over the list of dicts in items\n if dic['name'] == 'normMean':\n d2['normMean'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0105536',\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738264'\n }\n if dic['name'] == 'normStdDev':\n d2['normStdDev'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0105536',\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738265'\n }\n if dic['name'] == 'normMax':\n d2['normMax'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0105536',\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738267'\n }\n if dic['name'] == 'NVoxels':\n d2['NVoxels'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0112568',\n \"datumType\": 'http://uri.interlex.org/base/ilx_0102597',\n \"hasUnit\": 'voxel'\n }\n if dic['name'] == 'Volume_mm3':\n d2['Volume_mm3'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0112559',\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738276',\n \"hasUnit\": 'mm^3'\n }\n if dic['name'] == 'normMin':\n d2['normMin'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0105536',\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738266'\n }\n if dic['name'] == 'normRange':\n d2['normRange'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0105536',\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738268'\n }\n if dic['name'] == 'NumVert':\n d2['NumVert'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0738270', #vertex\n \"datumType\": 'http://uri.interlex.org/base/ilx_0102597' # count\n }\n if dic['name'] == 'SurfArea':\n d2['SurfArea'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0738271', #surface\n \"datumType\": 'http://uri.interlex.org/base/ilx_0100885' #area\n }\n if dic['name'] == 'GrayVol':\n d2['GrayVol'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0112559', # volume\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738276' #scalar\n }\n if dic['name'] == 'ThickAvg':\n d2['ThickAvg'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0111689', #thickness\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738264' #mean\n }\n if dic['name'] == 'ThickStd':\n d2['ThickStd'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0111689', #thickness\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738265' #stddev\n }\n if dic['name'] == 'MeanCurv':\n d2['MeanCurv'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0738272', #mean curvature\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738276' #scalar\n }\n if dic['name'] == 'GausCurv':\n d2['GausCurv'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0738273', #gaussian curvature\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738276' #scalar\n }\n if dic['name'] == 'FoldInd':\n d2['FoldInd'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0738274', #foldind\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738276' #scalar\n }\n if dic['name'] == 'CurvInd':\n d2['CurvInd'] = {\n \"measureOf\": 'http://uri.interlex.org/base/ilx_0738275', #curvind\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738276' #scalar\n }\n if dic['name'] == 'nuMean':\n d2['nuMean'] = {\n \"measureOf\": 'TODO',\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738264' #mean\n }\n if dic['name'] == 'nuStdDev':\n d2['nuStdDev'] = {\n \"measureOf\":'TODO',\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738265' #stddev\n }\n if dic['name'] == 'nuMin':\n d2['nuMin'] = {\n \"measureOf\":'TODO',\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738266' #min\n }\n if dic['name'] == 'nuMax':\n d2['nuMax'] = {\n \"measureOf\":'TODO',\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738267' #max\n }\n if dic['name'] == 'nuRange':\n d2['nuRange'] = {\n \"measureOf\":'TODO',\n \"datumType\": 'http://uri.interlex.org/base/ilx_0738268' #range\n }\n # join anatomical and measures dictionaries\n biggie = {'Anatomy': d,\n 'Measures': d2}\n\n if outfile:\n with open(outfile, 'w') as f:\n json.dump(biggie, f, indent=4)\n # if no outfile is provided, we can update the existing file or create one\n else:\n if json_file:\n with open(json_file, 'w') as f:\n json.dump(biggie, f, indent=4)\n else:\n datapath = mapping_data.__path__[0] + '/'\n with open(join(datapath, 'freesurfermap.json'), 'w') as f:\n json.dump(biggie, f, indent=4)\n\n return [header, tableinfo, measures, biggie]","def write_drugs_name(self):\r\n for elem in range(len(self.output_zakladki)):\r\n n, first_row = 0, 3\r\n\r\n sheet = self.output_zakladki[elem]\r\n sh = self.output_file.get_sheet_by_name(sheet)\r\n no_of_row = self.liczba_pelnych_linii\r\n\r\n if self.niepelna_liniia:\r\n no_of_row += 1\r\n\r\n while no_of_row != 0:\r\n for lek in self.output_leki[elem]:\r\n sh['A' + str(first_row + n)] = lek\r\n n += 1\r\n first_row += 2\r\n no_of_row -= 1","def map_county_data_compare(dem_16, rep_16, outname, county_svg):\n\n county_svg = open(county_svg, 'r').read()\n county_data = csv.reader(open('processed_data.csv'), delimiter = \",\")\n \n soup = BeautifulSoup(county_svg, \"html.parser\")\n paths = soup.findAll('path')\n blue_red = ['#FF0000','#EC0517','#DA092E','#C70E46','#B5135D','#A21774','#901C8B','#7D20A2','#6B25B9','#582AD1','#462EE8','#3333FF', '#FFFFFF']\n # County style\n path_style = 'font-size:12px;fill-rule:nonzero;stroke:#FFFFFF;stroke-opacity:1; stroke-width:0.1;stroke-miterlimit:4;stroke-dasharray:none;stroke-linecap:butt; marker-start:none;stroke-linejoin:bevel;fill:'\n\n for p in paths:\n if p['id'] not in ['State_Lines', 'separator']:\n #print(str(p['id']))\n try:\n rate = rep_16[int(p['id'])]\n rate2 = dem_16[int(p['id'])]\n except: \n continue\n if rate < 0.1 or rate2 > 0.9:\n color_class = 9\n elif rate < 0.2 or rate2 > 0.8: \n color_class = 8\n elif rate < 0.3 or rate2 > 0.7: \n color_class = 7\n elif rate < 0.4 or rate2 > 0.6: \n color_class = 6\n elif rate < 0.5 or rate2 > 0.5: \n color_class = 5\n elif rate < 0.6 or rate2 > 0.4: \n color_class = 4\n elif rate < 0.7 or rate2 > 0.3: \n color_class = 3\n elif rate < 0.8 or rate2 > 0.2: \n color_class = 2\n elif rate < 0.9 or rate2 > 0.1: \n color_class = 0\n elif rate < 1.0: \n color_class = 1\n else: color_class = 10\n\n color = blue_red[color_class]\n p['style'] = path_style + color\n \n\n f = open(outname, 'w')\n f.write(soup.prettify())\n f.close()","def fix_acquisition_numbers_of_json_files_in(raw_dir: Path):\n\n print(\"Fixing the acquisition numbers of the .json files in sourcedata.\")\n\n for old_path in raw_dir.rglob(\"*.json\"):\n\n parts_of_stem_of_old_path = old_path.stem.split(\"_\")\n stem_parts_with_correct_acquisition_number = parts_of_stem_of_old_path[:-1] + [acquisition_number_of(old_path)]\n fresh_new_stem = \"_\".join(stem_parts_with_correct_acquisition_number)\n fresh_new_path = old_path.with_name(fresh_new_stem + old_path.suffix)\n old_path.replace(fresh_new_path)","def test_too_small_remap(self):\n ethanol = Molecule.from_file(get_data_file_path(\"molecules/ethanol.sdf\"))\n # catch mappings that are the wrong size\n too_small_mapping = {0: 1}\n with pytest.raises(ValueError):\n new_ethanol = ethanol.remap(too_small_mapping, current_to_new=True)","def loadAndClean(jfile):\n with open(jfile) as json_file:\n data = json.load(json_file)[\"G15\"]\n newDict = {}\n # Print the type of data variable\n \n for entry in data:\n\n if \"version\" in data[entry] and data[entry][\"assessed_by\"] not in filterList:\n\n if data[entry][\"assessed_by\"] in dictTries:\n dictTries[data[entry][\"assessed_by\"]].append(data[entry])\n\n \n\n if len(dictTries[data[entry][\"assessed_by\"]]) == 2:\n ml = dictTries[data[entry][\"assessed_by\"]]\n #vou querer calcular o maior \n # comparisson = \"accuracy\"\n comparisson = \"target_w_penalty\"\n \n if ml[0][comparisson] <= ml[1][comparisson]:\n if ml[0][\"accuracy\"] > 90:\n printSingle(ml[0])\n newDict[entry] = ml[0]\n\n else:\n if ml[1][\"accuracy\"] > 90:\n printSingle(ml[1])\n newDict[entry] = ml[1]\n dictTries[data[entry][\"assessed_by\"]] = []\n\n else:\n dictTries[data[entry][\"assessed_by\"]] = [data[entry]]\n\n\n\n # dictTries[data[\"assessed_by\"]]\n\n # newDict[entry] = data[entry]\n # print(data[entry])\n # print()\n # printDict(newDict)\n return newDict","def change_file_name():\n path = \"/etc/atuned/webserver/\"\n file_list = os.listdir(path)\n file_list.sort(key=lambda fn: os.path.getmtime(path + fn))\n if len(file_list) > 0 and re.match(r'\\S*-\\d{17}\\S*', file_list[-1]) is None:\n old_name = file_list[-1].split(\".\")[0]\n curr_time = time.strftime(\"%Y%m%d%H%M%S\", time.localtime())\n new_name = old_name + \"-\" + str(curr_time) + str(random.randint(100, 999))\n os.rename(path + old_name + \".txt\", path + new_name + \".txt\")","def save_json_file():\n global output_on_display, import_lst, column_names, data, new_data\n if data_base == '':\n mistake_load_table()\n else:\n column_names = new_data\n step = len(column_names)\n save_name = asksaveasfilename(title=\"Select file\", filetypes=((\"JSON\", \"*.json\"), (\"all files\", \"*.*\")),\n confirmoverwrite=True, defaultextension='.json')\n data = import_lst\n\n if len(data[0]) == step:\n pass\n else:\n data = import_lst[step::]\n\n data2 = list(map(list, zip(*data)))\n\n data3 = {key: value for key, value in zip(column_names, data2)}\n\n column = list(data3.keys())\n\n df = pd.DataFrame(data3, columns=column)\n\n data_dict = df.to_dict(orient=\"records\")\n with open(save_name, \"w+\") as f:\n json.dump(data_dict, f, indent=4)\n\n data.clear()\n data2.clear()\n data3.clear()","def renameFiles(folder):\n\n # Retrieve list of all text files and remove the txt files\n for filename in glob.glob(os.path.join(folder, \"*.txt\")):\n with open(filename, 'r') as file:\n metadata=file.read().replace('\\n', '')\n ident = metadata[27:31]\n order = metadata[26].upper()\n finger = metadata[32:34]\n gender = metadata[8].upper()\n fingerprintClass = metadata[16].upper()\n fp = Fingerprint(ident, order, finger, gender, fingerprintClass)\n\n # Remove the .txt file and rename the png\n os.remove(filename)\n pngName = filename.replace(\".txt\", \".png\")\n newName = fp.id + \"_\" + fp.order + \"_\" + fp.finger + \"_\" + fp.gender + \"_\" + fp.fingerprintClass + \".png\"\n newName = os.path.join(folder, newName)\n os.rename(pngName, newName)","def make_output_names(self):\n yaml_names = []\n fits_names = []\n\n if self.use_nonstsci_names:\n for i in range(len(self.info['Module'])):\n act = str(self.info['act_id'][i]).zfill(2)\n if self.info['Instrument'][i].lower() == 'niriss':\n det = 'NIS'\n elif self.info['Instrument'][i].lower() == 'fgs':\n det = 'FGS'\n else:\n det = self.info['detector'][i]\n mode = self.info['Mode'][i]\n dither = str(self.info['dither'][i]).zfill(2)\n\n yaml_names.append(os.path.abspath(os.path.join(self.output_dir, 'Act{}_{}_{}_Dither{}.yaml'\n .format(act, det, mode, dither))))\n fits_names.append('Act{}_{}_{}_Dither{}_uncal.fits'.format(act, det, mode, dither))\n\n else:\n for i in range(len(self.info['Module'])):\n if self.info['Instrument'][i].upper() == 'NIRCAM':\n fulldetector = 'nrc{}'.format(self.info['detector'][i].lower())\n else:\n fulldetector = self.info['detector'][i].lower()\n outfilebase = self.create_output_name(self.info, index=i)\n outfile = \"{}{}{}\".format(outfilebase, fulldetector, '_uncal.fits')\n yamlout = \"{}{}{}\".format(outfilebase, fulldetector, '.yaml')\n\n yaml_names.append(yamlout)\n fits_names.append(outfile)\n\n self.info['yamlfile'] = yaml_names\n self.info['outputfits'] = fits_names\n # Table([self.info['yamlfile']]).pprint()","def sanitize_json_files(unsanitized_json_file):\n with open(develop_baseline_dir + unsanitized_json_file) as f:\n lines = f.readlines()\n\n with open('sanitizedJson/sanitized_{}'.format(unsanitized_json_file), 'w') as w:\n w.writelines([item for item in lines[:-1]])","def new_shp_name(file_path):\n while os.path.exists(file_path):\n try:\n int(file_path[-5])\n except ValueError:\n file_path = file_path[0:-4] + \"1.shp\"\n else:\n number = str(int(file_path[-5]) + 1)\n file_path = file_path[0:-5] + number + \".shp\"\n return file_path","def rename_images(_input_image_paths : list[str], _output_image_dir : str) -> None:\n #Starts at 0 to account for incrementing when seeing a non-alternative\n # (the 1st image can never be an alternative take)\n new_index = 0\n\n #Get the \"base name\" for the images - e.g., PICT, DCIM, IMG_, etc.\n #Assumes that each image has the same base name as the first one.\n #Also gets the \"base index\", e.g., 1, 001, 00018, etc.\n base_name, base_index = get_image_base_name_and_index(_input_image_paths[0])\n debug(f\"Base name ({base_name}) and index({base_index})\")\n\n #Since the first image can't be an alternative take, this lets us\n # get the proper index length for all of the images\n index_length = len(base_index)\n\n #For each image, rename based on the new indices\n for image in _input_image_paths:\n flag = get_alternative_flag(image)\n\n #increment the index if this was not an alternative-take image\n if flag == '':\n new_index += 1\n\n #Create an index padded with a sufficient number of prefixing '0's\n formatted_index = \"0\" * (index_length - len(str(new_index))) + str(new_index)\n\n #Get the file name's extension\n extension = os.path.splitext(image)[1]\n\n #Create the new file name based off of the current index\n new_filepath = _output_image_dir + base_name + formatted_index + flag + extension\n debug(f\"Saving {image} to {new_filepath}\")\n\n #Save the image with the updated path name\n with Image.open(image) as image_object:\n image_object.save(new_filepath)","def refactor(path: str, files: List):\n skipped = []\n for filename in files:\n try:\n number = get_number_from_name(filename)\n except AttributeError:\n skipped.append(os.path.join(path, filename))\n continue\n new_number = update_number(number)\n\n file_path = os.path.join(path, filename)\n new_file_path = file_path.replace(number, new_number)\n\n with open(file_path, 'r') as file:\n data = file.read()\n data = data.replace(number, new_number)\n with open(file_path, 'w') as file:\n file.write(data)\n\n os.rename(file_path, new_file_path)\n return skipped","def json_to_cache(new_json: Dict, file_name: str) -> None:\n\n json_path = os.path.join(CACHE_DIR, file_name)\n ensure_dir(json_path)\n with open(json_path, \"w\") as outfile:\n json.dump(new_json, outfile, ensure_ascii=False)","def renameFormats(self, nameDict):\n for item in globalref.docRef.root.descendantGen():\n item.formatName = nameDict.get(item.formatName, item.formatName)","def re_name(name,new_name):\n\n try:\n os.rename(config_tools.full_dest+name,config_tools.full_dest+new_name)\n except OSError:\n print(f\"Не удалось переименовать {name}\")\n else:\n print(f\"{name} успешно переименновавано в {new_name}\")","def crop_and_resize_images(images_path, annotations_path, output_path):\n assert os.path.exists(images_path)\n assert os.path.exists(annotations_path)\n\n if not os.path.exists(output_path):\n os.makedirs(output_path)\n\n image_file_names = util.get_images_at_path(images_path)\n\n # Filename of annotations file without path, e.g. annotations.json\n annotations_file_name, annotations_file_extension = os.path.splitext(os.path.basename(annotations_path))\n # Full path to new annotations file, e.g. /home/user/annotations/annotations_noisy.json\n modified_annotations_file_path = os.path.join(output_path, annotations_file_name + \"_cropped\" + annotations_file_extension)\n\n with open(annotations_path, \"r\") as json_file, open(modified_annotations_file_path, \"w\") as modified_json_file:\n json_data = json.load(json_file)\n new_json_data = {}\n\n for image_file_name in image_file_names:\n\n # Load the image to augment\n image = cv2.imread(os.path.join(images_path, image_file_name))\n width, height, channels = image.shape\n # At most 20% of the image width or height is used as offset\n x_offset = random.randint(0, width / 5)\n y_offset = random.randint(0, height / 5)\n # And width and height are between 80 and 100% of original\n crop_width = random.randint((4 * width) / 5, width)\n crop_height = random.randint((4 * height) / 5, height)\n # If we have 20% offset plus 100% width or height that's not gonna work\n crop_width = min(crop_width, width - x_offset)\n crop_height = min(crop_height, height - y_offset)\n\n print(\"Cropping image {} at ({}, {}) to ({}, {}).\".format(image_file_name, x_offset, y_offset, crop_width, crop_height))\n\n # Crop image\n cropped_image = image[y_offset:y_offset + crop_height, x_offset:x_offset + crop_width]\n image_file_base_name, extension = os.path.splitext(image_file_name)\n augmented_file_name = image_file_base_name + \"_cropped\" + extension\n augmented_file_path = os.path.join(output_path, augmented_file_name)\n cv2.imwrite(augmented_file_path, cropped_image)\n\n # Adjust the annotations file\n\n for key in json_data:\n if image_file_name in key:\n # We found the currently process image, now adjust bounding boxes and set the new sizes\n image_data = json_data[key]\n new_image_data = {\"base64_img_data\" : image_data[\"base64_img_data\"], \\\n \"fileref\" : image_data[\"fileref\"], \\\n \"file_attributes\" : image_data[\"file_attributes\"]}\n new_image_data[\"regions\"] = {}\n for region_key in image_data[\"regions\"]:\n region_data = image_data[\"regions\"][region_key]\n shape_attributes = region_data[\"shape_attributes\"]\n box_x, box_y, box_width, box_height = shape_attributes[\"x\"], shape_attributes[\"y\"], \\\n shape_attributes[\"width\"], shape_attributes[\"height\"]\n # Same as in conversion.py, we need to care for negative x and y (outside of image)\n box_x = max(box_x, 0)\n box_y = max(box_y, 0)\n # Adjust to regions that go beyond the image\n box_width = min(box_width, width - box_x)\n box_height = min(box_height, height - box_y)\n\n old_x, old_y, old_width, old_height = box_x, box_y, box_width, box_height\n\n box_too_far_left = box_x + box_width < x_offset\n box_too_far_right = box_x > x_offset + crop_width\n box_too_far_up = box_y + box_height < y_offset\n box_too_far_down = box_y > y_offset + crop_height\n if box_too_far_left or box_too_far_right or box_too_far_up or box_too_far_down:\n # If box is outside of cropping skip adding it\n continue\n\n # New x and y positions of the bounding box\n box_x = box_x - x_offset\n if box_x < 0:\n # Old x was outside of cropping, we need to adjust width, i.e. subtract the offset\n box_width = box_width + box_x\n box_x = 0\n if box_x + box_width > crop_width:\n # To care for the new box exceeding the image size\n box_width = crop_width - box_x\n\n box_y = box_y - y_offset\n if box_y < 0:\n # Same goes for height\n box_height = box_height + box_y\n box_y = 0\n if box_y + box_height > crop_height:\n box_height = crop_height - box_y\n \n shape_attributes[\"x\"] = box_x\n shape_attributes[\"y\"] = box_y\n shape_attributes[\"width\"] = box_width\n shape_attributes[\"height\"] = box_height\n new_image_data[\"regions\"][region_key] = region_data\n\n # Now adjust to the new file name\n split = key.split(image_file_name)\n statinfo = os.stat(augmented_file_path)\n new_key = augmented_file_name + str(statinfo.st_size)\n image_data = json_data[key]\n new_image_data[\"filename\"] = augmented_file_name\n new_image_data[\"size\"] = int(statinfo.st_size)\n new_json_data[new_key] = new_image_data\n\n json.dump(new_json_data, modified_json_file)","def backeruper(file_name, file_num=0):\n\n if not os.path.exists('%s.json' % file_name):\n write_backup('%s.json' % file_name)\n elif not os.path.exists('%s.%s.json' % (file_name, file_num)):\n write_backup('%s.%s.json' % (file_name, file_num))\n else:\n file_num += 1\n backeruper(file_name, file_num)","def download_hero_images(file_name, output_dir):\n with open(file_name,'r') as json_file:\n hero_json = json.load(json_file) \n try:\n os.mkdir(output_dir)\n except OSError:\n print (\"Failed to create directory %s\" % output_dir)\n return\n for hero in hero_json:\n print (\"Processing %s.\" % hero['name'])\n hero_dir = output_dir + '/' + str(hero['hero_id'])\n os.mkdir(hero_dir)\n urlr.urlretrieve(hero['img_url'], hero_dir + '/main.' + IMAGE_EXTENSION);\n urlr.urlretrieve(hero['portrait_img_url'], hero_dir + '/portrait.' + IMAGE_EXTENSION);\n\n for ability in hero['abilities']:\n ability_img = hero_dir + '/ability_' + str(ability['ability_id']) + '.' + IMAGE_EXTENSION\n urlr.urlretrieve(ability['img_url'], ability_img);","def add_shapefile_data(self, output):\n prefix = \"hazard\" if output.output_type == \"hazard_map\" else \"loss\"\n dirname = os.path.dirname(output.path)\n layer_name, _ = os.path.splitext(os.path.basename(output.path))\n layer_name = layer_name.replace(\".\", \"-\")\n dirname = os.path.join(dirname, \"%s-shapefiles\" % prefix)\n output.shapefile_path = os.path.join(dirname, \"%s.shp\" % layer_name)\n os.rename(self.touch(dir=dirname), output.shapefile_path)\n output.min_value = random.random()\n output.max_value = output.min_value * math.pi\n output.save()\n return output.shapefile_path","def rename_files_remove_version_number(files_dir, output_dir, logger=None):\n\n file_name_map = {}\n\n # Get a list of all files\n dirfiles = file_list(files_dir)\n\n for df in dirfiles:\n filename = df.split(os.sep)[-1]\n\n # Get the new file name\n file_name_map[filename] = None\n\n # TODO strip the -v1 from it\n file_extension = filename.split('.')[-1]\n if '-v' in filename:\n # Use part before the -v number\n part_without_version = filename.split('-v')[0]\n else:\n # No -v found, use the file name minus the extension\n part_without_version = ''.join(filename.split('.')[0:-1])\n\n renamed_filename = part_without_version + '.' + file_extension\n\n if renamed_filename:\n file_name_map[filename] = renamed_filename\n else:\n if logger:\n logger.info('there is no renamed file for ' + filename)\n\n for old_name, new_name in file_name_map.iteritems():\n if new_name is not None:\n shutil.move(files_dir + os.sep + old_name, output_dir + os.sep + new_name)\n\n return file_name_map","def fileResizeObscure(new_filepath):\n # Resize\n img1 = Image.open(new_filepath)\n img2=image_reduce(img1)\n *** Stopped working here\n newpath=\"toupload\\\\%s\" % new_filepath\n # Block ID\n width=img2.size[0]\n height=img2.size[1]\n # Obscuring params were decided by trial and error using fraction of width and height\n x1=int(0.16*width)\n x2=int(0.28*width)\n y1=int(0.94*height)\n y2=int(0.98*height) \n # Faster but easier to snoop? should not be since it changes the pixels\n draw = ImageDraw.Draw(img2)\n draw.rectangle([(x1,y1),(x2,y2)],fill=\"white\")\n del draw\n \n img2.save(newpath,optimize=True,quality=95)","def adjust_for_speed_of_light_in_water(df, tide_level):\n speed_of_light_air = 300000\n speed_of_light_water = 225000\n coef = speed_of_light_water / speed_of_light_air\n df['Height'] = (df['Height']- tide_level) * coef\n return df","def assumpfile_bad2():\n afile = tempfile.NamedTemporaryFile(suffix='.json', mode='a', delete=False)\n bad2_assump_contents = \"\"\"\n {\n \"consumption\": {},\n \"behavior\": {},\n \"growdiff_baseline\": {},\n \"growdiff_response\": {\"_ABOOK\": {\"2015\": [-0.01]}}\n }\n \"\"\"\n afile.write(bad2_assump_contents)\n afile.close()\n # must close and then yield for Windows platform\n yield afile\n if os.path.isfile(afile.name):\n try:\n os.remove(afile.name)\n except OSError:\n pass # sometimes we can't remove a generated temporary file","def WriteOnDiff(filename):\n\n class Writer(object):\n \"\"\"Wrapper around file which only covers the target if it differs.\"\"\"\n def __init__(self):\n # Pick temporary file.\n tmp_fd, self.tmp_path = tempfile.mkstemp(\n suffix='.tmp',\n prefix=os.path.split(filename)[1] + '.gyp.',\n dir=os.path.split(filename)[0]\n )\n try:\n self.tmp_file = os.fdopen(tmp_fd, 'w')\n except Exception:\n # Don't leave turds behind.\n os.unlink(self.tmp_path)\n raise\n\n def __getattr__(self, attrname):\n # Delegate everything else to self.tmp_file\n return getattr(self.tmp_file, attrname)\n\n def close(self):\n try:\n # Close tmp file.\n self.tmp_file.close()\n # Determine if different.\n same = False\n try:\n same = filecmp.cmp(self.tmp_path, filename, False)\n except OSError as e:\n if e.errno != errno.ENOENT:\n raise\n\n if same:\n # The new file is identical to the old one, just get rid of the new one.\n os.unlink(self.tmp_path)\n else:\n # The new file is different from the old one, or there is no old one.\n # Rename the new file to the permanent name.\n #\n # tempfile.mkstemp uses an overly restrictive mode, resulting in a\n # file that can only be read by the owner, regardless of the umask.\n # There's no reason to not respect the umask here, which means that\n # an extra hoop is required to fetch it and reset the new file's mode.\n #\n # No way to get the umask without setting a new one? Set a safe one\n # and then set it back to the old value.\n umask = os.umask(0o77)\n os.umask(umask)\n os.chmod(self.tmp_path, 0o666 & ~umask)\n if sys.platform == 'win32' and os.path.exists(filename):\n # NOTE: on windows (but not cygwin) rename will not replace an\n # existing file, so it must be preceded with a remove. Sadly there\n # is no way to make the switch atomic.\n os.remove(filename)\n os.rename(self.tmp_path, filename)\n except Exception:\n # Don't leave turds behind.\n os.unlink(self.tmp_path)\n raise\n\n return Writer()","def write_shapefile_combined(self, shpname):\r\n self.read_traveltime()\r\n \r\n westlats1 = []\r\n westlons1 = []\r\n eastlats1 = []\r\n eastlons1 = [] \r\n lines1 = []\r\n #### points ####\r\n lats1 = []\r\n lons1 = []\r\n for i in range(len(self.westPnts1)):\r\n westlat1, westlon1 = utm.to_latlon(self.westPnts1[i,0], self.westPnts1[i,1], 14, 'U')\r\n eastlat1, eastlon1 = utm.to_latlon(self.eastPnts1[i,0], self.eastPnts1[i,1], 14, 'U')\r\n lines1.append([[westlon1, westlat1], [eastlon1, eastlat1]])\r\n westlats1.append(westlat1)\r\n westlons1.append(westlon1)\r\n eastlats1.append(eastlat1)\r\n eastlons1.append(eastlon1)\r\n #### points ####\r\n lats1.append((westlat1+eastlat1)/2.)\r\n lons1.append((westlon1+eastlon1)/2.)\r\n \r\n \r\n \r\n \r\n \r\n westlats5 = []\r\n westlons5 = []\r\n eastlats5 = []\r\n eastlons5 = [] \r\n lines5 = []\r\n #### points ####\r\n lats5 = []\r\n lons5 = []\r\n for i in range(len(self.westPnts5)):\r\n westlat5, westlon5 = utm.to_latlon(self.westPnts5[i,0], self.westPnts5[i,1], 14, 'U')\r\n eastlat5, eastlon5 = utm.to_latlon(self.eastPnts5[i,0], self.eastPnts5[i,1], 14, 'U')\r\n lines5.append([[westlon5, westlat5], [eastlon5, eastlat5]])\r\n westlats5.append(westlat5)\r\n westlons5.append(westlon5)\r\n eastlats5.append(eastlat5)\r\n eastlons5.append(eastlon5)\r\n #### points ####\r\n lats5.append((westlat5+eastlat5)/2.)\r\n lons5.append((westlon5+eastlon5)/2.)\r\n \r\n \r\n Narray_branch1 = len(self.inarrays_branch1)\r\n Narray_branch5 = len(self.inarrays_branch5)\r\n \r\n #### travel time for branch 1\r\n Ttime = self.inarrays_branch1[0][:,2]\r\n ind0 = np.nonzero(Ttime)[0][0]\r\n ind = np.arange(ind0, Ttime.shape[0])\r\n \r\n\r\n branchIDs_branch1 = []\r\n SegIDs_branch1 = []\r\n lines_branch1 = []\r\n westlats_branch1 = []\r\n westlons_branch1 = []\r\n eastlats_branch1 = []\r\n eastlons_branch1 = []\r\n lats_branch1 = []\r\n lons_branch1 = []\r\n Ttimes_branch1 = []\r\n Density_branch1 = []\r\n Initial_loc_branch1 = []\r\n solubility_branch1 = []\r\n flow_condition_branch1 = []\r\n concentration_branch1 = []\r\n water_level_branch1 = []\r\n dist_branch1 = []\r\n \r\n \r\n \r\n for iarray in range(Narray_branch1):\r\n \r\n #### find indexes which segment has travel time\r\n Ttime_tem = self.inarrays_branch1[iarray][:,2]\r\n ind0 = np.nonzero(Ttime_tem)[0][0]\r\n ind = np.arange(ind0, Ttime_tem.shape[0])\r\n \r\n for i in range(self.inarrays_branch1[0].shape[0]):\r\n \r\n if i in ind:\r\n branchIDs_branch1.append(self.inarrays_branch1[iarray][i,0])\r\n SegIDs_branch1.append(self.inarrays_branch1[iarray][i,1])\r\n lines_branch1.append(lines1[i])\r\n westlats_branch1.append(westlats1[i])\r\n westlons_branch1.append(westlons1[i])\r\n eastlats_branch1.append(eastlats1[i])\r\n eastlons_branch1.append(eastlons1[i])\r\n lats_branch1.append(lats1[i])\r\n lons_branch1.append(lons1[i])\r\n \r\n Ttimes_branch1.append(self.inarrays_branch1[iarray][i,2])\r\n if self.inarrays_branch1[iarray][i,3] == 0:\r\n Density_branch1.append('Light')\r\n elif self.inarrays_branch1[iarray][i,3] == 1:\r\n Density_branch1.append('Heavy')\r\n elif self.inarrays_branch1[iarray][i,3] == 9:\r\n Density_branch1.append('None')\r\n \r\n Initial_loc_branch1.append('East')\r\n \r\n if self.inarrays_branch1[iarray][i,5] == 0:\r\n solubility_branch1.append('Insoluble')\r\n elif self.inarrays_branch1[iarray][i,5] == 1:\r\n solubility_branch1.append('Soluble')\r\n \r\n if self.inarrays_branch1[iarray][i,6] == 3:\r\n #flow_condition_branch1.append('High')\r\n flow_condition_branch1.append('> 945 cfs')\r\n elif self.inarrays_branch1[iarray][i,6] == 2:\r\n #flow_condition_branch1.append('Medium')\r\n flow_condition_branch1.append('110 ~ 945 cfs')\r\n elif self.inarrays_branch1[iarray][i,6] == 1:\r\n #flow_condition_branch1.append('Low')\r\n flow_condition_branch1.append('< 110 cfs')\r\n \r\n if self.inarrays_branch1[iarray][i,7] != 0:\r\n concentration_branch1.append(\"{:.3E}\".format(Decimal(self.inarrays_branch1[iarray][i,7])))\r\n else:\r\n concentration_branch1.append(str(self.inarrays_branch1[iarray][i,7]))\r\n \r\n water_level_branch1.append(self.inarrays_branch1[iarray][i,8])\r\n dist_branch1.append(self.inarrays_branch1[iarray][i,9])\r\n \r\n #### travel time for branch 5\r\n #Ttime = self.inarrays_particle_branch5[0][:,2]\r\n #ind1 = np.arange(43, 45) -1 #### hard coded, for release in branch 5\r\n #ind5 = np.nonzero(Ttime)[0]\r\n \r\n \r\n branchIDs_branch5 = []\r\n SegIDs_branch5 = []\r\n lines_branch5 = []\r\n westlats_branch5 = []\r\n westlons_branch5 = []\r\n eastlats_branch5 = []\r\n eastlons_branch5 = []\r\n lats_branch5 = []\r\n lons_branch5 = []\r\n Ttimes_branch5 = []\r\n Density_branch5 = []\r\n Initial_loc_branch5 = []\r\n solubility_branch5 = []\r\n flow_condition_branch5 = []\r\n concentration_branch5 = []\r\n water_level_branch5 = []\r\n dist_branch5 = []\r\n \r\n \r\n ## loop over all travel time for each array, find which is in branch 1 and which is in branch 5\r\n for iarray in range(Narray_branch5): \r\n \r\n #### find indexes which segment has travel time\r\n Ttime_tem = self.inarrays_branch5[iarray][:,2]\r\n \r\n nbr5 = len(lines5) ## number of elements in branch 5\r\n ind1 = np.arange(43, 45) -1 + nbr5 #### hard coded, for release in branch 5 len(branch5)+ [43,44] - 1\r\n ind5 = np.nonzero(Ttime_tem)[0]\r\n \r\n for i in range(self.inarrays_branch5[0].shape[0]):\r\n #if iarray==6 and i == 44:\r\n # pdb.set_trace()\r\n if self.inarrays_branch5[iarray][i,0] == 5: ## at branch 5\r\n \r\n if i in ind5:\r\n branchIDs_branch5.append(self.inarrays_branch5[iarray][i,0])\r\n SegIDs_branch5.append(self.inarrays_branch5[iarray][i,1])\r\n lines_branch5.append(lines5[i])\r\n westlats_branch5.append(westlats5[i])\r\n westlons_branch5.append(westlons5[i])\r\n eastlats_branch5.append(eastlats5[i])\r\n eastlons_branch5.append(eastlons5[i])\r\n lats_branch5.append(lats5[i])\r\n lons_branch5.append(lons5[i])\r\n \r\n Ttimes_branch5.append(self.inarrays_branch5[iarray][i,2])\r\n if self.inarrays_branch5[iarray][i,3] == 0:\r\n Density_branch5.append('Light')\r\n elif self.inarrays_branch5[iarray][i,3] == 1:\r\n Density_branch5.append('Heavy')\r\n elif self.inarrays_branch5[iarray][i,3] == 9:\r\n Density_branch5.append('None')\r\n \r\n if self.inarrays_branch5[iarray][i,4] == 1:\r\n Initial_loc_branch5.append('East')\r\n elif self.inarrays_branch5[iarray][i,4] == 5:\r\n Initial_loc_branch5.append('West')\r\n \r\n if self.inarrays_branch5[iarray][i,5] == 0:\r\n solubility_branch5.append('Insoluble')\r\n elif self.inarrays_branch5[iarray][i,5] == 1:\r\n solubility_branch5.append('Soluble')\r\n \r\n if self.inarrays_branch5[iarray][i,6] == 3:\r\n flow_condition_branch5.append('> 945 cfs')\r\n elif self.inarrays_branch5[iarray][i,6] == 2:\r\n flow_condition_branch5.append('110 ~ 945 cfs')\r\n elif self.inarrays_branch5[iarray][i,6] == 1:\r\n flow_condition_branch5.append('< 110 cfs')\r\n \r\n if self.inarrays_branch5[iarray][i,7] != 0:\r\n concentration_branch5.append(\"{:.3E}\".format(Decimal(self.inarrays_branch5[iarray][i,7])))\r\n else: \r\n concentration_branch5.append(str(self.inarrays_branch5[iarray][i,7]))\r\n \r\n water_level_branch5.append(self.inarrays_branch5[iarray][i,8])\r\n dist_branch5.append(self.inarrays_branch5[iarray][i,9])\r\n \r\n \r\n elif self.inarrays_branch5[iarray][i,0] == 1: ## at branch 1\r\n \r\n if i in ind1:\r\n \r\n branchIDs_branch5.append(self.inarrays_branch5[iarray][i,0])\r\n SegIDs_branch5.append(self.inarrays_branch5[iarray][i,1])\r\n lines_branch5.append(lines1[i-nbr5])\r\n westlats_branch5.append(westlats1[i-nbr5])\r\n westlons_branch5.append(westlons1[i-nbr5])\r\n eastlats_branch5.append(eastlats1[i-nbr5])\r\n eastlons_branch5.append(eastlons1[i-nbr5])\r\n lats_branch5.append(lats1[i-nbr5])\r\n lons_branch5.append(lons1[i-nbr5])\r\n \r\n Ttimes_branch5.append(self.inarrays_branch5[iarray][i,2])\r\n if self.inarrays_branch5[iarray][i,3] == 0:\r\n Density_branch5.append('Light')\r\n elif self.inarrays_branch5[iarray][i,3] == 1:\r\n Density_branch5.append('Heavy')\r\n elif self.inarrays_branch5[iarray][i,3] == 9:\r\n Density_branch5.append('None')\r\n \r\n if self.inarrays_branch5[iarray][i,4] == 1:\r\n Initial_loc_branch5.append('East')\r\n elif self.inarrays_branch5[iarray][i,4] == 5:\r\n Initial_loc_branch5.append('West')\r\n \r\n if self.inarrays_branch5[iarray][i,5] == 0:\r\n solubility_branch5.append('Insoluble')\r\n elif self.inarrays_branch5[iarray][i,5] == 1:\r\n solubility_branch5.append('Soluble')\r\n \r\n if self.inarrays_branch5[iarray][i,6] == 3:\r\n flow_condition_branch5.append('> 945 cfs')\r\n elif self.inarrays_branch5[iarray][i,6] == 2:\r\n flow_condition_branch5.append('110 ~ 945 cfs')\r\n elif self.inarrays_branch5[iarray][i,6] == 1:\r\n flow_condition_branch5.append('< 110 cfs')\r\n \r\n if self.inarrays_branch5[iarray][i,7] != 0:\r\n concentration_branch5.append(\"{:.3E}\".format(Decimal(self.inarrays_branch5[iarray][i,7])))\r\n else:\r\n concentration_branch5.append(str(self.inarrays_branch5[iarray][i,7]))\r\n \r\n water_level_branch5.append(self.inarrays_branch5[iarray][i,8])\r\n dist_branch5.append(self.inarrays_branch5[iarray][i,9])\r\n \r\n\r\n #### combine all data into one big array\r\n branchIDs_combined = branchIDs_branch1 + branchIDs_branch5\r\n SegIDs_combined = SegIDs_branch1 + SegIDs_branch5 \r\n lines_combined = lines_branch1 + lines_branch5\r\n# westlats_combined = westlats_branch1 + westlats_branch5\r\n# westlons_combined = westlons_branch1 + westlons_branch5\r\n# eastlats_combined = eastlats_branch1 + eastlats_branch5\r\n# eastlons_combined = eastlons_branch1 + eastlons_branch5\r\n lats_combined = lats_branch1 + lats_branch5\r\n lons_combined = lons_branch1 + lons_branch5\r\n \r\n Ttimes_combined = Ttimes_branch1 + Ttimes_branch5\r\n Density_combined = Density_branch1 + Density_branch5\r\n Initial_loc_combined = Initial_loc_branch1 + Initial_loc_branch5\r\n solubility_combined = solubility_branch1 + solubility_branch5\r\n flow_combined = flow_condition_branch1 + flow_condition_branch5\r\n concentration_combined = concentration_branch1 + concentration_branch5 \r\n water_level_combined = water_level_branch1 + water_level_branch5 \r\n dist_combined = dist_branch1 + dist_branch5\r\n \r\n #### Create the shapefile\r\n # Create the projection\r\n spatialReference = osgeo.osr.SpatialReference()\r\n spatialReference.ImportFromProj4('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')\r\n \r\n # Create the shape file\r\n outfile = r'ArcGIS_online\\%s'%shpname\r\n driver = osgeo.ogr.GetDriverByName('ESRI Shapefile')\r\n shapeData = driver.CreateDataSource(outfile)\r\n \r\n # Create the layer\r\n layer = shapeData.CreateLayer('Contour', spatialReference, osgeo.ogr.wkbPoint)\r\n layerDefinition = layer.GetLayerDefn()\r\n \r\n # Create fields containing segment infos\r\n field_def = osgeo.ogr.FieldDefn('BranchID', osgeo.ogr.OFTInteger)\r\n layer.CreateField(field_def)\r\n \r\n field_def = osgeo.ogr.FieldDefn('SegID', osgeo.ogr.OFTInteger)\r\n layer.CreateField(field_def)\r\n \r\n field_def = osgeo.ogr.FieldDefn('Lon', osgeo.ogr.OFTReal)\r\n layer.CreateField(field_def)\r\n \r\n field_def = osgeo.ogr.FieldDefn('Lat', osgeo.ogr.OFTReal)\r\n layer.CreateField(field_def)\r\n \r\n #field_def = osgeo.ogr.FieldDefn('Lon_east', osgeo.ogr.OFTReal)\r\n #layer.CreateField(field_def)\r\n \r\n #field_def = osgeo.ogr.FieldDefn('Lat_east', osgeo.ogr.OFTReal)\r\n #layer.CreateField(field_def)\r\n \r\n field_def = osgeo.ogr.FieldDefn('T (day)', osgeo.ogr.OFTInteger)\r\n layer.CreateField(field_def)\r\n \r\n ## density - type: string, option: light-0, heavey-1 \r\n field_def = osgeo.ogr.FieldDefn('Density', osgeo.ogr.OFTString)\r\n layer.CreateField(field_def)\r\n \r\n ## initial release location - type: string, option: East-1, West-5\r\n field_def = osgeo.ogr.FieldDefn('Initial', osgeo.ogr.OFTString)\r\n layer.CreateField(field_def)\r\n \r\n ## solubility\r\n field_def = osgeo.ogr.FieldDefn('Solubility', osgeo.ogr.OFTString)\r\n layer.CreateField(field_def)\r\n \r\n ## flow condition\r\n field_def = osgeo.ogr.FieldDefn('Flow', osgeo.ogr.OFTString)\r\n layer.CreateField(field_def)\r\n \r\n ## concentration\r\n field_def = osgeo.ogr.FieldDefn('C (mg/L)', osgeo.ogr.OFTString)\r\n layer.CreateField(field_def)\r\n \r\n ## water surface elevation\r\n field_def = osgeo.ogr.FieldDefn('WSE (ft)', osgeo.ogr.OFTReal)\r\n layer.CreateField(field_def)\r\n \r\n ## distance to WTP gate\r\n field_def = osgeo.ogr.FieldDefn('D (ft)', osgeo.ogr.OFTReal)\r\n layer.CreateField(field_def)\r\n \r\n \r\n def add_feature(layer, branchID, segs, lines, lon, lat, Ttime, density, Initial_loc, solubility, flows, concentration, water_level, dist):\r\n \"\"\"\r\n function that adds feature to layer\r\n \"\"\" \r\n ctr=0\r\n for i in range(len(lines)):\r\n ctr+=1\r\n point = osgeo.ogr.Geometry(osgeo.ogr.wkbPoint)\r\n # Add points individually to the line\r\n #xy = lines[i]\r\n \r\n #line.AddPoint_2D(xy[0][0],xy[0][1])\r\n #line.AddPoint_2D(xy[1][0],xy[1][1])\r\n point.AddPoint(lon[i], lat[i])\r\n # Update the feature with the line data\r\n featureIndex = ctr\r\n feature = osgeo.ogr.Feature(layerDefinition)\r\n #feature.SetStyleString(\"PEN(c:r,w:5px)\") \r\n feature.SetGeometry(point)\r\n feature.SetFID(featureIndex)\r\n feature.SetGeometryDirectly(point)\r\n \r\n # Set the attribute table\r\n feature.SetField('BranchID', int(branchID[i])) \r\n feature.SetField('SegID', int(segs[i])) # convert to int() is necessary, osgeo cannot recognize numpy int32 type\r\n feature.SetField('Lon', \"{:.3f}\".format(lon[i]))\r\n feature.SetField('Lat', \"{:.3f}\".format(lat[i]))\r\n #feature.SetField('Lon_east', \"{:.3f}\".format(eastlon[i]))\r\n #feature.SetField('Lat_east', \"{:.3f}\".format(eastlat[i]))\r\n feature.SetField('T (day)', int(Ttime[i]))\r\n feature.SetField('Density', density[i])\r\n feature.SetField('Initial', Initial_loc[i])\r\n feature.SetField('Solubility', solubility[i])\r\n feature.SetField('Flow', flows[i])\r\n feature.SetField('C (mg/L)', concentration[i])\r\n feature.SetField('WSE (ft)', water_level[i])\r\n feature.SetField('D (ft)', dist[i])\r\n \r\n layer.CreateFeature(feature)\r\n \r\n \r\n add_feature(layer, branchIDs_combined, SegIDs_combined, lines_combined, \\\r\n lons_combined, lats_combined,\\\r\n Ttimes_combined, Density_combined, Initial_loc_combined, solubility_combined, \\\r\n flow_combined, concentration_combined, water_level_combined, dist_combined)","def fix_name_table(font):\n modified = False\n name_records = font_data.get_name_records(font)\n\n copyright_data = name_records[0]\n years = re.findall('20[0-9][0-9]', copyright_data)\n year = min(years)\n copyright_data = u'Copyright %s Google Inc. All Rights Reserved.' % year\n\n if copyright_data != name_records[0]:\n print('Updated copyright message to \"%s\"' % copyright_data)\n font_data.set_name_record(font, 0, copyright_data)\n modified = True\n\n for name_id in [1, 3, 4, 6]:\n record = name_records[name_id]\n for source in NAME_CORRECTIONS:\n if source in record:\n oldrecord = record\n record = record.replace(source, NAME_CORRECTIONS[source])\n break\n if record != name_records[name_id]:\n font_data.set_name_record(font, name_id, record)\n print('Updated name table record #%d from \"%s\" to \"%s\"' % (\n name_id, oldrecord, record))\n modified = True\n\n trademark_names = ['Noto', 'Arimo', 'Tinos', 'Cousine']\n trademark_name = None\n font_family = name_records[1]\n for name in trademark_names:\n if font_family.find(name) != -1:\n trademark_name = name\n break\n if not trademark_name:\n print('no trademarked name in \\'%s\\'' % font_family)\n else:\n trademark_line = TRADEMARK_TEMPLATE % trademark_name\n if name_records[7] != trademark_line:\n old_line = name_records[7]\n font_data.set_name_record(font, 7, trademark_line)\n modified = True\n print('Updated name table record 7 from \"%s\" to \"%s\"' % (old_line, trademark_line))\n\n if name_records[11] != NOTO_URL:\n font_data.set_name_record(font, 11, NOTO_URL)\n modified = True\n print('Updated name table record 11 to \"%s\"' % NOTO_URL)\n\n if name_records[_LICENSE_ID] != _SIL_LICENSE:\n font_data.set_name_record(font, _LICENSE_ID, _SIL_LICENSE)\n modified = True\n print('Updated license id')\n\n if name_records[_LICENSE_URL_ID] != _SIL_LICENSE_URL:\n font_data.set_name_record(font, _LICENSE_URL_ID, _SIL_LICENSE_URL)\n modified = True\n print('Updated license url')\n\n # TODO: check preferred family/subfamily(16&17)\n\n return modified","def crudo_rename(fecha):\n os.rename(\"/var/lib/reportes-zabbix/crudos/Merged-Trends-{}.pickle\".format(datetime.today().date()),\"/var/lib/reportes-zabbix/crudos/Merged-Trends-{}.pickle\".format(fecha))\n os.rename(\"/var/lib/reportes-zabbix/crudos/Merged-Trends-{}_ONT.pickle\".format(datetime.today().date()),\"/var/lib/reportes-zabbix/crudos/Merged-Trends-{}_ONT.pickle\".format(fecha))","def WriteStructuralMaterialsjson(save_path,dic_in_json_format):\n complete_name=os.path.join(save_path,\"StructuralMaterials.json\") \n with open(complete_name, \"w\") as save_file:\n save_file.write(dic_in_json_format)\n if(DEBUG):\n print(\"StructuralMaterials.json written\")","def autorename_shots(context):\n\n for index, shot in enumerate(context.scene.milkshake_shots):\n shot.code = f\"SH{index + 1 :02}\"\n shot.camera.name = f\"{shot.code}.CAMX.000\"\n for obj in bpy.data.objects:\n if obj.data == shot.camera:\n obj.name = shot.camera.name\n break\n core.log(f\"Renamed shot {shot.code} and camera {shot.camera.name}.\")","def rename_bones(s='', t='unreal'):\r\n unreal = {\r\n 'root': 'Root',\r\n 'Hips': 'Pelvis',\r\n 'Spine': 'spine_01',\r\n 'Spine1': 'spine_02',\r\n 'Spine2': 'spine_03',\r\n 'LeftShoulder': 'clavicle_l',\r\n 'LeftArm': 'upperarm_l',\r\n 'LeftForeArm': 'lowerarm_l',\r\n 'LeftHand': 'hand_l',\r\n 'RightShoulder': 'clavicle_r',\r\n 'RightArm': 'upperarm_r',\r\n 'RightForeArm': 'lowerarm_r',\r\n 'RightHand': 'hand_r',\r\n 'Neck1': 'neck_01',\r\n 'Neck': 'neck_01',\r\n 'Head': 'head',\r\n 'LeftUpLeg': 'thigh_l',\r\n 'LeftLeg': 'calf_l',\r\n 'LeftFoot': 'foot_l',\r\n 'RightUpLeg': 'thigh_r',\r\n 'RightLeg': 'calf_r',\r\n 'RightFoot': 'foot_r',\r\n 'LeftHandIndex1': 'index_01_l',\r\n 'LeftHandIndex2': 'index_02_l',\r\n 'LeftHandIndex3': 'index_03_l',\r\n 'LeftHandMiddle1': 'middle_01_l',\r\n 'LeftHandMiddle2': 'middle_02_l',\r\n 'LeftHandMiddle3': 'middle_03_l',\r\n 'LeftHandPinky1': 'pinky_01_l',\r\n 'LeftHandPinky2': 'pinky_02_l',\r\n 'LeftHandPinky3': 'pinky_03_l',\r\n 'LeftHandRing1': 'ring_01_l',\r\n 'LeftHandRing2': 'ring_02_l',\r\n 'LeftHandRing3': 'ring_03_l',\r\n 'LeftHandThumb1': 'thumb_01_l',\r\n 'LeftHandThumb2': 'thumb_02_l',\r\n 'LeftHandThumb3': 'thumb_03_l',\r\n 'RightHandIndex1': 'index_01_r',\r\n 'RightHandIndex2': 'index_02_r',\r\n 'RightHandIndex3': 'index_03_r',\r\n 'RightHandMiddle1': 'middle_01_r',\r\n 'RightHandMiddle2': 'middle_02_r',\r\n 'RightHandMiddle3': 'middle_03_r',\r\n 'RightHandPinky1': 'pinky_01_r',\r\n 'RightHandPinky2': 'pinky_02_r',\r\n 'RightHandPinky3': 'pinky_03_r',\r\n 'RightHandRing1': 'ring_01_r',\r\n 'RightHandRing2': 'ring_02_r',\r\n 'RightHandRing3': 'ring_03_r',\r\n 'RightHandThumb1': 'thumb_01_r',\r\n 'RightHandThumb2': 'thumb_02_r',\r\n 'RightHandThumb3': 'thumb_03_r',\r\n 'LeftToeBase': 'ball_l',\r\n 'RightToeBase': 'ball_r'\r\n }\r\n schema = {'unreal': unreal }\r\n if type(s) == str:\r\n i = schema[t].get(s)\r\n if i:\r\n return i\r\n else:\r\n log.warning('WARNING %s bone is missing', s)\r\n return s\r\n elif type(s) == Object:\r\n if s.type == 'ARMATURE':\r\n for bone in s.data.bones:\r\n bone.name = rename_bones(remove_namespace(bone.name))\r\n s.name = rename_bones(s.name)\r\n return 1\r\n return -1","def updateHeightsTexture(self, gl):\n\n if (self.heightsTexture.width() != self.logicalResources.n or \n self.heightsTexture.height() != self.logicalResources.m):\n self.heightsTexture.destroy()\n\n self.heightsTexture = self.createTexture(gl, self.logicalResources.m, self.logicalResources.n, \n format=QOpenGLTexture.RG32F, filter=QOpenGLTexture.Nearest)\n \n data = []\n for i in range(self.logicalResources.n):\n for j in range(self.logicalResources.m):\n data.extend([ self.logicalResources.landscapeHeightsMatrix[i][j] * ZScale\n , self.logicalResources.waterHeightsMatrix[i][j] * ZScale])\n data = struct.pack('{}f'.format(len(data)), *data)\n\n self.heightsTexture.setData(QOpenGLTexture.RG, QOpenGLTexture.Float32, data)","def add_heights():\n fac_min = 50\n fac_max = 40\n\n print 'Get lands and oceans'\n t = time.time()\n lands, oceans = get_lands_oceans()\n print 'lands and oceans getted: ', time.time() - t\n\n # TODO: create one def with params: mount_level and other for create heights\n # add default heights\n for coord in lands:\n self[coord] = self.config.land_mount_level[1]\n\n for coord in oceans:\n self[coord] = -self.config.mid_mount_level[1]\n\n # add low heights for lands\n count_land = int(round(len(lands) * config.factor_low_mount / 100.))\n land_coords = []\n\n starts = random.randint(count_land / fac_min, count_land / fac_max)\n for start in xrange(starts):\n start_coord = lands[random.randint(0, len(lands)-1)]\n land_coords.append(start_coord)\n self[start_coord] = random.randint(self.config.low_mount_level[0], self.config.low_mount_level[1])\n\n while count_land > 0:\n # for lands\n if count_land > 0:\n dx = random.randint(-1,1)\n dy = random.randint(-1,1)\n coord = land_coords[random.randint(0, len(land_coords) - 1)]\n coord = coord[0] + dx, coord[1] + dy\n if coord not in land_coords:\n self[coord] = random.randint(self.config.low_mount_level[0], self.config.low_mount_level[1])\n land_coords.append(coord)\n count_land -= 1\n\n\n target_lands = land_coords\n\n # -------------------------------------------------------------------------------\n # add mid heights for lands\n count_land = int(round(len(target_lands) * (config.factor_mid_mount / 100.)))\n land_coords = []\n\n starts = random.randint(count_land / (fac_min * 3), count_land / (fac_max*3))\n for start in xrange(starts):\n start_coord = target_lands[random.randint(0, len(target_lands)-1)]\n land_coords.append(start_coord)\n self[start_coord] = random.randint(self.config.mid_mount_level[0],\n self.config.mid_mount_level[1])\n\n if land_coords == []:\n return\n\n while count_land > 0:\n # for lands\n if count_land > 0:\n dx = random.randint(-1,1)\n dy = random.randint(-1,1)\n coord = land_coords[random.randint(0, len(land_coords) - 1)]\n coord = coord[0] + dx, coord[1] + dy\n #if coord not in land_coords:\n self[coord] = random.randint(self.config.mid_mount_level[0],\n self.config.mid_mount_level[1])\n land_coords.append(coord)\n count_land -= 1\n\n\n target_lands = land_coords\n\n\n # -------------------------------------------------------------------------------\n # add high heights for lands\n count_land = int(round(len(target_lands) * (config.factor_high_mount / 100.)))\n land_coords = []\n\n starts = random.randint(count_land / (fac_min * 4), count_land / (fac_max * 3))\n for start in xrange(starts):\n start_coord = target_lands[random.randint(0, len(target_lands)-1)]\n land_coords.append(start_coord)\n self[start_coord] = random.randint(self.config.high_mount_level[0],\n self.config.high_mount_level[1])\n\n while count_land > 0:\n # for lands\n if count_land > 0:\n dx = random.randint(-1,1)\n dy = random.randint(-1,1)\n try:\n coord = land_coords[random.randint(0, len(land_coords) - 1)]\n except ValueError:\n coord = lands[random.randint(0, len(lands) - 1)]\n coord = coord[0] + dx, coord[1] + dy\n #if coord not in land_coords:\n self[coord] = random.randint(self.config.high_mount_level[0],\n self.config.high_mount_level[1])\n land_coords.append(coord)\n count_land -= 1","def add_hydrogens_by_reduce(pdb, pdb_path=None):\n if pdb_path is None:\n pdb_path = PDB_PATH\n # Check if hydrogens were added before\n if not Path(str(Path(pdb_path) / (pdb + 'h.pdb'))).is_file():\n print(str(Path(pdb_path) / (pdb + '.pdb')))\n subprocess.check_output(REDUCE_PATH + \\\n ' -p ' + str(Path(pdb_path) / (pdb + '.pdb')) + \\\n ' > ' + str(Path(pdb_path) / (pdb + 'h.pdb')), shell=True\n ) # Somehow with list of parameters does't work properly\n print(f'Added hydrogens to {pdb}.pdb')\n else:\n print(f'Were before added hydrogens to {pdb}.pdb')","def drename(filepath, namelength = 15):\n\tfilepath = os.path.abspath(filepath)\n\tif not os.path.isfile(filepath):\n\t\traise ValueError(\"The path is not a valid file path: \"+str(filepath))\n\t\n\tpath, name = os.path.split(filepath)\n\tname, ext = os.path.splitext(name)\n\tos.rename(filepath, os.path.join(path, dname(namelength)+ext)) #We replace name by the random name and reconstruct the path","def assumpfile_bad1():\n afile = tempfile.NamedTemporaryFile(suffix='.json', mode='a', delete=False)\n bad1_assump_contents = \"\"\"\n {\n \"consumption\": {},\n \"behavior\": {\"_BE_sub\": {\"2020\": [0.05]}},\n \"growdiff_baseline\": {},\n \"growdiff_response\": {}\n }\n \"\"\"\n afile.write(bad1_assump_contents)\n afile.close()\n # must close and then yield for Windows platform\n yield afile\n if os.path.isfile(afile.name):\n try:\n os.remove(afile.name)\n except OSError:\n pass # sometimes we can't remove a generated temporary file","def fix_image_dict(folder, image_dict):\n image_pattern = os.path.join(LOCAL_IMAGE_PATH, \"*.*\")\n for file_path in glob.glob(image_pattern):\n file_name = os.path.basename(file_path)\n if file_name not in image_dict:\n image_dict[file_name] = [replace_underscore(os.path.splitext(file_name)[0])]","def trim_long_colnames(cat):\n import re\n long_short_pairs = [\n ('GeneralShapeletPsf', 'GSPsf'),\n ('DoubleShapelet', 'DS'),\n ('noSecondDerivative', 'NoSecDer')]\n for long, short in long_short_pairs:\n long_re = re.compile(long)\n for col_name in cat.colnames:\n if long_re.search(col_name):\n new_col_name = long_re.sub(short, col_name)\n cat.rename_column(col_name, new_col_name)","def _update_stat_json(self, stat_name):\n\n pass","def _make_names_unique(animations):\n counts = {}\n for a in animations:\n c = counts.get(a['name'], 0) + 1\n counts[a['name']] = c\n if c > 1:\n a['name'] += '_' + str(c - 1)\n\n dupes = set(k for k, v in counts.items() if v > 1)\n for a in animations:\n if a['name'] in dupes:\n a['name'] += '_0'","def save_species(filename, destinationfolder='', norm=False):\n \n if not os.path.exists(destinationfolder):\n os.makedirs(destinationfolder)\n \n od = os.path.join(destinationfolder, filename) + '_fit'\n \n for i in np.arange(0,500,1):\n d = od + str(i+1)\n if norm:\n d = d + '_norm'\n condition = os.path.exists(d+'_species.svg') or os.path.exists(d+'_species.png')\n if condition:\n pass\n\t\t\t\n else:\n plt.savefig(d+'_species.svg', format='svg')\n print('Saved ' + d + '_species.svg')\n plt.savefig(d+'_species.png', format='png')\n print('Saved ' + d + '_species.png')\n break","def combine_sky_spectra(name):\n sky_list = get_sky_spectra(name)\n sizes = get(name, 'sizes')\n scaled = []\n for spectra in sky_list:\n scale = sizes[spectra] # scale by the number of pixels arcoss\n num = zerocount(spectra)\n sarith('%s/disp/%s.1d' % (name, num), '/', scale,\n '%s/sky/%s.scaled' % (name, num))\n scaled.append('%s/sky/%s.scaled' % (name, num))\n if os.path.isfile('%s/sky.1d' % name):\n os.remove('%s/sky.1d' % name)\n scombine(list_convert(scaled), '%s/sky.1d' % name)","def rename_weights(traindir, kkey, mon):\n # First load in the training.csv\n r = np.genfromtxt(os.path.join(traindir, \"training.csv\"), delimiter=\",\", names=True)\n e = r[\"epoch\"]\n q = r[mon]\n minq = np.min(q)\n beste = e[np.argmin(q)]\n\n newname = \"weights.\" + str(int(beste)) + \"-\" + \"{:.5f}\".format(minq) + \".hdf5\"\n\n os.rename(os.path.join(traindir, kkey), os.path.join(traindir, newname))","def create_json(fl, name):\n obj = json.dumps(fl, indent=4)\n with open(f\"new_json/{name}.json\", \"w\") as outfile:\n outfile.write(obj)\n return","def create_dictionary_of_old_and_new_paths(raw_dir: Path, bids_dir: Path, exclude_fieldmaps: bool) -> dict:\n\n old_and_new_paths = {}\n old_paths = list(raw_dir.rglob(\"*\"))\n print(f\"Sorting {len(old_paths)} paths into a dictionary.\") \n\n def task_name_of(path_to_func_or_json):\n \"\"\"\n Returns the task name of a func or json file. This function OVERWRITES the function\n \"task_name_of\" that we imported at the top of this script. BUT! It only overwrites it\n HERE, in \"create_dictionary_of_old_and_new_paths\".\n \"\"\"\n\n list_of_lines_containing_raw_subject_info = []\n for path in old_paths:\n if filetype_of(path) == \"subject info\":\n list_of_lines_containing_raw_subject_info = path.read_text().splitlines()\n break\n\n for line in list_of_lines_containing_raw_subject_info:\n if path_to_func_or_json.stem in line:\n return line.split(\"z\")[1]\n\n\n for old_path in old_paths:\n\n new_path = old_path\n\n if filetype_of(old_path.with_suffix(\".nii\")) == \"anat\" and acquisition_number_of(old_path) == \"14\":\n new_path = bids_dir / f\"sub-{subject_id_of(old_path)}\" / \"anat\" / f\"sub-{subject_id_of(old_path)}_T1w{old_path.suffix}\"\n\n elif filetype_of(old_path.with_suffix(\".nii\")) == \"func\" and acquisition_number_of(old_path) != \"02\":\n new_path = bids_dir / f\"sub-{subject_id_of(old_path)}\" / \"func\" / f\"sub-{subject_id_of(old_path)}_task-{task_name_of(old_path)}_acq-{acquisition_number_of(old_path)}_bold{old_path.suffix}\"\n\n elif filetype_of(old_path.with_suffix(\".nii\")) == \"fieldmap\" and not exclude_fieldmaps:\n old_affix = old_path.stem.split(\"_\")[-1]\n new_affix = \"phasediff\"\n if old_affix == \"e1\":\n new_affix = \"magnitude1\"\n if old_affix == \"e2\":\n new_affix = \"magnitude2\"\n new_path = bids_dir / f\"sub-{subject_id_of(old_path)}\" / \"fmap\" / f\"sub-{subject_id_of(old_path)}_{new_affix}{old_path.suffix}\"\n\n old_and_new_paths[old_path] = new_path\n\n print(\"Paths sorted.\")\n\n return old_and_new_paths","def write_map(self, file_name):\n\n if self.pixel == \"HEALPIX\":\n hp.fitsfunc.write_map(file_name, self.data, overwrite=True)\n if self.pixel == \"CAR\":\n enmap.write_map(file_name, self.data)","def save_new_dataset_by_ids(old_json, ecg_ids_to_save, name_new_dataset):\n import json\n from settings import PATH_TO_METADATASETS_FOLDER\n new_json_data = {}\n for ecg_id in old_json.keys():\n if ecg_id in ecg_ids_to_save:\n new_json_data[ecg_id]= old_json[ecg_id]\n result_file_path = PATH_TO_METADATASETS_FOLDER + \"\\\\\" + name_new_dataset\n with open(result_file_path, 'w') as outfile:\n json.dump(new_json_data, outfile)","def make_diff(file_before, file_after, file_output_name):\n if os.path.exists(file_output_name):\n shutil.rmtree(file_output_name)\n os.mkdir(file_output_name)\n psd_diff = diff(file_before, file_after)\n diff_content = {}\n for attr in [\"header\", \"layer\"]:\n diff_content[attr] = getattr(psd_diff, attr)\n with open(os.path.join(file_output_name, \"diff.json\"), \"w\") as diff_file:\n json.dump(diff_content, diff_file, indent=4)\n saved_files = []\n for layer_id in psd_diff.layer.keys():\n if len(psd_diff.layer_image[layer_id]) > 1:\n output_image = os.path.join(file_output_name, layer_id)\n psd_diff.layer_image[layer_id][\"before\"].save(output_image + \".before.png\")\n psd_diff.layer_image[layer_id][\"after\"].save(output_image + \".after.png\")\n diff_image_before = Image.new(\"RGBA\", psd_diff.layer_image[layer_id][\"before\"].size)\n diff_image_before_data = diff_image_before.load()\n diff_image_after = Image.new(\"RGBA\", psd_diff.layer_image[layer_id][\"after\"].size)\n diff_image_after_data = diff_image_after.load()\n width, height = diff_image_before.size\n pixel_index = 1\n for y in xrange(height):\n for x in xrange(width):\n if str(pixel_index) in diff_content[\"layer\"][layer_id][\"pixel\"]:\n diff_image_before_data[x, y] = tuple(diff_content[\"layer\"][layer_id][\"pixel\"][str(pixel_index)][\"before\"])\n diff_image_after_data[x, y] = tuple(diff_content[\"layer\"][layer_id][\"pixel\"][str(pixel_index)][\"after\"])\n else:\n diff_image_before_data[x, y] = (0, 0, 0, 0)\n diff_image_after_data[x, y] = (0, 0, 0, 0)\n pixel_index += 1\n diff_image_before.save(output_image + \".before.diff.png\", \"PNG\")\n diff_image_after.save(output_image + \".after.diff.png\", \"PNG\")\n saved_files.append(output_image + \".before.png\")\n saved_files.append(output_image + \".before.diff.png\")\n saved_files.append(output_image + \".after.diff.png\")\n saved_files.append(output_image + \".after.png\")\n saved_files.append(file_output_name + \"/diff.json\")\n return saved_files","def regenerate_json_file():\n \n # filepaths used in generating json data...\n dir_export = f\"C:\\\\Users\\\\{os.getlogin()}\\\\Downloads\"\n list_name = 'my-favourite-films.csv'\n json_output_filename = 'reviews_web_data.json'\n path_to_rootreducer = f'D:\\\\Programming-Projects\\\\nathansteele\\\\src\\\\reducers\\\\RootReducer.js';\n path_to_json_output = f'D:\\\\Programming-Projects\\\\nathansteele\\\\src\\\\components\\\\films\\\\{json_output_filename}'\n \n # 1) find letterboxd zip export...\n prefix = 'letterboxd'\n postfix = 'utc.zip'\n zip_file_name = \"\"\n download_folder = sorted(glob.glob(f\"{dir_export}/*.zip\"), key=os.path.getmtime)\n download_folder.reverse() # reversing the list means most recent downloads are first in the list...\n for filepath in download_folder:\n filename = filepath.split('\\\\')[-1]\n if filename.split('-')[0] == prefix and filename.split('-')[-1] == postfix:\n zip_file_name = filename\n print(f\"Found the zip export! -> {zip_file_name}\")\n break\n else:\n continue\n\n path_to_zip_file = f\"{dir_export}\\\\{zip_file_name}\" # path to zip file we downlodaded from letterboxd...\n path_to_extracted_zip = f\"{dir_export}\\\\{zip_file_name[:-4]}\" # path to extracted zip (which we are about to do)...\n\n # 2) extract zip automatically (if not done already)...\n if os.path.exists(path=path_to_zip_file):\n if not os.path.exists(path=path_to_extracted_zip):\n with zipfile.ZipFile(file=path_to_zip_file , mode='r') as z:\n z.extractall(path_to_extracted_zip)\n print(f\"Extract complete! -> {path_to_extracted_zip}\")\n else:\n print(f'Zip file already exists... No need to extract again... -> ({path_to_extracted_zip})')\n else:\n print(f'Zip file could not be found... -> ({path_to_zip_file})')\n\n\n # local version of letterboxd data list\n letterboxd_list = []\n \n # 3) locate the csv file of interest\n if os.path.exists(path_to_extracted_zip): \n # open csv file...\n path_to_list = f'{path_to_extracted_zip}\\\\lists\\\\{list_name}'\n with open(path_to_list, 'r') as f:\n # csv reader object\n csv_reader = csv.reader(f)\n \n # skip header in the csv file...\n rows_to_skip = 5\n for i in range(0, rows_to_skip):\n next(csv_reader)\n \n # 4) iterate over each row (i.e. each film) in csv file...\n for csv_row in csv_reader:\n pos = csv_row[0]\n title = csv_row[1]\n year = csv_row[2]\n letterboxd_url = csv_row[3]\n letterboxd_film_id = letterboxd_url.split('/')[-1]\n genres = []\n directors = []\n duration = 0\n language = \"\"\n imdb_url = \"\"\n imdb_avg_rating = \"\"\n imdb_num_votes = \"\"\n tmdb_url = \"\"\n poster_url = \"\"\n \n # parse data from letterboxd web page... (this takes ~1.21s)\n page = session.get(url=letterboxd_url, verify=False, stream=True)\n soup = BeautifulSoup(page.content, 'html.parser')\n \n # retrieve list of genres...\n div_genres = soup.select_one('#tab-genres')\n for link in div_genres.select('div.text-sluglist a.text-slug[href]'):\n if 'genre' in link['href']:\n genre = link.text.capitalize()\n if genre == 'Science-fiction':\n genre = 'Sci-fi'\n genres.append(genre)\n\n # retrieve duration\n textfooter = soup.select_one('section.col-main > p.text-footer').text\n if 'mins' in textfooter:\n minstext = textfooter.find('mins', 0, len(textfooter))\n duration = textfooter[minstext-5:minstext].strip()\n \n # retrieve the first spoken language\n div_details = soup.select_one('#tab-details')\n for link in div_details.select('div.text-sluglist a.text-slug[href]'):\n if 'language' in link['href']:\n language = link.text.capitalize()\n break\n \n # retrieve IMDB url\n footer = soup.select_one('section.col-main p.text-footer')\n url_buttons = footer.select('a.micro-button')\n for url in url_buttons:\n if 'imdb' in url.text.lower():\n # get IMDB URL\n imdb_url = url['href']\n elif 'tmdb' in url.text.lower():\n # get TMDB URL\n tmdb_url = url['href']\n if len(url_buttons) == 1:\n # if there's only 1 url_button, it's usually the IMDB link that's missing...\n if soup.select_one('#featured-film-header > h1').text == 'xxxHOLiC':\n imdb_url = 'https://www.imdb.com/title/tt16233104/'\n\n # retrieve avg rating on letterboxd\n # page_content_str = page.content.decode('utf-8')\n # letterboxd_avg_rating = soup.select_one('.average-rating')\n\n # Use the OMDB API (https://www.omdbapi.com/) to retrieve some additional data from IMDB website...\n omdb_api_key = '4af56bed' # apparently this expires after 1000 days (today is 07/02/2023, 1000 days from now is 03/11/2025... holy shit!)\n imdb_film_id = imdb_url.split('/')[-2]\n url = f'http://www.omdbapi.com/?i={imdb_film_id}&apikey={omdb_api_key}'\n imdb = requests.get(url=url, verify=False)\n imdb_json = json.loads(imdb.text)\n\n # retrieve avg IMD rating\n imdb_avg_rating = imdb_json['imdbRating']\n \n # retrieve number of votes on IMDB (we remove the comma, because react is fucking stupid and cant sort numbers when they contain commas)\n imdb_num_votes = imdb_json['imdbVotes'].replace(',', '')\n \n # retrieve poster from IMDB\n poster_url = imdb_json['Poster']\n if 'SX300' in poster_url:\n poster_url = poster_url.split('SX300')[0]\n \n # retrieve title from IMDB (because letterboxd parsing is shite!)\n # title = imdb_json['Title']\n \n # retrieve list of directors (because letterboxd parsing is shite!)\n directors = imdb_json['Director'].split(', ')\n \n # id of my review!\n titlev2 = Helpers.simplify_movie_title(title=title)\n review_id = f\"{titlev2}-{letterboxd_film_id}-review\"\n \n \"\"\"\n # iterate over \\\\img\\\\films\\\\\n screenshots = []\n directory_in_str = f'D:\\\\Programming-Projects\\\\nathansteele\\\\src\\\\img\\\\films';\n for subdir, dirs, files in os.walk(directory_in_str):\n for file in files:\n # find the right directory...\n title_from_directory_storing_screenshots = subdir.split('\\\\')[-1]\n titlev3 = Helpers.simplify_movie_title(title=title_from_directory_storing_screenshots)\n if titlev3 == titlev2:\n # get my screenshots...\n if 'screenshot' in file:\n screenshot = os.path.join(subdir, file)\n screenshots.append(screenshot)\n \n # use my custom poster if I put one there...\n if 'custom_poster' in file:\n poster_url = os.path.join(subdir, file)\n \"\"\"\n \n # DEBUGGING....\n print(f\" > {pos}: {title}\")\n #print(f' > Title = ({title})')\n #print(f' > IMDB url = ({imdb_url})')\n #print(f' > Language = ({language})')\n #print(f' > Duration = ({duration})')\n #print(f' > Genres = ({genres})')\n #print(f' > IMDB avg rating = ({imdb_avg_rating})')\n #print(f' > IMDB num votes = ({imdb_num_votes})')\n #print(f' > Poster = ({poster_url})')\n #print(f' > Directors = ({directors})')\n #print(f' > Tags = ({my_tags})')\n \n # append to list...\n letterboxd_list.append({\n 'letterboxdFilmId': letterboxd_film_id,\n 'imdbFilmId': imdb_film_id,\n 'letterboxdUrl': letterboxd_url,\n 'imdbUrl': imdb_url,\n 'posterUrl': poster_url,\n 'position': pos,\n 'title': title,\n 'year': year,\n 'duration': duration,\n 'language': language,\n 'imdbAvgRating': imdb_avg_rating,\n 'imdbNumVotes': imdb_num_votes,\n 'tmdbUrl': tmdb_url,\n 'directors': directors,\n 'genres': genres,\n 'reviewId': review_id\n })\n \n # clear json file first...\n open(path_to_json_output, 'w').close()\n \n # write new content...\n with open(path_to_json_output, 'w') as f:\n json.dump(letterboxd_list, f, indent=4)\n \n print(f'JSON export finished! -> {path_to_json_output}')"],"string":"[\n \"def renamefile(filename):\\n new_data_list = []\\n with open(filename, 'r') as f:\\n data_list = f.read().split('\\\\n')\\n\\n print('Generating new data list..')\\n for data in tqdm(data_list):\\n if len(data) == 0:\\n continue\\n data_info = data.split(' ')\\n\\n #data_info[0] = data_info[0].replace('jpg', 'png')\\n #data_info[1] = data_info[1].replace('jpg', 'png')\\n for it, name in enumerate(data_info):\\n data_info[it] = '/'.join(name.split('/')[1:])\\n if data_info[2].find('extras') == -1:\\n new_data_list.append(' '.join(data_info))\\n\\n with open(filename, 'w') as f:\\n print('writing new data names..')\\n\\n for it, data in tqdm(enumerate(new_data_list)):\\n if len(data) == 0:\\n continue\\n\\n if it == len(new_data_list)-1:\\n f.write(data)\\n else:\\n f.write(data+'\\\\n')\\n\\n print('Done.')\",\n \"def rename_water_atoms( pdb_filename, O_name = 'O', H1_name = 'H1', H2_name = 'H2' ):\\n\\n parmed = import_(\\\"parmed\\\")\\n\\n pdb = parmed.load_file( pdb_filename )\\n\\n #Find waters and rename\\n for residue in pdb.residues:\\n if len(residue)==3:\\n #Build list of atom types (PDB files don't store these) from names after stripping off digits\\n types = []\\n for atom in residue.atoms:\\n name = atom.name\\n while name[-1].isdigit():\\n name = name[:-1]\\n types.append(name)\\n #See if it's water and, if so, rename\\n if 'O' in types and types.count('H')==2:\\n hct = 0\\n for atom in residue.atoms:\\n if 'O' in atom.name:\\n atom.name = O_name\\n elif 'H' in atom.name:\\n if hct==0:\\n atom.name = H1_name\\n else:\\n atom.name = H2_name\\n hct+=1\\n\\n #Write file\\n pdb.write_pdb( pdb_filename )\",\n \"def _change_name(self, suff, info_extra):\\n if 'cable-ring' in self.path:\\n i1 = info_extra['convex_hull_area']\\n i2 = info_extra['best_possible_area']\\n f = i1 / i2\\n suff = suff.replace('.png',\\n f'-area-{i1:0.3f}-best-{i2:0.3f}-FRAC-{f:0.3f}.png')\\n elif 'cloth-flat' in self.path:\\n i1 = info_extra['cloth_coverage']\\n suff = suff.replace('.png', f'-coverage-{i1:0.3f}.png')\\n elif 'bag-alone' in self.path:\\n i1 = info_extra['convex_hull_area']\\n i2 = info_extra['best_possible_area']\\n suff = suff.replace('.png', f'-area-{i1:0.3f}-best-{i2:0.3f}.png')\\n else:\\n pass\\n return suff\",\n \"def minify_json(self) -> None:\\n print(f\\\"[FileManager: INFO] Minifing file {self.path}\\\")\\n file_data = open(self.path, \\\"r\\\", encoding=\\\"utf-8\\\").read()\\n json_data = json.loads(file_data) \\n json_string = json.dumps(json_data, separators=(',', \\\":\\\")) \\n path = str(self.path).replace(\\\".json\\\", \\\"\\\")\\n new_path = \\\"{0}_min.json\\\".format(path)\\n open(new_path, \\\"w+\\\", encoding=\\\"utf-8\\\").write(json_string)\",\n \"def fix_jsons_in(bids_dir: Path):\\n\\n print(\\\"Finalizing task json files.\\\")\\n\\n for path in bids_dir.rglob(\\\"func/*_task-*.json\\\"):\\n append_to_json_file(key=\\\"TaskName\\\", value=task_name_of(path), path_to_json=path)\\n\\n print(\\\"Appending echo times to phase difference json files.\\\")\\n\\n for path in bids_dir.rglob(\\\"fmap/*_phasediff.json\\\"):\\n magnitude1_path = the_path_that_matches(pattern=\\\"sub-*_magnitude1.json\\\", in_directory=path.parent)\\n magnitude2_path = the_path_that_matches(pattern=\\\"sub-*_magnitude2.json\\\", in_directory=path.parent)\\n echo_time1 = value_of_key_in_json_file(\\\"EchoTime\\\", magnitude1_path)\\n echo_time2 = value_of_key_in_json_file(\\\"EchoTime\\\", magnitude2_path)\\n append_to_json_file(key=\\\"EchoTime1\\\", value=echo_time1, path_to_json=path)\\n append_to_json_file(key=\\\"EchoTime2\\\", value=echo_time2, path_to_json=path)\\n\\n print(\\\"Setting targets of fieldmap json files.\\\")\\n\\n for path in bids_dir.rglob(\\\"fmap/*.json\\\"):\\n func_dir = path.parent.parent / \\\"func\\\"\\n trimmed_func_paths = [\\\"func/\\\" + func_path.name for func_path in func_dir.glob(\\\"*.nii\\\")]\\n append_to_json_file(key=\\\"IntendedFor\\\", value=trimmed_func_paths, path_to_json=path)\",\n \"def fileRenameandReplace(filename,newfilename):\\n try:\\n os.rename(filename,newfilename)\\n logging.info(\\\"Json file renamed in PD path\\\")\\n except Exception as er:\\n print (\\\"Not able to rename the json file \\\")\\n return False\",\n \"def waste_water(osm_path): \\n return (retrieve(osm_path,'multipolygons',['man_made'],**{'man_made':[\\\"='wastewater_plant'\\\"]})).rename(columns={'man_made': 'asset'})\",\n \"def rename_outputs(size, i, format):\\n for k in range(size):\\n src_name = 'out' + str(k) + '.png'\\n dst_name = 'objective' + str(i) + '_' + format + '.png'\\n os.rename(src_name, dst_name)\",\n \"def process_files_json():\\n # chdir into beep root\\n pwd = os.getcwd()\\n os.chdir(os.environ.get(\\\"BEEP_ROOT\\\", \\\"/\\\"))\\n\\n meta_list = list(filter(lambda x: '_Metadata.csv' in x, os.listdir(SRC_DIR)))\\n file_list = list(filter(lambda x: '.csv' in x if x not in meta_list else None, os.listdir(SRC_DIR)))\\n all_list = list(filter(lambda x: '.csv' in x, os.listdir(SRC_DIR)))\\n\\n all_list = sorted(all_list)\\n dumpfn(all_list, \\\"all_files.json\\\")\\n\\n [file_id, mapdf] = init_map(PROJECT_NAME, DEST_DIR)\\n\\n new_file_index = file_id\\n\\n for filename in tqdm(sorted(file_list)):\\n # If the file has already been renamed another entry should not be made\\n if mapdf['filename'].str.contains(filename).sum() > 0:\\n continue\\n old_file = os.path.join(SRC_DIR, filename)\\n new_path = os.path.join(DEST_DIR, PROJECT_NAME)\\n shutil.copy(old_file, new_path) # copy main data file\\n shutil.copy(old_file.replace(\\\".csv\\\", '_Metadata.csv'), new_path) # copy meta data file\\n\\n if PROJECT_NAME == 'FastCharge':\\n [date, channel_no, strname, protocol] = get_parameters_fastcharge(filename, SRC_DIR)\\n elif PROJECT_NAME == 'ClosedLoopOED':\\n [date, channel_no, strname, protocol] = get_parameters_oed(filename, SRC_DIR)\\n else:\\n raise ValueError(\\\"Unsupported PROJECT_NAME: {}\\\".format(PROJECT_NAME))\\n\\n df_dup = mapdf.set_index(['protocol', 'date'])\\n if (protocol, date) in df_dup.index:\\n row = mapdf[(mapdf['protocol'] == protocol) & (mapdf['date'] == date)]\\n file_id = row['fid'].iloc[0]\\n protocol = row['protocol'].iloc[0]\\n date = row['date'].iloc[0]\\n strname = row['strname'].iloc[0]\\n else:\\n file_id = new_file_index\\n new_file_index = new_file_index + 1\\n\\n new_name = \\\"{}_{}_{}\\\".format(PROJECT_NAME, f'{file_id:06}', channel_no)\\n new_file = os.path.join(DEST_DIR, PROJECT_NAME, \\\"{}.csv\\\".format(new_name))\\n\\n new_row = pd.DataFrame([[file_id, protocol, channel_no, date, strname,\\n os.path.abspath(old_file),\\n os.path.abspath(new_file)]],\\n columns=METADATA_COLUMN_NAMES)\\n mapdf = mapdf.append(new_row)\\n\\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename), new_file)\\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename).replace(\\\".csv\\\", \\\"_Metadata.csv\\\"),\\n new_file.replace(\\\".csv\\\", \\\"_Metadata.csv\\\"))\\n\\n mapdf.to_csv(os.path.join(DEST_DIR, PROJECT_NAME, PROJECT_NAME + \\\"map.csv\\\"), index=False)\\n mapdf = mapdf.reset_index(drop=True)\\n os.chdir(pwd)\\n return json.dumps(mapdf.to_dict(\\\"list\\\"))\",\n \"def update_mapper_file(model_name):\\n # only update female array, males always die :(\\n with open('../src/mapper/mapper.py', 'w') as output_file:\\n with open('../src/mapper/mapper_template.py', 'r') as input_file:\\n for line in input_file:\\n if \\\"female_survival_table =\\\" in line:\\n insert_string = \\\" female_survival_table = \\\"\\n if model_name == \\\"model2\\\":\\n insert_string += (\\\"[[0, 0, 1, 1],\\\" +\\n \\\" [0, 1, 1, 1], [1, 1, 0, 0]]\\\\n\\\")\\n else:\\n insert_string += (\\\"[[1, 1, 1, 1],\\\" +\\n \\\" [1, 1, 1, 1], [1, 1, 1, 1]]\\\\n\\\")\\n output_file.write(insert_string)\\n else:\\n output_file.write(line)\",\n \"def changeFilenames(reduced, path, input):\\n file = path + '/' + input\\n data = open(file, 'r').readlines()\\n os.remove(file)\\n\\n fh = open(file, 'w')\\n for line in data:\\n if 'includegraphics' in line:\\n for key in reduced:\\n if key in line:\\n new = line.replace(key, reduced[key])\\n fh.write(new)\\n\\n logging.debug('Changed {0:>s} to {1:>s} '.format(line, new))\\n else:\\n fh.write(line)\\n\\n fh.close()\",\n \"def rename(source_dir,dest_dir):\\n keep_going(text=\\\"This script will backup the original folder to dest_dir/Source/** and remove the original folder. It will make copies of the original files and rename them in directories called Darks, Flats, etc. Do you wish to continue? Answer Y or N.\\\")\\n\\n ## Backup Original Source Folder\\n dir_util.copy_tree(source_dir, dest_dir + '/Source')\\n\\n data = []\\n for file in os.listdir(\\\"./\\\" + source_dir): # put in your path directory\\n if file.endswith(\\\".fits\\\"): # what does the file end with?\\n data.append(os.path.join(source_dir, file))\\n\\n n = len(data)\\n obj, itime, filt, renamed, datemod, count, flatmod, mod = ([] for i in range(8))\\n for i in range(0, n):\\n header = fits.getheader(data[i])\\n Name, Date, Number, Ext = data[i].split(\\\".\\\")\\n obj.append(header['OBJECT'])\\n itime.append(header['ITIME'])\\n filt.append(header['FWINAME'])\\n mod.append((header['OBJECT'] + header['FWINAME']))\\n flatmod.append((header['OBJECT'] + header['FWINAME'] + Date))\\n datemod.append(datetime.strptime(Date, \\\"%Y%m%d\\\").date())\\n if flatmod[i] in flatmod:\\n count = flatmod.count(flatmod[i])\\n if ('Lamp' in obj[i] or 'Flat' in obj[i]):\\n renamed.append((dest_dir + '/Flats/' + str(datemod[i]) + '/' + 'K' + header['OBJECT'] + str(count) + \\\".fits\\\"))\\n os.makedirs(os.path.dirname(dest_dir + '/Flats/' + str(datemod[i]) + '/'), exist_ok=True)\\n elif ('Dark' in obj[i]) or ('dark' in obj[i]):\\n renamed.append((dest_dir + '/Darks/' + str(datemod[i]) + '/' + 'K' + header['OBJECT'] + str(count) + \\\".fits\\\"))\\n os.makedirs(os.path.dirname(dest_dir + '/Darks/' + str(datemod[i]) + '/'), exist_ok=True)\\n elif ('Sky' in obj[i]) or ('sky' in obj[i]):\\n renamed.append((dest_dir + '/Skys/' + str(datemod[i]) + '/' + 'K' + header['OBJECT'] + header['FWINAME'] + str(\\n count) + \\\".fits\\\"))\\n os.makedirs(os.path.dirname(dest_dir + '/Skys/' + str(datemod[i]) + '/'), exist_ok=True)\\n else:\\n renamed.append((dest_dir + '/Objects/' + header['OBJECT'].upper() + '/' + str(datemod[i]) + '/' + 'K' + list(header['CAMNAME'])[0].title() + header['OBJECT'].upper() +\\n header['FWINAME'] + str(\\n count) + \\\".fits\\\"))\\n os.makedirs(os.path.dirname(dest_dir + '/Objects/' + header['OBJECT'].upper() + '/' + str(datemod[i]) + '/'), exist_ok=True)\\n os.rename(data[i], renamed[i])\\n\\n ## REMOVE LEFT OVER original Folders\\n shutil.rmtree(source_dir)\\n\\n lists = [data, mod, datemod, itime, flatmod, renamed]\\n data_headers = pd.concat([pd.Series(x) for x in lists], axis=1)\\n\\n return data_headers\",\n \"def map_county_data_difference(party_12, party_16, outname, county_svg):\\n county_svg = open(county_svg, 'r').read()\\n county_data = csv.reader(open('processed_data.csv'), delimiter = \\\",\\\")\\n \\n soup = BeautifulSoup(county_svg, \\\"html.parser\\\")\\n paths = soup.findAll('path')\\n blue_red = ['#999999','#EC0517','#DA092E','#C70E46','#B5135D','#A21774','#901C8B','#7D20A2','#6B25B9','#582AD1','#462EE8','#3333FF', '#FFFFFF']\\n # County style\\n path_style = 'font-size:12px;fill-rule:nonzero;stroke:#FFFFFF;stroke-opacity:1; stroke-width:0.1;stroke-miterlimit:4;stroke-dasharray:none;stroke-linecap:butt; marker-start:none;stroke-linejoin:bevel;fill:'\\n\\n for p in paths:\\n if p['id'] not in ['State_Lines', 'separator']:\\n #print(str(p['id']))\\n try:\\n rate = party_12[int(p['id'])]\\n rate2 = party_16[int(p['id'])]\\n except: \\n continue\\n if rate == 'red' and rate2 == 'blue':\\n color_class = 9\\n elif rate == 'blue' and rate2 == 'red':\\n color_class = 1\\n else:\\n color_class = 0\\n \\n color = blue_red[color_class]\\n p['style'] = path_style + color\\n \\n f = open(outname, 'w')\\n f.write(soup.prettify())\\n f.close()\",\n \"def mark_bad(imgID_list, side='blue'):\\r\\n\\r\\n assert (side in ['blue', 'red'])\\r\\n try:\\r\\n for num in imgID_list:\\r\\n name = '{:s}{:04d}.fits'.format(side, num)\\r\\n os.rename(name, name+'.bad')\\r\\n except TypeError:\\r\\n # single number\\r\\n num = imgID_list\\r\\n name = '{:s}{:04d}.fits'.format(side, num)\\r\\n os.rename(name, name+'.bad')\",\n \"def anonymize(data_dir):\\n\\n for root, dirs, files in os.walk(dst_data_dir, topdown=False):\\n for dir_name in sorted(dirs):\\n dir_path = os.path.join(root, dir_name)\\n json_path = os.path.join(root, dir_name, 'data.json')\\n print(json_path)\\n\\n with open(json_path) as f:\\n data = json.load(f)\\n\\n data.pop('user_email')\\n data.pop('user_name')\\n data.pop('survey_data')\\n\\n with open(json_path, 'w') as f:\\n json.dump(data, f)\",\n \"def cmip6_renaming_dict():\\n # I could probably simplify this with a generalized single dict, \\n # which has every single possible `wrong` name and then for each model\\n # the renaming function just goes through them...\\n dim_name_dict = {\\n \\\"AWI-CM-1-1-MR\\\":{},\\n \\\"BCC-CSM2-MR\\\": {\\n \\\"x\\\": \\\"lon\\\",\\n \\\"y\\\": \\\"lat\\\",\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"bnds\\\":\\\"bnds\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n \\\"vertex\\\": None,\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n \\\"BCC-ESM1\\\": {\\n \\\"x\\\": \\\"lon\\\",\\n \\\"y\\\": \\\"lat\\\",\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"bnds\\\":\\\"bnds\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n \\\"vertex\\\": \\\"vertex\\\",\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n \\\"CAMS-CSM1-0\\\": {\\n \\\"x\\\": [\\\"i\\\", 'lon'],\\n \\\"y\\\": [\\\"j\\\", 'lat'],\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": None,\\n \\\"lat_bounds\\\": None,\\n \\\"vertex\\\": 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n \\\"CanESM5\\\": {\\n \\\"x\\\": [\\\"i\\\", 'lon'],\\n \\\"y\\\": [\\\"j\\\", 'lat'],\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": None,\\n \\\"lat_bounds\\\": None,\\n \\\"time_bounds\\\": \\\"time_bnds\\\",\\n \\\"vertex\\\": \\\"vertices\\\",\\n },\\n \\\"CanESM5-CanOE\\\": {\\n \\\"x\\\": \\\"i\\\",\\n \\\"y\\\": \\\"j\\\",\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": 'vertices_longitude',\\n \\\"lat_bounds\\\": 'vertices_latitude',\\n \\\"vertex\\\": \\\"vertices\\\",\\n },\\n \\\"CNRM-CM6-1\\\": {\\n \\\"x\\\": [\\\"x\\\", 'lon'],\\n \\\"y\\\": [\\\"y\\\", 'lat'],\\n \\\"lon\\\": \\\"lon\\\",\\n \\\"lat\\\": \\\"lat\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"bnds\\\": \\\"axis_nbounds\\\",\\n \\\"lev_bounds\\\": \\\"lev_bounds\\\",\\n \\\"lon_bounds\\\": \\\"bounds_lon\\\",\\n \\\"lat_bounds\\\": \\\"bounds_lat\\\",\\n 'vertex': \\\"nvertex\\\",\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n \\\"CNRM-ESM2-1\\\": {\\n \\\"x\\\": [\\\"x\\\", \\\"lon\\\"],\\n \\\"y\\\": [\\\"y\\\", \\\"lat\\\"],\\n \\\"lon\\\": \\\"lon\\\",\\n \\\"lat\\\": \\\"lat\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bounds\\\",\\n \\\"lon_bounds\\\": \\\"bounds_lon\\\",\\n \\\"lat_bounds\\\": \\\"bounds_lat\\\",\\n \\\"bnds\\\":\\\"axis_nbounds\\\",\\n 'vertex': None,\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n \\\"E3SM-1-0\\\": {\\n \\\"x\\\": \\\"lon\\\",\\n \\\"y\\\": \\\"lat\\\",\\n \\\"lon\\\": None,\\n \\\"lat\\\": None,\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"bnds\\\":\\\"bnds\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n \\\"time_bounds\\\":\\\"time_bounds\\\",\\n 'vertex': None,\\n },\\n \\\"E3SM-1-1\\\": {\\n \\\"x\\\": \\\"lon\\\",\\n \\\"y\\\": \\\"lat\\\",\\n \\\"lon\\\": None,\\n \\\"lat\\\": None,\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"bnds\\\":\\\"bnds\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n \\\"time_bounds\\\":\\\"time_bounds\\\",\\n 'vertex': None,\\n },\\n \\\"E3SM-1-1-ECA\\\": {\\n \\\"x\\\": \\\"lon\\\",\\n \\\"y\\\": \\\"lat\\\",\\n \\\"lon\\\": None,\\n \\\"lat\\\": None,\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"bnds\\\":\\\"bnds\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n \\\"time_bounds\\\":\\\"time_bounds\\\",\\n 'vertex': None,\\n },\\n \\\"EC-Earth3-LR\\\": {\\n \\\"x\\\": [\\\"i\\\", 'lon'],\\n \\\"y\\\": [\\\"j\\\", 'lat'],\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": None,\\n \\\"lat_bounds\\\": None,\\n 'time_bounds': \\\"time_bnds\\\",\\n # 'vertex': 'vertices',\\n # 'dzt': 'thkcello',\\n },\\n \\\"EC-Earth3-Veg\\\": {\\n \\\"x\\\": [\\\"i\\\", 'lon'],\\n \\\"y\\\": [\\\"j\\\", 'lat'],\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": None,\\n \\\"lat_bounds\\\": None,\\n 'vertex': 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n # 'dzt': 'thkcello',\\n },\\n \\\"EC-Earth3\\\": {\\n \\\"x\\\": [\\\"i\\\", 'lon'],\\n \\\"y\\\": [\\\"j\\\", 'lat'],\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": None,\\n \\\"lat_bounds\\\": None,\\n 'time_bounds': \\\"time_bnds\\\",\\n # 'vertex': 'vertices',\\n # 'dzt': 'thkcello',\\n },\\n \\\"FGOALS-f3-L\\\": {\\n \\\"x\\\": [\\\"i\\\", 'lon'],\\n \\\"y\\\": [\\\"j\\\", 'lat'],\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": None,\\n \\\"lat_bounds\\\": None,\\n 'time_bounds': \\\"time_bnds\\\",\\n # 'vertex': 'vertices',\\n # 'dzt': 'thkcello',\\n },\\n \\\"NICAM16-7S\\\": {\\n \\\"x\\\": \\\"lon\\\",\\n \\\"y\\\": \\\"lat\\\",\\n \\\"lon\\\": None,\\n \\\"lat\\\": None,\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n \\\"time_bounds\\\": \\\"time_bnds\\\",\\n 'vertex': 'vertices',\\n },\\n \\\"MIROC-ES2L\\\": {\\n \\\"x\\\": [\\\"x\\\", 'lon'],\\n \\\"y\\\": [\\\"y\\\", 'lat'],\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": [\\\"lev\\\", \\\"zlev\\\"],\\n \\\"lev_bounds\\\": [\\\"lev_bnds\\\", \\\"zlev_bnds\\\"],\\n \\\"lon_bounds\\\": \\\"x_bnds\\\",\\n \\\"lat_bounds\\\": \\\"y_bnds\\\",\\n \\\"time_bounds\\\": \\\"time_bnds\\\",\\n 'vertex': 'vertices',\\n },\\n \\\"MIROC6\\\": {\\n \\\"x\\\": [\\\"x\\\", 'lon'],\\n \\\"y\\\": [\\\"y\\\", 'lat'],\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"x_bnds\\\",\\n \\\"lat_bounds\\\": \\\"y_bnds\\\",\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n \\\"HadGEM3-GC31-LL\\\": {\\n \\\"x\\\": [\\\"i\\\", 'lon'],\\n \\\"y\\\": [\\\"j\\\", 'lat'],\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bounds\\\",\\n \\\"lon_bounds\\\": None,\\n \\\"lat_bounds\\\": None,\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n \\\"HadGEM3-GC31-MM\\\": {\\n \\\"x\\\": [\\\"i\\\", 'lon'],\\n \\\"y\\\": [\\\"j\\\", 'lat'],\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bounds\\\",\\n \\\"lon_bounds\\\": None,\\n \\\"lat_bounds\\\": None,\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n \\\"UKESM1-0-LL\\\": {\\n \\\"x\\\": [\\\"i\\\", 'lon'],\\n \\\"y\\\": [\\\"j\\\", 'lat'],\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": None,\\n \\\"lat_bounds\\\": None,\\n \\\"time_bounds\\\":\\\"time_bnds\\\",\\n # 'vertex': 'vertices',\\n # 'dzt': 'thkcello',\\n },\\n 'GISS-E2-2-G': { \\n \\\"x\\\": \\\"lon\\\",\\n \\\"y\\\": \\\"lat\\\",\\n \\\"lon\\\": None,\\n \\\"lat\\\": None,\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n 'vertex': None,\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n \\\"GISS-E2-1-G-CC\\\": {\\n \\\"x\\\": \\\"lon\\\",\\n \\\"y\\\": \\\"lat\\\",\\n \\\"lon\\\": None,\\n \\\"lat\\\": None,\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n 'vertex': None,\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n \\\"GISS-E2-1-G\\\": {\\n \\\"x\\\": \\\"lon\\\",\\n \\\"y\\\": \\\"lat\\\",\\n \\\"lon\\\": None,\\n \\\"lat\\\": None,\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n 'vertex': None,\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n \\\"GISS-E2-1-H\\\": {\\n \\\"x\\\": \\\"lon\\\",\\n \\\"y\\\": \\\"lat\\\",\\n \\\"lon\\\": None,\\n \\\"lat\\\": None,\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n 'vertex': None,\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n \\\"CESM1-1-CAM5-CMIP5\\\": {\\n \\\"x\\\": [\\\"nlon\\\", \\\"lon\\\"],\\n \\\"y\\\": [\\\"nlat\\\", \\\"lat\\\"],\\n \\\"lon\\\": \\\"lon\\\",\\n \\\"lat\\\": \\\"lat\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"bnds\\\":\\\"d2\\\",\\n \\\"time_bounds\\\":\\\"time_bnds\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n 'vertex': 'vertices',\\n },\\n \\\"CESM2-WACCM\\\": {\\n \\\"x\\\": [\\\"nlon\\\", \\\"lon\\\"],\\n \\\"y\\\": [\\\"nlat\\\", \\\"lat\\\"],\\n \\\"lon\\\": \\\"lon\\\",\\n \\\"lat\\\": \\\"lat\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"bnds\\\":\\\"d2\\\",\\n \\\"time_bounds\\\":\\\"time_bnds\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n 'vertex': 'vertices',\\n },\\n \\\"CESM2-WACCM-FV2\\\": {\\n \\\"x\\\": [\\\"nlon\\\", \\\"lon\\\"],\\n \\\"y\\\": [\\\"nlat\\\", \\\"lat\\\"],\\n \\\"lon\\\": \\\"lon\\\",\\n \\\"lat\\\": \\\"lat\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"bnds\\\":\\\"d2\\\",\\n \\\"time_bounds\\\":\\\"time_bnds\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n 'vertex': 'vertices',\\n },\\n \\\"CESM2\\\": {\\n \\\"x\\\": [\\\"nlon\\\", \\\"lon\\\"],\\n \\\"y\\\": [\\\"nlat\\\", \\\"lat\\\"],\\n \\\"lon\\\": \\\"lon\\\",\\n \\\"lat\\\": \\\"lat\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"bnds\\\":'d2',\\n \\\"time_bounds\\\":\\\"time_bnds\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n 'vertex': 'vertices',\\n },\\n \\\"CESM2-FV2\\\": {\\n \\\"x\\\": [\\\"nlon\\\", \\\"lon\\\"],\\n \\\"y\\\": [\\\"nlat\\\", \\\"lat\\\"],\\n \\\"lon\\\": \\\"lon\\\",\\n \\\"lat\\\": \\\"lat\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"bnds\\\":'d2',\\n \\\"time_bounds\\\":\\\"time_bnds\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n 'vertex': 'vertices',\\n },\\n \\\"GFDL-CM4\\\": {\\n \\\"x\\\": [\\\"x\\\",\\\"lon\\\"],\\n \\\"y\\\": [\\\"y\\\", \\\"lat\\\"],\\n \\\"lon\\\": \\\"lon\\\",\\n \\\"lat\\\": \\\"lat\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n \\\"time_bounds\\\": \\\"time_bnds\\\",\\n # 'vertex': 'vertex',\\n # 'dzt': 'thkcello',\\n },\\n \\\"GFDL-OM4p5B\\\": {\\n \\\"x\\\": [\\\"x\\\",\\\"lon\\\"],\\n \\\"y\\\": [\\\"y\\\", \\\"lat\\\"],\\n \\\"lon\\\": \\\"lon\\\",\\n \\\"lat\\\": \\\"lat\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n \\\"time_bounds\\\": \\\"time_bnds\\\",\\n # 'vertex': 'vertex',\\n # 'dzt': 'thkcello',\\n },\\n \\\"GFDL-ESM4\\\": {\\n \\\"x\\\": [\\\"x\\\",\\\"lon\\\"],\\n \\\"y\\\": [\\\"y\\\", \\\"lat\\\"],\\n \\\"lon\\\": \\\"lon\\\",\\n \\\"lat\\\": \\\"lat\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n \\\"time_bounds\\\": \\\"time_bnds\\\",\\n # 'vertex': 'vertex',\\n # 'dzt': 'thkcello',\\n },\\n \\\"NESM3\\\": {\\n \\\"x\\\": ['i', \\\"lon\\\"],\\n \\\"y\\\": ['j', \\\"lat\\\"],\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": None,\\n \\\"lat_bounds\\\": None,\\n 'vertex': 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n # 'dzt': 'thkcello',\\n },\\n \\\"MRI-ESM2-0\\\": {\\n \\\"x\\\": ['x', \\\"lon\\\"],\\n \\\"y\\\": ['y', \\\"lat\\\"],\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"bnds\\\":'bnds',\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": [\\\"x_bnds\\\", 'lon_bnds'],\\n \\\"lat_bounds\\\": [\\\"y_bnds\\\", 'lat_bnds'],\\n \\\"time_bounds\\\": \\\"time_bnds\\\",\\n 'vertex': 'vertices',\\n },\\n \\\"SAM0-UNICON\\\": {\\n \\\"x\\\": [\\\"i\\\", 'lon'],\\n \\\"y\\\": [\\\"j\\\", 'lat'],\\n \\\"lon\\\": \\\"longitude\\\",\\n \\\"lat\\\": \\\"latitude\\\",\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": None,\\n \\\"lat_bounds\\\": None,\\n 'vertex': 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n # 'dzt': 'thkcello',\\n },\\n \\\"MCM-UA-1-0\\\": {\\n \\\"x\\\": \\\"longitude\\\",\\n \\\"y\\\": \\\"latitude\\\",\\n \\\"lon\\\": None,\\n \\\"lat\\\": None,\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n 'time_bounds': \\\"time_bnds\\\",\\n # 'vertex': 'vertices',\\n # 'dzt': 'thkcello',\\n }, \\n 'IPSL-CM6A-LR': {\\n \\\"x\\\": ['x', \\\"lon\\\"],\\n \\\"y\\\": ['y', \\\"lat\\\"],\\n \\\"lon\\\": 'nav_lon',\\n \\\"lat\\\": 'nav_lat',\\n \\\"lev\\\": [\\\"lev\\\",\\\"deptht\\\", \\\"olevel\\\"],\\n \\\"lev_bounds\\\": [\\\"lev_bounds\\\", \\\"deptht_bounds\\\",'olevel_bounds'],\\n \\\"lon_bounds\\\": \\\"bounds_nav_lon\\\",\\n \\\"lat_bounds\\\": \\\"bounds_nav_lat\\\",\\n 'vertex': 'nvertex',\\n \\\"bnds\\\":\\\"axis_nbounds\\\",\\n 'time_bounds': \\\"time_bnds\\\",\\n # 'dzt': 'thkcello',\\n },\\n 'NorCPM1': {\\n \\\"x\\\": [\\\"i\\\", 'lon'],\\n \\\"y\\\": [\\\"j\\\", 'lat'],\\n \\\"lon\\\": 'longitude',\\n \\\"lat\\\": 'latitude',\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": None,\\n \\\"lat_bounds\\\": None,\\n 'vertex': 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n 'NorESM1-F': {\\n \\\"x\\\": [\\\"i\\\", 'lon'],\\n \\\"y\\\": [\\\"j\\\", 'lat'],\\n \\\"lon\\\": 'longitude',\\n \\\"lat\\\": 'latitude',\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": 'vertices_longitude',\\n \\\"lat_bounds\\\": 'vertices_latitude',\\n 'vertex': 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n 'NorESM2-LM': {\\n \\\"x\\\": \\\"i\\\",\\n \\\"y\\\": \\\"j\\\",\\n \\\"lon\\\": 'longitude',\\n \\\"lat\\\": 'latitude',\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": 'vertices_longitude',\\n \\\"lat_bounds\\\": 'vertices_latitude',\\n 'vertex': 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n 'NorESM2-MM': {\\n \\\"x\\\": \\\"i\\\",\\n \\\"y\\\": \\\"j\\\",\\n \\\"lon\\\": 'longitude',\\n \\\"lat\\\": 'latitude',\\n \\\"lev\\\": \\\"lev\\\", # i leave this here because the names are the same as for the other Nor models.\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": 'vertices_longitude',\\n \\\"lat_bounds\\\": 'vertices_latitude',\\n 'vertex': 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n \\n 'MPI-ESM1-2-HR': {\\n \\\"x\\\": [\\\"i\\\", 'lon'],\\n \\\"y\\\": [\\\"j\\\", 'lat'],\\n \\\"lon\\\": 'longitude',\\n \\\"lat\\\": 'latitude',\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": 'vertices_longitude',\\n \\\"lat_bounds\\\": 'vertices_latitude',\\n 'vertex': 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n 'MPI-ESM1-2-LR': {\\n \\\"x\\\": \\\"i\\\",\\n \\\"y\\\": \\\"j\\\",\\n \\\"lon\\\": 'longitude',\\n \\\"lat\\\": 'latitude',\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": 'vertices_longitude',\\n \\\"lat_bounds\\\": 'vertices_latitude',\\n 'vertex': 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n 'MPI-ESM-1-2-HAM': {\\n \\\"x\\\": \\\"i\\\",\\n \\\"y\\\": \\\"j\\\",\\n \\\"lon\\\": 'longitude',\\n \\\"lat\\\": 'latitude',\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": 'vertices_longitude',\\n \\\"lat_bounds\\\": 'vertices_latitude',\\n 'vertex': 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n 'CNRM-CM6-1-HR': {\\n \\\"x\\\": \\\"x\\\",\\n \\\"y\\\": \\\"y\\\",\\n \\\"lon\\\": 'lon',\\n \\\"lat\\\": 'lat',\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bounds\\\",\\n \\\"lon_bounds\\\": \\\"bounds_lon\\\",\\n \\\"lat_bounds\\\": \\\"bounds_lat\\\",\\n 'vertex': None,\\n 'time_bounds': \\\"time_bounds\\\",\\n },\\n 'FIO-ESM-2-0': {\\n \\\"x\\\": \\\"i\\\",\\n \\\"y\\\": \\\"j\\\",\\n \\\"lon\\\": 'longitude',\\n \\\"lat\\\": 'latitude',\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"vertices_longitude\\\",\\n \\\"lat_bounds\\\": \\\"vertices_latitude\\\",\\n 'vertex': 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n 'ACCESS-ESM1-5': {\\n \\\"x\\\": \\\"i\\\",\\n \\\"y\\\": \\\"j\\\",\\n \\\"lon\\\": 'longitude',\\n \\\"lat\\\": 'latitude',\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"vertices_longitude\\\",\\n \\\"lat_bounds\\\": \\\"vertices_latitude\\\",\\n 'vertex': 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n 'ACCESS-CM2': {\\n \\\"x\\\": \\\"i\\\",\\n \\\"y\\\": \\\"j\\\",\\n \\\"lon\\\": 'longitude',\\n \\\"lat\\\": 'latitude',\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"vertices_longitude\\\",\\n \\\"lat_bounds\\\": \\\"vertices_latitude\\\",\\n 'vertex': 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n 'INM-CM4-8': { # this is a guess.\\n \\\"x\\\": \\\"lon\\\",\\n \\\"y\\\": \\\"lat\\\",\\n \\\"lon\\\": None,\\n \\\"lat\\\": None,\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n 'vertex': None,\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n 'INM-CM5-0': { # this is a guess.\\n \\\"x\\\": \\\"lon\\\",\\n \\\"y\\\": \\\"lat\\\",\\n \\\"lon\\\": None,\\n \\\"lat\\\": None,\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"lon_bnds\\\",\\n \\\"lat_bounds\\\": \\\"lat_bnds\\\",\\n 'vertex': None,\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n 'MRI-ESM2-0':{\\n \\\"x\\\": \\\"x\\\",\\n \\\"y\\\": \\\"y\\\",\\n \\\"lon\\\": 'longitude',\\n \\\"lat\\\": 'latitude',\\n \\\"lev\\\": \\\"lev\\\",\\n \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n# \\\"lon_bounds\\\": 'x_bnds',\\n# \\\"lat_bounds\\\": 'y_bnds',\\n# 'vertex': None, # this is a mess. there is yet another convention. Will have to deal with this once I wrap xgcm into here.\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n 'CIESM': { # this is a guess.\\n \\\"x\\\": \\\"i\\\",\\n \\\"y\\\": \\\"j\\\",\\n \\\"lon\\\": 'longitude',\\n \\\"lat\\\": 'latitude',\\n# \\\"lev\\\": \\\"lev\\\", # no 3d data available as of now\\n# \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n \\\"lon_bounds\\\": \\\"vertices_longitude\\\",\\n \\\"lat_bounds\\\": \\\"vertices_latitude\\\",\\n 'vertex': 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n 'KACE-1-0-G': { # this is a guess.\\n \\\"x\\\": \\\"lon\\\",\\n \\\"y\\\": \\\"lat\\\",\\n \\\"lon\\\": 'longitude',\\n \\\"lat\\\": 'latitude',\\n# \\\"lev\\\": \\\"lev\\\", # no 3d data available as of now\\n# \\\"lev_bounds\\\": \\\"lev_bnds\\\",\\n# \\\"lon_bounds\\\": \\\"vertices_longitude\\\",\\n# \\\"lat_bounds\\\": \\\"vertices_latitude\\\",\\n# \\\"lon_bounds\\\": \\\"vertices_longitude\\\",\\n# \\\"lat_bounds\\\": \\\"vertices_latitude\\\",\\n 'vertex': 'vertices',\\n 'time_bounds': \\\"time_bnds\\\",\\n },\\n \\n }\\n # cast all str into lists\\n for model in dim_name_dict.keys():\\n for field in dim_name_dict[model].keys():\\n if isinstance(dim_name_dict[model][field], str) or dim_name_dict[model][field] is None :\\n dim_name_dict[model][field] = [dim_name_dict[model][field]]\\n# add 'lon' and 'lat' as possible logical indicies for all models. This should take care of all regridded ocean output and all atmosphere models.\\n if 'x' in dim_name_dict[model].keys():\\n if not 'lon' in dim_name_dict[model]['x']:\\n dim_name_dict[model]['x'].append('lon')\\n \\n if 'y' in dim_name_dict[model].keys():\\n if not 'lat' in dim_name_dict[model]['y']:\\n dim_name_dict[model]['y'].append('lat') \\n return dim_name_dict\",\n \"def rewrite_hdf5(\\n self, job_name=None, info=False, exclude_groups=None, exclude_nodes=None\\n ):\\n if job_name is not None:\\n state.logger.warning(\\n \\\"Specifying job_name is deprecated and ignored! Future versions will change signature.\\\"\\n )\\n file_name = self.file_name\\n new_file = file_name + \\\"_rewrite\\\"\\n\\n self_hdf = FileHDFio(file_name=file_name)\\n hdf_new = FileHDFio(file_name=new_file, h5_path=\\\"/\\\")\\n\\n old_logger_level = state.logger.level\\n state.logger.level = 50\\n hdf_new = self.hd_copy(self_hdf, hdf_new)\\n state.logger.level = old_logger_level\\n\\n if info:\\n print(\\n \\\"compression rate from old to new: {}\\\".format(\\n self.file_size(self_hdf) / self.file_size(hdf_new)\\n )\\n )\\n print(\\n \\\"data size vs file size: {}\\\".format(\\n self.get_size(hdf_new) / self.file_size(hdf_new)\\n )\\n )\\n self.remove_file()\\n os.rename(hdf_new.file_name, file_name)\",\n \"def sky_subtract_galaxy(name):\\n spectra = get_object_spectra(name)\\n sky_levels = get(name, 'sky')\\n for spectrum in spectra:\\n sky_level = sky_levels[spectrum]\\n if not sky_level:\\n sky_level = sky_subtract(name, spectrum)\\n generate_sky(name, spectrum, sky_level)\\n write(name, 'sky', sky_levels)\",\n \"def fix_demand(city):\\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + 'new_' + file, \\\"w\\\") as wf:\\n writer = csv.writer(wf)\\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file) as rf:\\n reader = csv.reader(rf)\\n for row in reader:\\n writer.writerow([int(row[0]), int(row[1]), int(row[2]), float(row[3]), int(row[4]), int(row[5]), float(row[6]),\\n int(row[1]) + int(row[4]), int(row[2]) + int(row[5]), (int(row[2]) + int(row[5]) - int(row[1]) - int(row[4])) / (int(row[2]) + int(row[5]))])\\n\\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\\n if not file.startswith('new'):\\n os.remove(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file)\\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\\n prefix = exp_data_path + os.sep + 'station' + os.sep + city\\n os.rename(prefix + os.sep + file, prefix + os.sep + file[4:])\",\n \"def corrector(file=\\\"\\\"):\\n intermediate = str(file) + str(\\\"_intermediate\\\")\\n\\n # Lies den bisherigen Inhalt:\\n with open(file, mode=\\\"r\\\") as source:\\n content = source.read()\\n\\n # Tausche die Liniendefinition, grau gegen schwarz:\\n gray_line = re.compile(\\\"stroke:#969696;\\\")\\n substituted = str(gray_line.sub(\\\"stroke:#000000;\\\", content))\\n\\n # Tausche die Liniendefinition, keine Schattierung\\n opacity = re.compile(\\\"stroke-opacity:\\\\d\\\\.?\\\\d*\\\")\\n no_shadow = str(opacity.sub(\\\"stroke-opacity:1.0\\\", substituted))\\n\\n # Lege eine korrigierte Datei an:\\n with open(intermediate, mode=\\\"w\\\") as newfile:\\n # newfile.write(substituted)\\n newfile.write(no_shadow)\",\n \"def unpack_rename_data(self):\\n for old, new in self.f_name_map.items():\\n try:\\n read_path = Path(os.environ[\\\"DATA_PATH\\\"]) / old\\n write_path = Path(os.environ[\\\"DATA_PATH\\\"]) / new\\n if \\\"ZIP\\\" in old:\\n shutil.unpack_archive(read_path, write_path, \\\"zip\\\")\\n else:\\n shutil.unpack_archive(read_path, write_path)\\n read_path.unlink() # delete original file\\n except OSError:\\n print(f\\\"Did not unpack {read_path}\\\")\",\n \"def update_level_name(lumpname, bexdata, bexname):\\n\\tif bexname not in bexdata:\\n\\t\\traise Exception('Level name %s not defined in '\\n\\t\\t\\t\\t'DEHACKED lump!' % bexname)\\n\\t# Strip \\\"MAP01: \\\" or \\\"E1M2: \\\" etc. from start, if present:\\n\\tlevelname = re.sub('^\\\\w*\\\\d:\\\\s*', '', bexdata[bexname])\\n\\twhite_graphics[lumpname] = levelname\",\n \"def bless_output(self):\\n actual_output_file = path.splitext(self.source_name)[0] + \\\".actual\\\"\\n expected_output_file = path.splitext(self.source_name)[0] + \\\".expected\\\"\\n if path.exists(expected_output_file):\\n os.unlink(expected_output_file)\\n os.rename(actual_output_file, expected_output_file)\",\n \"def updateCountryNames(self):\\n try:\\n with open('countryNameMapping.json', 'r') as file:\\n name_mapping = json.loads(file.read())\\n except:\\n sys.exit('countryNameMapping.json file is unavailable in current directory.')\\n \\n for key, value in name_mapping.items():\\n self.covid_df.replace(key, value, inplace=True)\\n \\n try:\\n with open('countryNameISO2.json', 'r') as file:\\n self.name_iso2_mapping = json.loads(file.read())\\n except:\\n print('countryNameISO2.json file is unavailable in current directory, creating file...')\\n self.writeCountryCodeFile()\\n print('Re-importing required JSONs...')\\n self.updateCountryNames()\",\n \"def rename(self, name, new_name):\\n renames = {}\\n if new_name in self._data.columns:\\n msg = \\\"Cannot rename '{}' into '{}'. Column name already exists!\\\"\\n raise ValueError(msg.format(name, new_name))\\n\\n self._in_blacklist(new_name)\\n self._check_against_weak_dupes(new_name)\\n\\n if not self._dimensions_comp == 'ignore':\\n self.undimensionize([name] + self.sources(name))\\n name = self._dims_free_arr_name(name)\\n\\n for no, s in enumerate(self.sources(name), start=1):\\n if '_' in s and s.split('_')[-1].isdigit():\\n new_s_name = '{}_{}'.format(new_name, s.split('_')[-1])\\n else:\\n new_s_name = '{}_{}'.format(new_name, no)\\n self._add_all_renames_to_mapper(renames, s, new_s_name)\\n\\n self._add_all_renames_to_mapper(renames, name, new_name)\\n\\n self.rename_from_mapper(renames)\\n\\n if self._dimensions_comp and not self._dimensions_comp == 'ignore':\\n self.dimensionize(new_name)\\n\\n return None\",\n \"def fix_path(self):\\n paths = self.data['path'].tolist()\\n prefixes = [re.findall(r'[A-Z\\\\-0-9]+', path) for path in paths]\\n prefix_good = [str(prefix[0]) + \\\".json\\\" for prefix in prefixes]\\n self.data['path'] = prefix_good\",\n \"def fix_bad_column_blue():\\r\\n\\r\\n science = iraf.hselect('blue????.fits', '$I', 'TURRET == \\\"APERTURE\\\" & LAMPS == \\\"0000000\\\"', Stdout=1)\\r\\n if len(science) > 0:\\r\\n f = open('science_dump', 'w')\\r\\n for fn in science:\\r\\n f.write('%s\\\\n' % fn)\\r\\n f.close()\\r\\n science = iraf.hselect('@science_dump', '$I', 'TURRET == \\\"APERTURE\\\" & LAMPS == \\\"0000000\\\" & AIRMASS > 1.01', Stdout=1)\\r\\n if len(science)>0:\\r\\n os.unlink('science_dump')\\r\\n f = pyfits.open(science[0])\\r\\n bad_column = f[0].data[1608,:].argmin() + 1\\r\\n f.close()\\r\\n f = open('bluebpm', 'w')\\r\\n f.write('%d %d 1 2835\\\\n' % (bad_column, bad_column))\\r\\n f.close()\\r\\n iraf.fixpix('blue????.fits', \\\"bluebpm\\\")\",\n \"def regenerate_heightmap(self):\\n\\n for x in range(16):\\n for z in range(16):\\n column = x * 16 + z\\n for y in range(255, -1, -1):\\n if self.get_block((x, y, z)):\\n break\\n\\n self.heightmap[column] = y\",\n \"def update_json(shell=False):\\n\\n surahs_modified = 0\\n last_update = update_timestamp()\\n if shell: tell.info(\\\"Updating JSON AST files.\\\")\\n\\n for surah in range(1, 115):\\n\\n source_path = \\\"source/surah{}.text\\\".format(surah)\\n\\n if last_modified(source_path) > last_update:\\n\\n if shell:\\n tell.info(\\\"Rebuilding Surah `{}`.\\\".format(surah))\\n surahs_modified += 1\\n\\n with open(source_path) as source_file:\\n with open(\\\"json/surah{}.json\\\".format(surah), \\\"w\\\") as json_file:\\n data = parse(source_file.read())\\n json_file.write(json.dumps(data))\\n\\n if shell:\\n if surahs_modified: tell.done(\\\"The JSON files are now up to date.\\\")\\n else: tell.info(\\\"No edits were found in the source files.\\\")\\n\\n return surahs_modified\",\n \"def update_best_model_json(updated):\\n with open(qualify_full_filepath(f\\\"models.json\\\", HERE), \\\"w\\\") as outfile:\\n json.dump(updated, outfile, sort_keys=True, indent=2)\\n return None\",\n \"def _handle_old_style_images(staging_path):\\n file_num = 0\\n for filename in ('snap.vhd', 'image.vhd', 'base.vhd'):\\n path = os.path.join(staging_path, filename)\\n if os.path.exists(path):\\n _rename(path, os.path.join(staging_path, \\\"%d.vhd\\\" % file_num))\\n file_num += 1\",\n \"def recalc_names(\\n input_path,\\n config_file,\\n linked_styles,\\n exclude_namerecords,\\n shorten_width,\\n shorten_weight,\\n shorten_italic,\\n fix_cff,\\n super_family,\\n alt_uid,\\n regular_italic,\\n keep_regular,\\n old_full_font_name,\\n output_dir,\\n recalc_timestamp,\\n overwrite\\n):\\n\\n files = getFontsList(input_path)\\n if len(files) == 0:\\n click.secho('\\\\nNo fonts found.', fg='red')\\n sys.exit()\\n\\n if not config_file:\\n config_file = getConfigPath(input_path)\\n\\n # If config.json doesn't exist, it has to be created before.\\n if not os.path.exists(config_file):\\n configHandler(config_file).resetConfig()\\n click.secho('\\\\n{} didn\\\\'t exist and has been created'.format(\\n config_file), fg='yellow')\\n\\n config = configHandler(config_file).getConfig()\\n\\n italics = config['italics']\\n italics.sort(key=len)\\n\\n csv_file = getCsvPath(input_path)\\n if not os.path.exists(csv_file):\\n csvHandler(csv_file).resetCSV(config_file=config_file)\\n data = csvHandler(csv_file).getData()\\n\\n # Checks if the file name is present in the CSV data. If the file name\\n # is not present, the file is removed from the list of files and will\\n # not be processed.\\n csv_filenames = [row['file_name'] for row in data]\\n files = [f for f in files if os.path.basename(f) in csv_filenames]\\n\\n shorten_width = [int(i) for i in shorten_width]\\n shorten_weight = [int(i) for i in shorten_weight]\\n shorten_italic = [int(i) for i in shorten_italic]\\n exclude_namerecords = [int(i) for i in exclude_namerecords]\\n\\n # We convert the linked_styles tuple to a list and then sort it.\\n linked_styles = tuple(set(linked_styles))\\n linked_styles = list(linked_styles)\\n linked_styles.sort()\\n\\n for f in files:\\n try:\\n font = TTFont(f, recalcTimestamp=recalc_timestamp)\\n font_data = {}\\n for row in data:\\n if str(row['file_name']) == os.path.basename(f):\\n font_data = row\\n\\n pyFont(font).recalcNames(\\n font_data, italics,\\n linked_styles=linked_styles, namerecords_to_ignore=exclude_namerecords,\\n shorten_weight=shorten_weight, shorten_width=shorten_width, shorten_italic=shorten_italic,\\n alt_uid=alt_uid, fixCFF=fix_cff, isSuperFamily=super_family, regular_italic=regular_italic, keep_regular=keep_regular, old_full_font_name=old_full_font_name)\\n\\n output_file = makeOutputFileName(\\n f, outputDir=output_dir, overWrite=overwrite)\\n font.save(output_file)\\n click.secho('{} saved'.format(output_file), fg='green')\\n except:\\n click.secho('{} is not a valid font'.format(f), fg='red')\\n pass\",\n \"def rename_duplicates_across_vol(count, ggg1, ggg2, vol1='25', vol2='50', verbose=True):\\n\\n c2 = []\\n for k,v in c1.items():\\n if v == 0:\\n c2.append(k)\\n\\n if verbose:\\n print(\\\"Duplicated galnames between m{:} and m{:}: \\\".format(vol1, vol2))\\n print(c2)\\n\\n if len(c2) > 0:\\n overlapped = True\\n p1 = pd.read_pickle('xxx' + vol1 + '/gal_catalog.pkl')\\n\\n import glob\\n # renaming duplicates\\n for i, old_n in enumerate(c2):\\n\\n if i == 0:\\n lastind = int(ggg1[-1][ggg1[-1].find('s36_')+5:])\\n\\n newind = lastind + 1\\n halo_name = old_n[:old_n.find('_')] # let's just keep the halo number from the first box, it's fine even tho it's not from the same halo as the second box, but we don't use that info in the future.\\n new_name = halo_name + '_s36_G' + str(newind)\\n lastind = newind\\n\\n ggg2.extend([new_name])\\n ggg1.remove(old_n)\\n\\n # update name in pickle file\\n iii = p1[p1['galnames'] == old_n].index.values\\n old_files = glob.glob('xxx' + vol1 + '/z*' + old_n + '_sim.*')\\n\\n if len(iii) > 0 and len(old_files) > 0:\\n p1['galnames'][int(iii)] = new_name\\n p1.to_pickle('xxx' + vol1 + '/gal_catalog.pkl') # update\\n\\n for fff in old_files:\\n basename = os.path.basename(fff)\\n basename = basename[:basename.find('_')]\\n extension = os.path.splitext(fff)[1]\\n print('mv ' + fff + ' ' + 'xxx' + vol1 + '/' + basename + '_' + new_name + '_sim' + extension)\\n os.system('mv ' + fff + ' ' + 'xxx' + vol1 + '/' + basename + '_' + new_name + '_sim' + extension)\\n\\n blah = os.system('ls ' + 'xxx' + vol1 + '/' + basename + '_' + new_name + '_sim' + extension)\\n if blah != 0:\\n import pdb; pdb.set_trace()\\n # update galaxies/z6_extracted_gals_xxx file\\n # CURRENTLY need to UPDATE MANUALLY\\n\\n else:\\n # probably alraedy updated when we ran code before\\n pass\\n\\n if not os.path.exists('xxx' + vol1 + vol2 + '/'):\\n os.mkdir('xxx' + vol1 + vol2 + '/')\\n p2 = pd.read_pickle('xxx' + vol2 + '/gal_catalog.pkl')\\n # combine...\\n results = {}\\n for kk in p1.keys():\\n results[kk] = np.hstack([p1[kk].values, p2[kk].values])\\n results = pd.DataFrame(results)\\n results.to_pickle('xxx' + vol1+vol2 +'/gal_catalog.pkl')\\n\\n # symlink simulation files\\n os.chdir('xxx' + vol1 + vol2 + '/')\\n os.system('rm *.dm *.star *.gas')\\n\\n for i in glob.glob('../xxx' + vol1 + '/*.dm'):\\n basename, extension = os.path.splitext(i)\\n os.system('cp ' + basename + '.dm .')\\n os.system('cp ' + basename + '.gas .')\\n os.system('cp ' + basename + '.star .')\\n\\n for i in glob.glob('../xxx' + vol2 + '/*.dm'):\\n basename, extension = os.path.splitext(i)\\n os.system('cp ' + basename + '.dm .')\\n os.system('cp ' + basename + '.gas .')\\n os.system('cp ' + basename + '.star .')\\n os.chdir('../')\\n\\n else:\\n overlapped = False\\n\\n return overlapped, ggg1, ggg2\",\n \"def _replace_names_in_json_dict(jdict, renmap):\\n if jdict:\\n for k in list(jdict.keys()):\\n nk = renmap.get(k)\\n if nk:\\n jdict[nk] = jdict[k]\\n del jdict[k]\",\n \"def reformat_json_file(infilename, outfilename, clobber=False):\\n # open input json file\\n with open(infilename) as json_file:\\n json_string = json_file.read()\\n json_data = json.loads(json_string)\\n\\n # see if output file already exists and determine course of action\\n if os.path.exists(outfilename):\\n if clobber:\\n os.remove(outfilename)\\n else:\\n sys.exit(\\\"Error: output file {} already exists and would be overwritten!\\\".format(outfilename))\\n\\n # write out reformatted json file\\n with open(outfilename, 'w') as f:\\n json.dump(json_data, f, indent=4)\",\n \"def smooth_images_toresolution(target_resolution,\\n globs=[\\\"destripe*P[LMS]W*fits\\\",\\n \\\"destripe*blue*fits\\\",\\n \\\"destripe*red*fits\\\"],\\n reject_regex='smooth|smregrid', verbose=True,\\n skip_existing=True, regrid=True,\\n target_header=None, regrid_order=1,\\n clobber=False, **kwargs):\\n\\n for fn in [x for g in globs for x in glob.glob(g)\\n if not re.search(reject_regex, x)]:\\n if verbose:\\n print(\\\"Reading file {0}\\\".format(fn),)\\n\\n outnum = int(target_resolution.to(u.arcsec).value)\\n smoutfn = fn.replace(\\\".fits\\\", \\\"_smooth{0:d}.fits\\\".format(outnum))\\n if os.path.exists(smoutfn):\\n if skip_existing:\\n if verbose:\\n print(\\\"Skipping {0}\\\".format(fn))\\n continue\\n \\n smhduL = smooth_image_toresolution(fn, smoutfn, target_resolution,\\n verbose=verbose, clobber=clobber,\\n **kwargs)\\n smhdu = smhduL[0]\\n\\n if regrid:\\n if target_header is None:\\n raise ValueError(\\\"Must specify a target header if regridding.\\\")\\n newimage = hcongrid(smhdu.data, smhdu.header, target_header,\\n order=regrid_order)\\n\\n rgoutfn = fn.replace(\\\".fits\\\", \\\"_smregrid{0:d}.fits\\\".format(outnum))\\n print(\\\"Regridding {0} to {1}\\\".format(smoutfn, rgoutfn))\\n newhdu = fits.PrimaryHDU(data=newimage, header=target_header)\\n newhdu.writeto(rgoutfn, clobber=clobber)\",\n \"def correct_naming(obsid, inst):\\n cobsid = str(int(float(obsid)))\\n if len(cobsid) == 5:\\n return \\n\\n lobsid = mcf.add_leading_zero(obsid, 5)\\n \\n for sdir in ['secondary', 'analysis']:\\n\\n cmd = 'ls /data/hrc/' + inst + '/' + lobsid + '/' + sdir + '/hrcf* >' + zspace\\n os.system(cmd)\\n\\n data = mcf.read_data_file(zspace, remove=1)\\n for ent in data:\\n atemp = re.split('\\\\/', ent)\\n fname = atemp[-1]\\n mc = re.search(lobsid, fname)\\n if mc is not None:\\n continue\\n else:\\n atemp = re.split('hrcf', fname)\\n btemp = re.split('_', atemp[1])\\n sobs = btemp[0]\\n new = fname.replace(sobs, lobsid)\\n full = '/data/hrc/' + inst + '/' + lobsid + '/' + sdir + '/' + new\\n\\n cmd = 'mv ' + ent + ' ' + full\\n os.system(cmd)\",\n \"def change_column_names(filename, old_colnames, new_colnames):\\n\\tos.system('mv %s %s.copy' % (filename, filename))\\n\\tc = pyfits.open(filename+\\\".copy\\\")\\n\\ttbhdu = c[1]\\n\\tncol = len(tbhdu.data.columns)\\n\\tnewcols = []\\n\\tfor i in range(ncol):\\n\\t\\tcolname = tbhdu.data.columns[i].name\\n\\t\\tcolfmt = tbhdu.data.formats[i]\\n\\t\\tcolarr = tbhdu.data.field(colname)\\n\\t\\tfor j in range(len(old_colnames)):\\n\\t\\t\\tif tbhdu.data.columns[i].name == old_colnames[j]:\\n\\t\\t\\t\\tcolname = new_colnames[j]\\n\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t#print colname\\n\\t\\tnewcols += [pyfits.Column(name=colname, format=colfmt, array=colarr)]\\n\\tnewcols = pyfits.ColDefs(newcols)\\n\\t#print newcols\\n\\tnewhdu = pyfits.new_table(newcols)\\n\\tnewhdu.writeto(filename)\\n\\tc.close()\\n\\tos.system('rm %s.copy' % filename)\",\n \"def flareplot_json(df, clustdict, folderpath, flare_template = False):\\n os.makedirs(folderpath, exist_ok = True)\\n colors_auld = ['#800000', '#860000', '#8c0000', '#930000', '#990000', '#9f0000', '#a60000', '#ac0000', '#b20000', '#b90000', '#bf0000', '#c50000', '#cc0000', '#d20000', '#d80000', '#df0000', '#e50000', '#eb0000', '#f20000', '#f80000', '#ff0000', '#ff0700', '#ff0e00', '#ff1500', '#ff1c00', '#ff2300', '#ff2a00', '#ff3100', '#ff3800', '#ff3f00', '#ff4600', '#ff4d00', '#ff5400', '#ff5b00', '#ff6200', '#ff6900', '#ff7000', '#ff7700', '#ff7e00', '#ff8500', '#ff8c00', '#ff9100', '#ff9700', '#ff9d00', '#ffa300', '#ffa800', '#ffae00', '#ffb400', '#ffba00', '#ffbf00', '#ffc500', '#ffcb00', '#ffd100', '#ffd600', '#ffdc00', '#ffe200', '#ffe800', '#ffed00', '#fff300', '#fff900', '#ffff00', '#f2ff00', '#e5ff00', '#d8ff00', '#ccff00', '#bfff00', '#b2ff00', '#a5ff00', '#99ff00', '#8cff00', '#7fff00', '#72ff00', '#66ff00', '#59ff00', '#4cff00', '#3fff00', '#33ff00', '#26ff00', '#19ff00', '#0cff00', '#00ff00', '#0afc0a', '#15fa15', '#1ff81f', '#2af62a', '#34f434', '#3ff13f', '#49ef49', '#54ed54', '#5eeb5e', '#69e969', '#74e674', '#7ee47e', '#89e289', '#93e093', '#9ede9e', '#a8dba8', '#b3d9b3', '#bdd7bd', '#c8d5c8', '#d3d3d3']\\n colors_ylorrd = ['#800026', '#850026', '#8a0026', '#8f0026', '#940026', '#990026', '#9e0026', '#a30026', '#a80026', '#ad0026', '#b20026', '#b70026', '#bd0026', '#c00225', '#c30424', '#c60623', '#c90822', '#cc0a21', '#d00d21', '#d30f20', '#d6111f', '#d9131e', '#dc151d', '#df171c', '#e31a1c', '#e51e1d', '#e7221e', '#e9271f', '#eb2b20', '#ed2f21', '#ef3423', '#f13824', '#f33c25', '#f54126', '#f74527', '#f94928', '#fc4e2a', '#fc532b', '#fc582d', '#fc5d2e', '#fc6330', '#fc6831', '#fc6d33', '#fc7234', '#fc7836', '#fc7d37', '#fc8239', '#fc873a', '#fd8d3c', '#fd903d', '#fd933e', '#fd9640', '#fd9941', '#fd9c42', '#fd9f44', '#fda245', '#fda546', '#fda848', '#fdab49', '#fdae4a', '#feb24c', '#feb54f', '#feb853', '#febb56', '#febf5a', '#fec25d', '#fec561', '#fec864', '#fecc68', '#fecf6b', '#fed26f', '#fed572', '#fed976', '#feda79', '#fedc7d', '#fede80', '#fedf84', '#fee187', '#fee38b', '#fee48e', '#fee692', '#fee895', '#fee999', '#feeb9c', '#ffeda0', '#ffeea3', '#fff0a7', '#fff1ab', '#fff3ae', '#fff4b2', '#fff6b6', '#fff7b9', '#fff9bd', '#fffac1', '#fffcc4', '#fffdc8', '#ffffcc']\\n colors_grorrd = ['#800026', '#850026', '#8a0026', '#8f0026', '#940026', '#990026', '#9e0026', '#a30026', '#a80026', '#ad0026', '#b20026', '#b70026', '#bd0026', '#c00225', '#c30424', '#c60623', '#c90822', '#cc0a21', '#d00d21', '#d30f20', '#d6111f', '#d9131e', '#dc151d', '#df171c', '#e31a1c', '#e51e1d', '#e7221e', '#e9271f', '#eb2b20', '#ed2f21', '#ef3423', '#f13824', '#f33c25', '#f54126', '#f74527', '#f94928', '#fc4e2a', '#fc532b', '#fc582d', '#fc5d2e', '#fc6330', '#fc6831', '#fc6d33', '#fc7234', '#fc7836', '#fc7d37', '#fc8239', '#fc873a', '#fd8d3c', '#fd903d', '#fd933e', '#fd9640', '#fd9941', '#fd9c42', '#fd9f44', '#fda245', '#fda546', '#fda848', '#fdab49', '#fdae4a', '#feb24c', '#feb54f', '#feb853', '#febb56', '#febf5a', '#fec25d', '#fec561', '#fec864', '#fecc68', '#fecf6b', '#fed26f', '#fed572', '#fed976', '#feda79', '#fedc7d', '#fede80', '#fedf84', '#fee187', '#fee38b', '#fee48e', '#fee692', '#fee895', '#fee999', '#feeb9c', '#ffeda0', '#fbeaa4', '#f7e8a8', '#f4e6ac', '#f0e4b1', '#ece2b5', '#e9e0b9', '#e5ddbd', '#e1dbc2', '#ded9c6', '#dad7ca', '#d6d5ce', '#d3d3d3']\\n colors_inferno = ['#000003', '#000004', '#000006', '#010007', '#010109', '#01010B', '#02010E', '#020210', '#030212', '#040314', '#040316', '#050418', '#06041B', '#07051D', '#08061F', '#090621', '#0A0723', '#0B0726', '#0D0828', '#0E082A', '#0F092D', '#10092F', '#120A32', '#130A34', '#140B36', '#160B39', '#170B3B', '#190B3E', '#1A0B40', '#1C0C43', '#1D0C45', '#1F0C47', '#200C4A', '#220B4C', '#240B4E', '#260B50', '#270B52', '#290B54', '#2B0A56', '#2D0A58', '#2E0A5A', '#300A5C', '#32095D', '#34095F', '#350960', '#370961', '#390962', '#3B0964', '#3C0965', '#3E0966', '#400966', '#410967', '#430A68', '#450A69', '#460A69', '#480B6A', '#4A0B6A', '#4B0C6B', '#4D0C6B', '#4F0D6C', '#500D6C', '#520E6C', '#530E6D', '#550F6D', '#570F6D', '#58106D', '#5A116D', '#5B116E', '#5D126E', '#5F126E', '#60136E', '#62146E', '#63146E', '#65156E', '#66156E', '#68166E', '#6A176E', '#6B176E', '#6D186E', '#6E186E', '#70196E', '#72196D', '#731A6D', '#751B6D', '#761B6D', '#781C6D', '#7A1C6D', '#7B1D6C', '#7D1D6C', '#7E1E6C', '#801F6B', '#811F6B', '#83206B', '#85206A', '#86216A', '#88216A', '#892269', '#8B2269', '#8D2369', '#8E2468', '#902468', '#912567', '#932567', '#952666', '#962666', '#982765', '#992864', '#9B2864', '#9C2963', '#9E2963', '#A02A62', '#A12B61', '#A32B61', '#A42C60', '#A62C5F', '#A72D5F', '#A92E5E', '#AB2E5D', '#AC2F5C', '#AE305B', '#AF315B', '#B1315A', '#B23259', '#B43358', '#B53357', '#B73456', '#B83556', '#BA3655', '#BB3754', '#BD3753', '#BE3852', '#BF3951', '#C13A50', '#C23B4F', '#C43C4E', '#C53D4D', '#C73E4C', '#C83E4B', '#C93F4A', '#CB4049', '#CC4148', '#CD4247', '#CF4446', '#D04544', '#D14643', '#D24742', '#D44841', '#D54940', '#D64A3F', '#D74B3E', '#D94D3D', '#DA4E3B', '#DB4F3A', '#DC5039', '#DD5238', '#DE5337', '#DF5436', '#E05634', '#E25733', '#E35832', '#E45A31', '#E55B30', '#E65C2E', '#E65E2D', '#E75F2C', '#E8612B', '#E9622A', '#EA6428', '#EB6527', '#EC6726', '#ED6825', '#ED6A23', '#EE6C22', '#EF6D21', '#F06F1F', '#F0701E', '#F1721D', '#F2741C', '#F2751A', '#F37719', '#F37918', '#F47A16', '#F57C15', '#F57E14', '#F68012', '#F68111', '#F78310', '#F7850E', '#F8870D', '#F8880C', '#F88A0B', '#F98C09', '#F98E08', '#F99008', '#FA9107', '#FA9306', '#FA9506', '#FA9706', '#FB9906', '#FB9B06', '#FB9D06', '#FB9E07', '#FBA007', '#FBA208', '#FBA40A', '#FBA60B', '#FBA80D', '#FBAA0E', '#FBAC10', '#FBAE12', '#FBB014', '#FBB116', '#FBB318', '#FBB51A', '#FBB71C', '#FBB91E', '#FABB21', '#FABD23', '#FABF25', '#FAC128', '#F9C32A', '#F9C52C', '#F9C72F', '#F8C931', '#F8CB34', '#F8CD37', '#F7CF3A', '#F7D13C', '#F6D33F', '#F6D542', '#F5D745', '#F5D948', '#F4DB4B', '#F4DC4F', '#F3DE52', '#F3E056', '#F3E259', '#F2E45D', '#F2E660', '#F1E864', '#F1E968', '#F1EB6C', '#F1ED70', '#F1EE74', '#F1F079', '#F1F27D', '#F2F381', '#F2F485', '#F3F689', '#F4F78D', '#F5F891', '#F6FA95', '#F7FB99', '#F9FC9D', '#FAFDA0', '#FCFEA4']\\n colors_magma = ['#000003', '#000004', '#000006', '#010007', '#010109', '#01010B', '#02020D', '#02020F', '#030311', '#040313', '#040415', '#050417', '#060519', '#07051B', '#08061D', '#09071F', '#0A0722', '#0B0824', '#0C0926', '#0D0A28', '#0E0A2A', '#0F0B2C', '#100C2F', '#110C31', '#120D33', '#140D35', '#150E38', '#160E3A', '#170F3C', '#180F3F', '#1A1041', '#1B1044', '#1C1046', '#1E1049', '#1F114B', '#20114D', '#221150', '#231152', '#251155', '#261157', '#281159', '#2A115C', '#2B115E', '#2D1060', '#2F1062', '#301065', '#321067', '#341068', '#350F6A', '#370F6C', '#390F6E', '#3B0F6F', '#3C0F71', '#3E0F72', '#400F73', '#420F74', '#430F75', '#450F76', '#470F77', '#481078', '#4A1079', '#4B1079', '#4D117A', '#4F117B', '#50127B', '#52127C', '#53137C', '#55137D', '#57147D', '#58157E', '#5A157E', '#5B167E', '#5D177E', '#5E177F', '#60187F', '#61187F', '#63197F', '#651A80', '#661A80', '#681B80', '#691C80', '#6B1C80', '#6C1D80', '#6E1E81', '#6F1E81', '#711F81', '#731F81', '#742081', '#762181', '#772181', '#792281', '#7A2281', '#7C2381', '#7E2481', '#7F2481', '#812581', '#822581', '#842681', '#852681', '#872781', '#892881', '#8A2881', '#8C2980', '#8D2980', '#8F2A80', '#912A80', '#922B80', '#942B80', '#952C80', '#972C7F', '#992D7F', '#9A2D7F', '#9C2E7F', '#9E2E7E', '#9F2F7E', '#A12F7E', '#A3307E', '#A4307D', '#A6317D', '#A7317D', '#A9327C', '#AB337C', '#AC337B', '#AE347B', '#B0347B', '#B1357A', '#B3357A', '#B53679', '#B63679', '#B83778', '#B93778', '#BB3877', '#BD3977', '#BE3976', '#C03A75', '#C23A75', '#C33B74', '#C53C74', '#C63C73', '#C83D72', '#CA3E72', '#CB3E71', '#CD3F70', '#CE4070', '#D0416F', '#D1426E', '#D3426D', '#D4436D', '#D6446C', '#D7456B', '#D9466A', '#DA4769', '#DC4869', '#DD4968', '#DE4A67', '#E04B66', '#E14C66', '#E24D65', '#E44E64', '#E55063', '#E65162', '#E75262', '#E85461', '#EA5560', '#EB5660', '#EC585F', '#ED595F', '#EE5B5E', '#EE5D5D', '#EF5E5D', '#F0605D', '#F1615C', '#F2635C', '#F3655C', '#F3675B', '#F4685B', '#F56A5B', '#F56C5B', '#F66E5B', '#F6705B', '#F7715B', '#F7735C', '#F8755C', '#F8775C', '#F9795C', '#F97B5D', '#F97D5D', '#FA7F5E', '#FA805E', '#FA825F', '#FB8460', '#FB8660', '#FB8861', '#FB8A62', '#FC8C63', '#FC8E63', '#FC9064', '#FC9265', '#FC9366', '#FD9567', '#FD9768', '#FD9969', '#FD9B6A', '#FD9D6B', '#FD9F6C', '#FDA16E', '#FDA26F', '#FDA470', '#FEA671', '#FEA873', '#FEAA74', '#FEAC75', '#FEAE76', '#FEAF78', '#FEB179', '#FEB37B', '#FEB57C', '#FEB77D', '#FEB97F', '#FEBB80', '#FEBC82', '#FEBE83', '#FEC085', '#FEC286', '#FEC488', '#FEC689', '#FEC78B', '#FEC98D', '#FECB8E', '#FDCD90', '#FDCF92', '#FDD193', '#FDD295', '#FDD497', '#FDD698', '#FDD89A', '#FDDA9C', '#FDDC9D', '#FDDD9F', '#FDDFA1', '#FDE1A3', '#FCE3A5', '#FCE5A6', '#FCE6A8', '#FCE8AA', '#FCEAAC', '#FCECAE', '#FCEEB0', '#FCF0B1', '#FCF1B3', '#FCF3B5', '#FCF5B7', '#FBF7B9', '#FBF9BB', '#FBFABD', '#FBFCBF']\\n colors_ylgnbl = ['#081d58', '#0a1e5d', '#0c2062', '#0f2267', '#11246c', '#142671', '#162876', '#182a7b', '#1b2c80', '#1d2e85', '#20308a', '#22328f', '#253494', '#243795', '#243b97', '#243e99', '#24429a', '#23459c', '#23499e', '#234c9f', '#2350a1', '#2253a3', '#2257a4', '#225aa6', '#225ea8', '#2162aa', '#2166ac', '#206aae', '#206fb0', '#1f73b2', '#1f77b4', '#1f7bb6', '#1e80b8', '#1e84ba', '#1d88bc', '#1d8cbe', '#1d91c0', '#2094c0', '#2397c0', '#269ac1', '#299dc1', '#2ca0c1', '#2fa3c2', '#32a6c2', '#35a9c2', '#38acc3', '#3bafc3', '#3eb2c3', '#41b6c4', '#46b7c3', '#4bb9c2', '#50bbc1', '#55bdc1', '#5abfc0', '#60c1bf', '#65c3be', '#6ac5be', '#6fc7bd', '#74c9bc', '#79cbbb', '#7fcdbb', '#85cfba', '#8bd1b9', '#91d4b9', '#97d6b8', '#9dd8b8', '#a3dbb7', '#a9ddb6', '#afdfb6', '#b5e2b5', '#bbe4b5', '#c1e6b4', '#c7e9b4', '#caeab3', '#cdebb3', '#d0ecb3', '#d3eeb3', '#d6efb2', '#daf0b2', '#ddf1b2', '#e0f3b2', '#e3f4b1', '#e6f5b1', '#e9f6b1', '#edf8b1', '#eef8b4', '#f0f9b7', '#f1f9bb', '#f3fabe', '#f4fac1', '#f6fbc5', '#f7fcc8', '#f9fccb', '#fafdcf', '#fcfdd2', '#fdfed5', '#ffffd9']\\n colors_grorrd = ['#800026', '#850026', '#8a0026', '#8f0026', '#940026', '#990026', '#9e0026', '#a30026', '#a80026', '#ad0026', '#b20026', '#b70026', '#bd0026', '#c00225', '#c30424', '#c60623', '#c90822', '#cc0a21', '#d00d21', '#d30f20', '#d6111f', '#d9131e', '#dc151d', '#df171c', '#e31a1c', '#e51e1d', '#e7221e', '#e9271f', '#eb2b20', '#ed2f21', '#ef3423', '#f13824', '#f33c25', '#f54126', '#f74527', '#f94928', '#fc4e2a', '#fc532b', '#fc582d', '#fc5d2e', '#fc6330', '#fc6831', '#fc6d33', '#fc7234', '#fc7836', '#fc7d37', '#fc8239', '#fc873a', '#fd8d3c', '#fd903d', '#fd933e', '#fd9640', '#fd9941', '#fd9c42', '#fd9f44', '#fda245', '#fda546', '#fda848', '#fdab49', '#fdae4a', '#feb24c', '#feb54f', '#feb853', '#febb56', '#febf5a', '#fec25d', '#fec561', '#fec864', '#fecc68', '#fecf6b', '#fed26f', '#fed572', '#fed976', '#feda79', '#fedc7d', '#fede80', '#fedf84', '#fee187', '#fee38b', '#fee48e', '#fee692', '#fee895', '#fee999', '#feeb9c', '#ffeda0', '#fbeaa4', '#f7e8a8', '#f4e6ac', '#f0e4b1', '#ece2b5', '#e9e0b9', '#e5ddbd', '#e1dbc2', '#ded9c6', '#dad7ca', '#d6d5ce', '#d3d3d3']\\n colors = colors_grorrd\\n color_len = len(colors) -1\\n for clust in clustdict.keys():\\n\\n # Select top interactions based on its mean frequency. Also asign color based on mean value\\n df_clust = df.filter(items = clustdict[clust] + ['APosition1', 'APosition2', 'BPosition1', 'BPosition2','CPosition1', 'CPosition2','FPosition1', 'FPosition2',])\\n df_clust['mean'] = df_clust.mean(axis = 1, numeric_only = True)\\n mean_threshold = min(df_clust['mean'].nlargest(20).tolist())\\n df_clust['color'] = df_clust['mean'].apply(lambda x: colors[color_len-round(x*color_len/100)]) #There are 101 colors avalible in list\\n\\n #Filter top 5 in df_clust\\n df_clust = df_clust.nlargest(20,'mean')\\n\\n # 'Edge' entry for json file\\n df_dict = pd.DataFrame(columns = [\\\"name1\\\", \\\"name2\\\", \\\"frames\\\"])\\n df_dict['name1'] = df_clust['APosition1'] \\n df_dict['name2'] = df_clust['APosition2']\\n df_dict['frames'] = [[1]]*len(df_dict)\\n df_dict['color'] = df_clust['color']\\n df_dict['value'] = df_clust['mean']\\n edges = df_dict.to_dict(orient=\\\"records\\\")\\n\\n # Appending edges to flare plot template, if any submitted\\n if flare_template:\\n flare_template['edges'] = edges\\n jsondict = flare_template\\n else:\\n jsondict = { 'edges' : edges }\\n\\n #'Edge' multi-entries, based on the 4 GPCR nomenclatures\\n for leter in ['A', 'B', 'C', 'F']:\\n df_dict = pd.DataFrame(columns = [\\\"name1\\\", \\\"name2\\\", \\\"frames\\\"])\\n df_dict['name1'] = df_clust[leter+'Position1'] \\n df_dict['name2'] = df_clust[leter+'Position2']\\n df_dict['frames'] = [[1]]*len(df_dict)\\n df_dict['color'] = df_clust['color']\\n df_dict['value'] = df_clust['mean']\\n leter_edges = df_dict.to_dict(orient=\\\"records\\\")\\n\\n #Appending edges\\n if flare_template:\\n flare_template[leter+'edges'] = leter_edges\\n jsondict = flare_template\\n else:\\n jsondict = { leter+'edges' : leter_edges }\\n\\n #Writing json\\n jsonpath = folderpath + clust + \\\".json\\\"\\n with open(jsonpath, 'w') as jsonfile:\\n dump(jsondict, jsonfile, ensure_ascii=False, indent = 4)\",\n \"def make_modified_json(num_urls):\\n json_path = os.path.join(CHROMIUM_SRC, 'tools/perf/page_sets/data/')\\n json_template = ('{{'\\n '\\\"description\\\": \\\"Describes the Web Page Replay archives for a user '\\n 'story set. Dont edit by hand! Use record_wpr for updating.\\\", '\\n '\\\"archives\\\": {{ \\\"url{0}_page_set_000.wpr\\\": [\\\"url{0}\\\"]}}}}\\\\n')\\n for i in range(num_urls):\\n modified_name = str(i) + '_pc'\\n file_name = 'url{0}_page_set.json'\\n with open('{0}{1}'.format(json_path,\\n file_name.format(modified_name)), 'wb') as f:\\n f.write(json_template.format(modified_name))\",\n \"def save_as_json(self, json_name):\\r\\n with open(json_name, \\\"w\\\") as outfile:\\r\\n json.dump(self.pet_file, outfile) # save create json file with current information\\r\\n self.pet_file_name = json_name # set name to passed name\\r\",\n \"def subtract_skydark(f):\\n\\n # Store these final products in a separate directory\\n final_outdir = './final/'\\n outfile = os.path.join(final_outdir, f.replace('.fits', '_skydarksub.fits'))\\n if not os.path.isfile(outfile):\\n # Get the skydark data\\n skydark_ext1 = fits.getdata('skydark_ext_1_filtered.fits')\\n skydark_ext4 = fits.getdata('skydark_ext_4_filtered.fits')\\n\\n # Subtract the skydark from each extension\\n h = fits.open(f)\\n data = np.copy(h[1].data)\\n data = data - skydark_ext1\\n h[1].data = data.astype('float32')\\n data = np.copy(h[4].data)\\n data = data - skydark_ext4\\n h[4].data = data.astype('float32')\\n h.writeto(outfile)\\n h.close()\\n else:\\n print('{} already exists.'.format(outfile))\",\n \"def write_snappy_dict(self):\\n feature_list = []\\n refinement_surface_dict = {}\\n layer_dict = {}\\n geom_dict = {}\\n\\n for part in self.geometries:\\n geom = { part.filename : {'type':'triSurfaceMesh', 'name':part.name}}\\n geom_dict.update(geom)\\n\\n file_dict = {'file' : '\\\"{}.eMesh\\\"'.format(part.name),\\n 'level' : self.surfaceRefinement}\\n feature_list.append(file_dict)\\n\\n refinement_surface = {part.name : {\\n 'level' : [self.refinementSurfaceMin, self.refinementSurfaceMax]}}\\n refinement_surface_dict.update(refinement_surface)\\n\\n layer = {part.name : {'nSurfaceLayers' : self.nSurfaceLayers}}\\n layer_dict.update(layer)\\n\\n snappy_dict = {\\n\\n 'castellatedMesh' : self.castellate,\\n 'snap' : self.snap,\\n 'addLayers' : self.addLayers,\\n 'geometry' :geom_dict,\\n 'castellatedMeshControls' : {\\n 'maxLocalCells' : self.maxLocalCells,\\n 'maxGlobalCells' : self.maxGlobalCells,\\n 'minRefinementCells' : self.minRefinementCells,\\n 'maxLoadUnbalance' : self.maxLoadUnbalance,\\n 'nCellsBetweenLevels' : self.nCellsBetweenLevels,\\n 'features' : feature_list,\\n 'refinementSurfaces': refinement_surface_dict,\\n 'resolveFeatureAngle' : self.resolveFeatureAngle,\\n 'refinementRegions' : {self.geometries[0].name :\\n {'mode' : 'distance',\\n 'levels' :([[(self.distanceRefinements[x],\\\\\\n self.distanceLevels[x])] for x in\\\\\\n range(len(self.distanceRefinements))])}},\\n 'locationInMesh' : self.locationToKeep,\\n 'allowFreeStandingZoneFaces' : self.allowFreeStandingFaces\\n },\\n 'snapControls' :\\n {\\n 'nSmoothPatch' : self.nSmoothPatch,\\n 'tolerance' : self.snapTolerance,\\n 'nRelaxIter' : self.nRelaxIter,\\n 'nSolveIter' : self.nSolveIter,\\n 'nFeatureSnapIter' : self.nFeatureSnapIter,\\n 'implicitFeatureSnap' : self.implicitFeatureSnap,\\n 'explicitFeatureSnap' : self.explicitFeatureSnap,\\n 'multiRegionFeatureSnap' : self.multiRegionFeatureSnap,\\n },\\n 'addLayersControls' :\\n {\\n 'relativeSizes' : self.relativeSizes,\\n 'expansionRatio' : self.expansionRatio,\\n 'finalLayerThickness' : self.finalLayerThickness,\\n 'minThickness' : self.minThickness,\\n 'nGrow' : self.nGrow,\\n 'layers': layer_dict,\\n 'featureAngle' : self.featureAngle,\\n 'slipFeatureAngle' : self.slipFeatureAngle,\\n 'nRelaxIter' : self.nRelaxIter,\\n 'nSmoothSurfaceNormals' : self.nSmoothSurfaceNormals,\\n 'nSmoothNormals' : self.nSmoothNormals,\\n 'nSmoothThickness' : self.nSmoothThickness,\\n 'maxFaceThicknessRatio' : self.maxFaceThicknessratio,\\n 'maxThicknessToMedialRatio' : self.maxThicknessToMedialRatio,\\n 'minMedianAxisAngle' : self.minMedianAxisAngle,\\n 'nBufferCellsNoExtrude' : self.nBufferCellsNoExtrude,\\n 'nLayerIter' : self.nLayerIter\\n },\\n 'meshQualityControls' :\\n {\\n '#include' : '\\\"meshQualityDict\\\"'\\n },\\n 'mergeTolerance' : self.mergeTolerance\\n }\\n with self.case.mutable_data_file(FileName.SNAPPY_HEX_MESH) as d:\\n d.update(snappy_dict)\",\n \"def finalize(self, filename):\\n with open(filename.replace('.json', '') + '-sprite.json', 'w') as outfile:\\n json.dump(self.intra_dups_list, outfile)\\n with open(filename.replace('.json', '') + '-project.json', 'w') as outfile:\\n json.dump(self.project_dups_list, outfile)\\n\\n# count = sum([len(listElem) for listElem in self.intra_dups_list])\\n count = len(self.intra_dups_list)\\n result = (\\\"{} intra-sprite duplicate scripts found\\\\n\\\".format(count))\\n result += (\\\"%d project-wide duplicate scripts found\\\\n\\\" % len(self.project_dups_list))\\n\\n return result\",\n \"def test_rotate_filenames():\\n tmpdir = os.path.join(tempfile.gettempdir(), \\\"jade-test-tmp87alkj8ew\\\")\\n os.makedirs(tmpdir, exist_ok=True)\\n\\n data = {\\\"A\\\": 1, \\\"B\\\": 2}\\n json_file1 = os.path.join(tmpdir, \\\"a1.json\\\")\\n dump_data(data, json_file1)\\n\\n json_file2 = os.path.join(tmpdir, \\\"a2.json\\\")\\n dump_data(data, json_file2)\\n\\n rotate_filenames(tmpdir, \\\".json\\\")\\n\\n if os.path.exists(tmpdir):\\n shutil.rmtree(tmpdir)\",\n \"def main(masklist, degrade, outfolder, outfileroot):\\n maplist = []\\n nsidelist = []\\n\\n # 1) Operating on individual masks\\n for mask in masklist:\\n path = mask['path']\\n cut = mask['cut']\\n invert = mask['invert']\\n unseen = mask['unseen']\\n\\n hpmap = hp.read_map(path)\\n nside = hp.get_nside(hpmap)\\n nsidelist.append(nside)\\n hp_seen = (hpmap != hp.UNSEEN)\\n\\n if cut is not None:\\n hpmap = np.where((hpmap < cut) & hp_seen, 1, 0)\\n else:\\n assert np.all((hpmap[hp_seen] == 0) | (hpmap[hp_seen] == 1)), (\\\"\\\"+\\n \\\"If there is no cut, the map must consist of zeros and ones\\\")\\n if invert:\\n hpmap[hp_seen] = np.where((hpmap[hp_seen] == 1), 0, 1)\\n if unseen is not None:\\n hpmap[~hp_seen] = unseen\\n\\n maplist.append(hpmap)\\n del hpmap, nside\\n\\n # 2) Upgrading to common high resolution and merging\\n n_hires = max(nsidelist)\\n mask_hires = np.ones(hp.nside2npix(n_hires))\\n for hpmap, nside in zip(maplist, nsidelist):\\n if nside < n_hires:\\n hpmap = hp.ud_grade(hpmap, n_hires)\\n mask_hires *= hpmap\\n del hpmap\\n\\n # 3) Save full mask\\n try:\\n os.makedirs(outfolder)\\n except OSError as exception:\\n if exception.errno != errno.EEXIST:\\n raise\\n\\n outfile = outfileroot + \\\"_nside\\\" + str(n_hires) + \\\".fits\\\"\\n outpath = os.path.join(outfolder, outfile)\\n hp.write_map(outpath, mask_hires)\\n\\n # 4) Degrade resolution down to Nside = 128 and saving\\n if degrade:\\n pow2_hires = int(np.log2(n_hires))\\n nsideiter = (2**i for i in xrange(7, pow2_hires)) # 7 --> Nside = 128\\n for nside in nsideiter:\\n mask_lores = hp.ud_grade(mask_hires, nside)\\n outfile = (outfileroot + \\\"_degraded_nside\\\" + str(n_hires) +\\n \\\"_to_\\\" + str(nside) + \\\".fits\\\")\\n outpath = os.path.join(outfolder, outfile)\\n hp.write_map(outpath, mask_lores)\\n del mask_lores\\n\\n return None\",\n \"def reSize(self, percent = 50, newName = '', force = False):\\n\\t\\tnewFile = textureFile( self.dirPath + newName + self.extension )\\n\\t\\tcmd = '\\\"' + self.path + '\\\" -resize ' + str( percent ) + '% \\\"' + newFile.path + '\\\"'\\n\\t\\tif force or not newFile.exists:\\n\\t\\t\\tos.popen( IMAGEMAGICPATH + 'convert.exe ' + cmd )\\n\\t\\treturn newFile\",\n \"def map_county_data(percentage, outname, county_svg, dem = False):\\n\\n county_svg = open(county_svg, 'r').read()\\n county_data = csv.reader(open('processed_data.csv'), delimiter = \\\",\\\")\\n \\n soup = BeautifulSoup(county_svg, \\\"html.parser\\\")\\n paths = soup.findAll('path')\\n red_colors = ['#FF0033', \\\"#FF4066\\\", \\\"#FF8099\\\", '#FFBFCC', '#FFFFFF']\\n blue_colors = ['#3333FF', \\\"#6666FF\\\", \\\"#9999FF\\\", \\\"#CCCCFF\\\", \\\"#FFFFFF\\\"]\\n \\n path_style = 'font-size:12px;fill-rule:nonzero;stroke:#FFFFFF;stroke-opacity:1; stroke-width:0.1;stroke-miterlimit:4;stroke-dasharray:none;stroke-linecap:butt; marker-start:none;stroke-linejoin:bevel;fill:' \\n \\n if dem:\\n colors = blue_colors\\n else:\\n colors = red_colors\\n \\n for p in paths:\\n if p['id'] not in ['State_Lines', 'separator']:\\n #print(str(p['id']))\\n try:\\n rate = percentage[int(p['id'])]\\n except: \\n continue\\n \\n if rate < 0.1:\\n color_class = 4\\n elif rate < 0.3: \\n color_class = 3\\n elif rate < 0.5: \\n color_class = 2\\n elif rate < 0.7: \\n color_class = 1\\n elif rate < 0.9: \\n color_class = 0\\n \\n color = colors[color_class]\\n p['style'] = path_style + color\\n \\n\\n f = open(outname, 'w')\\n f.write(soup.prettify())\\n f.close()\",\n \"def rename(self):\\n\\n # Remove any zero-padding from single-digit parameter names\\n # This reverses any change applied by one of the CUDA writers\\n for i in range(self.parser.comp-1, len(self.parser.parsedModel.parameterId)):\\n old_name = self.parser.parsedModel.parameterId[i]\\n num = old_name[len('parameter'):]\\n if len(num) > 1 and num[0] == '0':\\n new_name = 'parameter' + str(num[1:])\\n self.parser.parsedModel.parameterId[i] = new_name\\n self.parser.rename_everywhere(old_name, new_name)\\n\\n # Remove any zero-padding from single-digit species names\\n # This reverses any change applied by one of the CUDA writers\\n for i in range(len(self.parser.parsedModel.speciesId)):\\n old_name = self.parser.parsedModel.speciesId[i]\\n num = old_name[len('species'):]\\n if len(num) > 1 and num[0] == '0':\\n new_name = 'species' + str(num[1:])\\n self.parser.parsedModel.speciesId[i] = new_name\\n self.parser.rename_everywhere(old_name, new_name)\",\n \"def remove_useless_file(rootPath):\\n all_file_paddle_list = get_all_paddle_file(rootPath)\\n ut_file_map_new = {}\\n ut_file_map = \\\"%s/build/ut_file_map.json\\\" % rootPath\\n with open(ut_file_map, 'r') as load_f:\\n load_dict = json.load(load_f)\\n for key in load_dict:\\n if key in all_file_paddle_list:\\n ut_file_map_new[key] = load_dict[key]\\n\\n with open(\\\"%s/build/ut_file_map.json\\\" % rootPath, \\\"w\\\") as f:\\n json.dump(ut_file_map_new, f, indent=4)\\n print(\\\"remove_useless_file ut_file_map success!!\\\")\",\n \"def remap2json(xlsxfile,\\n fs_stat_file,\\n json_file = None,\\n outfile = None,\\n noscrape = False,\\n force_update = False,\\n ):\\n import io\\n import requests\\n import json\\n import pandas as pd\\n import numpy as np\\n import xlrd\\n import socket\\n\\n # read in the xlxs file\\n xls = pd.ExcelFile(xlsxfile)\\n mapping = pd.read_excel(xls, 'Subcortical Volumes', header=[0,1])\\n corticals = pd.read_excel(xls, 'Cortical Structures', header=[0,1])\\n\\n if not json_file:\\n # creating a mapper and scraping definitions from the web is time-consuming.\\n # Ideally, we want to do this only once. Therefore, we generate a base-remapper\\n # that we take in as a default, and only update the definitions if none exists yet.\\n try:\\n with open ('segstats_jsonld/mapping_data/freesurfermap.json') as j:\\n mapper = json.load(j)\\n print('Found a base-remapper. To speed up the generation of the .json'\\n 'mapping file, I will use the existing one and update it, if possible')\\n json_file = 'segstats_jsonld/mapping_data/freesurfermap.json'\\n except OSError as e:\\n print(\\\"Could not find any base-remapper. Will generate one.\\\")\\n\\n if json_file:\\n # if we have a user-supplied json mapper, check whats inside and only append new stuff\\n # if necessary, update the file.\\n with open(json_file) as j:\\n mapper = json.load(j)\\n\\n # check whether we have an internet connection\\n has_connection = test_connection()\\n\\n if not noscrape and has_connection:\\n # if not existing in json mapper, rename the URIs so that they resolve, scrape definition\\n definition_anat = []\\n print(\\\"\\\"\\\"\\n Scraping anatomical definitions from interlex. This might take a few minutes,\\n depending on your internet connection.\\n \\\"\\\"\\\")\\n get_info = True\\n for i, row in mapping.iterrows():\\n if json_file:\\n if row['Atlas Segmentation Label'].values[0] in mapper['Anatomy'].keys():\\n # the term already exists in the mapper, lets check whether it has a definition\\n get_info = False\\n if mapper[\\\"Anatomy\\\"][row['Atlas Segmentation Label'].values[0]][\\\"definition\\\"] == 'NA':\\n # there is no definition yet, lets try to get it\\n get_info = True\\n print('Checking for yet missing definition of label', row['Atlas Segmentation Label'].values[0])\\n else:\\n if not force_update:\\n # append existing definition\\n definition_anat.append(mapper[\\\"Anatomy\\\"][row['Atlas Segmentation Label'].values[0]][\\\"definition\\\"])\\n if force_update:\\n # override if we really want to check the definitions again\\n get_info = True\\n if get_info:\\n # print('getting info for', row['Atlas Segmentation Label'].values[0])\\n # get info only if json mapper does not exist yet\\n if row['Federated DE']['URI'] is not np.nan:\\n # this fixes the ilx link to resolve to scicrunch\\n url = 'ilx_'.join(row['Federated DE']['URI'].split('ILX:')) + '.ttl'\\n try:\\n r = requests.get(url)\\n file = io.StringIO(r.text)\\n lines = file.readlines()\\n for line in lines:\\n if 'definition' in line[:14]:\\n definition_anat.append(line.split('\\\"')[1])\\n except socket.timeout:\\n print('caught a timeout, appending \\\"\\\" to definitions')\\n definition_anat.append(\\\"\\\")\\n\\n else:\\n definition_anat.append('NA')\\n\\n definition_cort = []\\n for i, row in corticals.iterrows():\\n if json_file:\\n if row['APARC Structures - Assuming Cortical Areas (not sulci)']['Label'] in mapper['Anatomy'].keys():\\n # the term already exists in the mapper, lets check whether it has a definition\\n get_info = False\\n if mapper[\\\"Anatomy\\\"][row['APARC Structures - Assuming Cortical Areas (not sulci)']['Label']][\\\"definition\\\"] == 'NA':\\n # there is no definition yet, lets try to get it\\n get_info = True\\n print('Checking for yet missing definition of label', row['APARC Structures - Assuming Cortical Areas (not sulci)']['Label'])\\n else:\\n # append existing definition\\n if not force_update:\\n definition_cort.append(\\n mapper[\\\"Anatomy\\\"][row['APARC Structures - Assuming Cortical Areas (not sulci)']['Label']][\\\"definition\\\"])\\n if force_update:\\n get_info = True\\n if get_info:\\n # print('getting info for', row['APARC Structures - Assuming Cortical Areas (not sulci)']['Label'])\\n if row['APARC Structures - Assuming Cortical Areas (not sulci)']['Interlex Label'] is not np.nan:\\n url = row['APARC Structures - Assuming Cortical Areas (not sulci)']['URI'] + '.ttl'\\n r = requests.get(url)\\n file = io.StringIO(r.text)\\n lines = file.readlines()\\n for line in lines:\\n if 'definition' in line[:14]:\\n definition_cort.append(line.split('\\\"')[1])\\n break\\n elif line == lines[-1]:\\n # some structures do not have definitions yet, append empty strings\\n definition_cort.append(\\\"\\\")\\n else:\\n definition_cort.append('NA')\\n\\n elif noscrape or not has_connection:\\n # if we can't or don't want scrape, append NA and print a warning? # TODO: is that sensible?\\n print(\\\"\\\"\\\"\\n Interlex definition of anatomical concepts will NOT be performed. If you did not\\n specify this behaviour, this could be due to a missing internet connection\\\"\\\"\\\")\\n if not json_file:\\n # no definitions at all\\n definition_anat = [\\\"\\\"] * len(mapping)\\n definition_cort = [\\\"\\\"] * len(corticals)\\n else:\\n # append existing definitions from json\\n if 'Left-Lateral-Ventricle' in mapper['Anatomy'].keys():\\n definition_anat = [\\n mapper['Anatomy'][r['Atlas Segmentation Label'].values[0]]['definition'] \\\\\\n for (i, r) in mapping.iterrows()\\n ]\\n definition_anat = np.asarray(definition_anat)\\n if 'bankssts' in mapper['Anatomy'].keys():\\n definition_cort = [\\n mapper['Anatomy'][r['APARC Structures - Assuming Cortical Areas (not sulci)']['Label']]['definition'] \\\\\\n for (i, r) in corticals.iterrows()\\n ]\\n definition_cort = np.asarray(definition_cort)\\n\\n assert len(definition_cort) == len(corticals)\\n assert len(definition_anat) == len(mapping)\\n # append the definitions\\n mapping['definition'] = definition_anat\\n corticals['definition'] = definition_cort\\n print(\\\"\\\"\\\"Done collecting definitions.\\\"\\\"\\\")\\n d = {}\\n print(\\\"\\\"\\\"creating json mapping from anatomicals...\\\"\\\"\\\")\\n for i, row in mapping.iterrows():\\n # store missing values as empty strings, not NaNs that json can't parse\\n label = row['Atlas Segmentation Label'].values[0] if row['Atlas Segmentation Label'].values[0] is not np.nan else \\\"\\\"\\n url = row['Structure']['URI'] if row['Structure']['URI'] is not np.nan else \\\"\\\"\\n # the UBERON ID is currently listed as a string (e.g. UBERON:0014930) in the Excel file, we want\\n # an URI such as http://purl.obolibrary.org/obo/UBERON_0014930\\n # TODO: is the base URL correct here? (is it static and can be hardcoded?)\\n isAbout = 'http://purl.obolibrary.org/obo/' + row['Structure']['Preferred'].replace(':', '_') \\\\\\n if row['Structure']['Preferred'] is not np.nan else \\\"\\\"\\n hasLaterality = row['Laterality']['ILX:0106135'] if row['Laterality']['ILX:0106135'] is not np.nan else \\\"\\\"\\n l = row['Federated DE']['Name'] if row['Federated DE']['Name'] is not np.nan else \\\"\\\"\\n # WIP: Added by DBK because I can't change the Name column or really edit the ReproNimCDEs.xlsx file at all\\n # with my version of Excel (version 16.27 on Mac) without it mangling column B which is an IF statement\\n # something to do with Excel so here I'm forcing the removal of \\\"left\\\" | \\\"right\\\" | \\\"volume\\\" from the Names\\n l=l.replace('left','')\\n l=l.replace('right','')\\n l=l.replace('volume','').strip()\\n d[label] = {\\\"url\\\": url,\\n \\\"isAbout\\\": isAbout,\\n \\\"hasLaterality\\\": hasLaterality,\\n # WIP: Added by DBK, see comment above...\\n # \\\"definition\\\": row['definition'][0],\\n \\\"definition\\\": row['definition'][0].replace('left','').replace('right','').replace('volume','').strip(),\\n \\\"label\\\": l\\n }\\n print(\\\"Done. Creating json mapping from cortical structures...\\\")\\n for i, row in corticals.iterrows():\\n label = row['APARC Structures - Assuming Cortical Areas (not sulci)']['Label'] \\\\\\n if row['APARC Structures - Assuming Cortical Areas (not sulci)']['Label'] is not np.nan else \\\"\\\"\\n url = row['APARC Structures - Assuming Cortical Areas (not sulci)']['URI'] \\\\\\n if row['APARC Structures - Assuming Cortical Areas (not sulci)']['URI'] is not np.nan else \\\"\\\"\\n isAbout = 'http://purl.obolibrary.org/obo/' + row['APARC Structures - Assuming Cortical Areas (not sulci)']['Preferred'].replace(':', '_') \\\\\\n if row['APARC Structures - Assuming Cortical Areas (not sulci)']['Preferred'] is not np.nan else \\\"\\\"\\n # TODO: The Laterality of the terms in aparc files is undefined yet. I think that should change\\n hasLaterality = \\\"\\\"\\n l = row['APARC Structures - Assuming Cortical Areas (not sulci)']['Interlex Label'] \\\\\\n if row['APARC Structures - Assuming Cortical Areas (not sulci)']['Interlex Label'] is not np.nan else \\\"\\\"\\n d[label] = {\\\"url\\\": url,\\n \\\"isAbout\\\": isAbout,\\n \\\"hasLaterality\\\": hasLaterality,\\n \\\"definition\\\": row['definition'][0],\\n \\\"label\\\": l\\n }\\n # read the measures output of a of a read_stats() call. Depending on the header in the file,\\n # include present measures in json\\n print(\\\"Reading in FS stat file...\\\")\\n [header, tableinfo, measures] = read_stats(fs_stat_file)\\n d2 = {}\\n print(\\\"\\\"\\\"Creating measures json mapping...\\\"\\\"\\\")\\n\\n for fi, ind1, ind2 in [(mapping, 'Atlas Segmentation Label', 0),\\n (corticals, 'APARC Structures - Assuming Cortical Areas (not sulci)', 'Label')]:\\n for i, row in fi.iterrows():\\n anatomical = row[ind1][ind2]\\n for c in measures:\\n if c['structure'] == anatomical:\\n for dic in c['items']:\\n # iterate over the list of dicts in items\\n if dic['name'] == 'normMean':\\n d2['normMean'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0105536',\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738264'\\n }\\n if dic['name'] == 'normStdDev':\\n d2['normStdDev'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0105536',\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738265'\\n }\\n if dic['name'] == 'normMax':\\n d2['normMax'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0105536',\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738267'\\n }\\n if dic['name'] == 'NVoxels':\\n d2['NVoxels'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0112568',\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0102597',\\n \\\"hasUnit\\\": 'voxel'\\n }\\n if dic['name'] == 'Volume_mm3':\\n d2['Volume_mm3'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0112559',\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738276',\\n \\\"hasUnit\\\": 'mm^3'\\n }\\n if dic['name'] == 'normMin':\\n d2['normMin'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0105536',\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738266'\\n }\\n if dic['name'] == 'normRange':\\n d2['normRange'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0105536',\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738268'\\n }\\n if dic['name'] == 'NumVert':\\n d2['NumVert'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0738270', #vertex\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0102597' # count\\n }\\n if dic['name'] == 'SurfArea':\\n d2['SurfArea'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0738271', #surface\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0100885' #area\\n }\\n if dic['name'] == 'GrayVol':\\n d2['GrayVol'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0112559', # volume\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738276' #scalar\\n }\\n if dic['name'] == 'ThickAvg':\\n d2['ThickAvg'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0111689', #thickness\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738264' #mean\\n }\\n if dic['name'] == 'ThickStd':\\n d2['ThickStd'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0111689', #thickness\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738265' #stddev\\n }\\n if dic['name'] == 'MeanCurv':\\n d2['MeanCurv'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0738272', #mean curvature\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738276' #scalar\\n }\\n if dic['name'] == 'GausCurv':\\n d2['GausCurv'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0738273', #gaussian curvature\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738276' #scalar\\n }\\n if dic['name'] == 'FoldInd':\\n d2['FoldInd'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0738274', #foldind\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738276' #scalar\\n }\\n if dic['name'] == 'CurvInd':\\n d2['CurvInd'] = {\\n \\\"measureOf\\\": 'http://uri.interlex.org/base/ilx_0738275', #curvind\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738276' #scalar\\n }\\n if dic['name'] == 'nuMean':\\n d2['nuMean'] = {\\n \\\"measureOf\\\": 'TODO',\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738264' #mean\\n }\\n if dic['name'] == 'nuStdDev':\\n d2['nuStdDev'] = {\\n \\\"measureOf\\\":'TODO',\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738265' #stddev\\n }\\n if dic['name'] == 'nuMin':\\n d2['nuMin'] = {\\n \\\"measureOf\\\":'TODO',\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738266' #min\\n }\\n if dic['name'] == 'nuMax':\\n d2['nuMax'] = {\\n \\\"measureOf\\\":'TODO',\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738267' #max\\n }\\n if dic['name'] == 'nuRange':\\n d2['nuRange'] = {\\n \\\"measureOf\\\":'TODO',\\n \\\"datumType\\\": 'http://uri.interlex.org/base/ilx_0738268' #range\\n }\\n # join anatomical and measures dictionaries\\n biggie = {'Anatomy': d,\\n 'Measures': d2}\\n\\n if outfile:\\n with open(outfile, 'w') as f:\\n json.dump(biggie, f, indent=4)\\n # if no outfile is provided, we can update the existing file or create one\\n else:\\n if json_file:\\n with open(json_file, 'w') as f:\\n json.dump(biggie, f, indent=4)\\n else:\\n datapath = mapping_data.__path__[0] + '/'\\n with open(join(datapath, 'freesurfermap.json'), 'w') as f:\\n json.dump(biggie, f, indent=4)\\n\\n return [header, tableinfo, measures, biggie]\",\n \"def write_drugs_name(self):\\r\\n for elem in range(len(self.output_zakladki)):\\r\\n n, first_row = 0, 3\\r\\n\\r\\n sheet = self.output_zakladki[elem]\\r\\n sh = self.output_file.get_sheet_by_name(sheet)\\r\\n no_of_row = self.liczba_pelnych_linii\\r\\n\\r\\n if self.niepelna_liniia:\\r\\n no_of_row += 1\\r\\n\\r\\n while no_of_row != 0:\\r\\n for lek in self.output_leki[elem]:\\r\\n sh['A' + str(first_row + n)] = lek\\r\\n n += 1\\r\\n first_row += 2\\r\\n no_of_row -= 1\",\n \"def map_county_data_compare(dem_16, rep_16, outname, county_svg):\\n\\n county_svg = open(county_svg, 'r').read()\\n county_data = csv.reader(open('processed_data.csv'), delimiter = \\\",\\\")\\n \\n soup = BeautifulSoup(county_svg, \\\"html.parser\\\")\\n paths = soup.findAll('path')\\n blue_red = ['#FF0000','#EC0517','#DA092E','#C70E46','#B5135D','#A21774','#901C8B','#7D20A2','#6B25B9','#582AD1','#462EE8','#3333FF', '#FFFFFF']\\n # County style\\n path_style = 'font-size:12px;fill-rule:nonzero;stroke:#FFFFFF;stroke-opacity:1; stroke-width:0.1;stroke-miterlimit:4;stroke-dasharray:none;stroke-linecap:butt; marker-start:none;stroke-linejoin:bevel;fill:'\\n\\n for p in paths:\\n if p['id'] not in ['State_Lines', 'separator']:\\n #print(str(p['id']))\\n try:\\n rate = rep_16[int(p['id'])]\\n rate2 = dem_16[int(p['id'])]\\n except: \\n continue\\n if rate < 0.1 or rate2 > 0.9:\\n color_class = 9\\n elif rate < 0.2 or rate2 > 0.8: \\n color_class = 8\\n elif rate < 0.3 or rate2 > 0.7: \\n color_class = 7\\n elif rate < 0.4 or rate2 > 0.6: \\n color_class = 6\\n elif rate < 0.5 or rate2 > 0.5: \\n color_class = 5\\n elif rate < 0.6 or rate2 > 0.4: \\n color_class = 4\\n elif rate < 0.7 or rate2 > 0.3: \\n color_class = 3\\n elif rate < 0.8 or rate2 > 0.2: \\n color_class = 2\\n elif rate < 0.9 or rate2 > 0.1: \\n color_class = 0\\n elif rate < 1.0: \\n color_class = 1\\n else: color_class = 10\\n\\n color = blue_red[color_class]\\n p['style'] = path_style + color\\n \\n\\n f = open(outname, 'w')\\n f.write(soup.prettify())\\n f.close()\",\n \"def fix_acquisition_numbers_of_json_files_in(raw_dir: Path):\\n\\n print(\\\"Fixing the acquisition numbers of the .json files in sourcedata.\\\")\\n\\n for old_path in raw_dir.rglob(\\\"*.json\\\"):\\n\\n parts_of_stem_of_old_path = old_path.stem.split(\\\"_\\\")\\n stem_parts_with_correct_acquisition_number = parts_of_stem_of_old_path[:-1] + [acquisition_number_of(old_path)]\\n fresh_new_stem = \\\"_\\\".join(stem_parts_with_correct_acquisition_number)\\n fresh_new_path = old_path.with_name(fresh_new_stem + old_path.suffix)\\n old_path.replace(fresh_new_path)\",\n \"def test_too_small_remap(self):\\n ethanol = Molecule.from_file(get_data_file_path(\\\"molecules/ethanol.sdf\\\"))\\n # catch mappings that are the wrong size\\n too_small_mapping = {0: 1}\\n with pytest.raises(ValueError):\\n new_ethanol = ethanol.remap(too_small_mapping, current_to_new=True)\",\n \"def loadAndClean(jfile):\\n with open(jfile) as json_file:\\n data = json.load(json_file)[\\\"G15\\\"]\\n newDict = {}\\n # Print the type of data variable\\n \\n for entry in data:\\n\\n if \\\"version\\\" in data[entry] and data[entry][\\\"assessed_by\\\"] not in filterList:\\n\\n if data[entry][\\\"assessed_by\\\"] in dictTries:\\n dictTries[data[entry][\\\"assessed_by\\\"]].append(data[entry])\\n\\n \\n\\n if len(dictTries[data[entry][\\\"assessed_by\\\"]]) == 2:\\n ml = dictTries[data[entry][\\\"assessed_by\\\"]]\\n #vou querer calcular o maior \\n # comparisson = \\\"accuracy\\\"\\n comparisson = \\\"target_w_penalty\\\"\\n \\n if ml[0][comparisson] <= ml[1][comparisson]:\\n if ml[0][\\\"accuracy\\\"] > 90:\\n printSingle(ml[0])\\n newDict[entry] = ml[0]\\n\\n else:\\n if ml[1][\\\"accuracy\\\"] > 90:\\n printSingle(ml[1])\\n newDict[entry] = ml[1]\\n dictTries[data[entry][\\\"assessed_by\\\"]] = []\\n\\n else:\\n dictTries[data[entry][\\\"assessed_by\\\"]] = [data[entry]]\\n\\n\\n\\n # dictTries[data[\\\"assessed_by\\\"]]\\n\\n # newDict[entry] = data[entry]\\n # print(data[entry])\\n # print()\\n # printDict(newDict)\\n return newDict\",\n \"def change_file_name():\\n path = \\\"/etc/atuned/webserver/\\\"\\n file_list = os.listdir(path)\\n file_list.sort(key=lambda fn: os.path.getmtime(path + fn))\\n if len(file_list) > 0 and re.match(r'\\\\S*-\\\\d{17}\\\\S*', file_list[-1]) is None:\\n old_name = file_list[-1].split(\\\".\\\")[0]\\n curr_time = time.strftime(\\\"%Y%m%d%H%M%S\\\", time.localtime())\\n new_name = old_name + \\\"-\\\" + str(curr_time) + str(random.randint(100, 999))\\n os.rename(path + old_name + \\\".txt\\\", path + new_name + \\\".txt\\\")\",\n \"def save_json_file():\\n global output_on_display, import_lst, column_names, data, new_data\\n if data_base == '':\\n mistake_load_table()\\n else:\\n column_names = new_data\\n step = len(column_names)\\n save_name = asksaveasfilename(title=\\\"Select file\\\", filetypes=((\\\"JSON\\\", \\\"*.json\\\"), (\\\"all files\\\", \\\"*.*\\\")),\\n confirmoverwrite=True, defaultextension='.json')\\n data = import_lst\\n\\n if len(data[0]) == step:\\n pass\\n else:\\n data = import_lst[step::]\\n\\n data2 = list(map(list, zip(*data)))\\n\\n data3 = {key: value for key, value in zip(column_names, data2)}\\n\\n column = list(data3.keys())\\n\\n df = pd.DataFrame(data3, columns=column)\\n\\n data_dict = df.to_dict(orient=\\\"records\\\")\\n with open(save_name, \\\"w+\\\") as f:\\n json.dump(data_dict, f, indent=4)\\n\\n data.clear()\\n data2.clear()\\n data3.clear()\",\n \"def renameFiles(folder):\\n\\n # Retrieve list of all text files and remove the txt files\\n for filename in glob.glob(os.path.join(folder, \\\"*.txt\\\")):\\n with open(filename, 'r') as file:\\n metadata=file.read().replace('\\\\n', '')\\n ident = metadata[27:31]\\n order = metadata[26].upper()\\n finger = metadata[32:34]\\n gender = metadata[8].upper()\\n fingerprintClass = metadata[16].upper()\\n fp = Fingerprint(ident, order, finger, gender, fingerprintClass)\\n\\n # Remove the .txt file and rename the png\\n os.remove(filename)\\n pngName = filename.replace(\\\".txt\\\", \\\".png\\\")\\n newName = fp.id + \\\"_\\\" + fp.order + \\\"_\\\" + fp.finger + \\\"_\\\" + fp.gender + \\\"_\\\" + fp.fingerprintClass + \\\".png\\\"\\n newName = os.path.join(folder, newName)\\n os.rename(pngName, newName)\",\n \"def make_output_names(self):\\n yaml_names = []\\n fits_names = []\\n\\n if self.use_nonstsci_names:\\n for i in range(len(self.info['Module'])):\\n act = str(self.info['act_id'][i]).zfill(2)\\n if self.info['Instrument'][i].lower() == 'niriss':\\n det = 'NIS'\\n elif self.info['Instrument'][i].lower() == 'fgs':\\n det = 'FGS'\\n else:\\n det = self.info['detector'][i]\\n mode = self.info['Mode'][i]\\n dither = str(self.info['dither'][i]).zfill(2)\\n\\n yaml_names.append(os.path.abspath(os.path.join(self.output_dir, 'Act{}_{}_{}_Dither{}.yaml'\\n .format(act, det, mode, dither))))\\n fits_names.append('Act{}_{}_{}_Dither{}_uncal.fits'.format(act, det, mode, dither))\\n\\n else:\\n for i in range(len(self.info['Module'])):\\n if self.info['Instrument'][i].upper() == 'NIRCAM':\\n fulldetector = 'nrc{}'.format(self.info['detector'][i].lower())\\n else:\\n fulldetector = self.info['detector'][i].lower()\\n outfilebase = self.create_output_name(self.info, index=i)\\n outfile = \\\"{}{}{}\\\".format(outfilebase, fulldetector, '_uncal.fits')\\n yamlout = \\\"{}{}{}\\\".format(outfilebase, fulldetector, '.yaml')\\n\\n yaml_names.append(yamlout)\\n fits_names.append(outfile)\\n\\n self.info['yamlfile'] = yaml_names\\n self.info['outputfits'] = fits_names\\n # Table([self.info['yamlfile']]).pprint()\",\n \"def sanitize_json_files(unsanitized_json_file):\\n with open(develop_baseline_dir + unsanitized_json_file) as f:\\n lines = f.readlines()\\n\\n with open('sanitizedJson/sanitized_{}'.format(unsanitized_json_file), 'w') as w:\\n w.writelines([item for item in lines[:-1]])\",\n \"def new_shp_name(file_path):\\n while os.path.exists(file_path):\\n try:\\n int(file_path[-5])\\n except ValueError:\\n file_path = file_path[0:-4] + \\\"1.shp\\\"\\n else:\\n number = str(int(file_path[-5]) + 1)\\n file_path = file_path[0:-5] + number + \\\".shp\\\"\\n return file_path\",\n \"def rename_images(_input_image_paths : list[str], _output_image_dir : str) -> None:\\n #Starts at 0 to account for incrementing when seeing a non-alternative\\n # (the 1st image can never be an alternative take)\\n new_index = 0\\n\\n #Get the \\\"base name\\\" for the images - e.g., PICT, DCIM, IMG_, etc.\\n #Assumes that each image has the same base name as the first one.\\n #Also gets the \\\"base index\\\", e.g., 1, 001, 00018, etc.\\n base_name, base_index = get_image_base_name_and_index(_input_image_paths[0])\\n debug(f\\\"Base name ({base_name}) and index({base_index})\\\")\\n\\n #Since the first image can't be an alternative take, this lets us\\n # get the proper index length for all of the images\\n index_length = len(base_index)\\n\\n #For each image, rename based on the new indices\\n for image in _input_image_paths:\\n flag = get_alternative_flag(image)\\n\\n #increment the index if this was not an alternative-take image\\n if flag == '':\\n new_index += 1\\n\\n #Create an index padded with a sufficient number of prefixing '0's\\n formatted_index = \\\"0\\\" * (index_length - len(str(new_index))) + str(new_index)\\n\\n #Get the file name's extension\\n extension = os.path.splitext(image)[1]\\n\\n #Create the new file name based off of the current index\\n new_filepath = _output_image_dir + base_name + formatted_index + flag + extension\\n debug(f\\\"Saving {image} to {new_filepath}\\\")\\n\\n #Save the image with the updated path name\\n with Image.open(image) as image_object:\\n image_object.save(new_filepath)\",\n \"def refactor(path: str, files: List):\\n skipped = []\\n for filename in files:\\n try:\\n number = get_number_from_name(filename)\\n except AttributeError:\\n skipped.append(os.path.join(path, filename))\\n continue\\n new_number = update_number(number)\\n\\n file_path = os.path.join(path, filename)\\n new_file_path = file_path.replace(number, new_number)\\n\\n with open(file_path, 'r') as file:\\n data = file.read()\\n data = data.replace(number, new_number)\\n with open(file_path, 'w') as file:\\n file.write(data)\\n\\n os.rename(file_path, new_file_path)\\n return skipped\",\n \"def json_to_cache(new_json: Dict, file_name: str) -> None:\\n\\n json_path = os.path.join(CACHE_DIR, file_name)\\n ensure_dir(json_path)\\n with open(json_path, \\\"w\\\") as outfile:\\n json.dump(new_json, outfile, ensure_ascii=False)\",\n \"def renameFormats(self, nameDict):\\n for item in globalref.docRef.root.descendantGen():\\n item.formatName = nameDict.get(item.formatName, item.formatName)\",\n \"def re_name(name,new_name):\\n\\n try:\\n os.rename(config_tools.full_dest+name,config_tools.full_dest+new_name)\\n except OSError:\\n print(f\\\"Не удалось переименовать {name}\\\")\\n else:\\n print(f\\\"{name} успешно переименновавано в {new_name}\\\")\",\n \"def crop_and_resize_images(images_path, annotations_path, output_path):\\n assert os.path.exists(images_path)\\n assert os.path.exists(annotations_path)\\n\\n if not os.path.exists(output_path):\\n os.makedirs(output_path)\\n\\n image_file_names = util.get_images_at_path(images_path)\\n\\n # Filename of annotations file without path, e.g. annotations.json\\n annotations_file_name, annotations_file_extension = os.path.splitext(os.path.basename(annotations_path))\\n # Full path to new annotations file, e.g. /home/user/annotations/annotations_noisy.json\\n modified_annotations_file_path = os.path.join(output_path, annotations_file_name + \\\"_cropped\\\" + annotations_file_extension)\\n\\n with open(annotations_path, \\\"r\\\") as json_file, open(modified_annotations_file_path, \\\"w\\\") as modified_json_file:\\n json_data = json.load(json_file)\\n new_json_data = {}\\n\\n for image_file_name in image_file_names:\\n\\n # Load the image to augment\\n image = cv2.imread(os.path.join(images_path, image_file_name))\\n width, height, channels = image.shape\\n # At most 20% of the image width or height is used as offset\\n x_offset = random.randint(0, width / 5)\\n y_offset = random.randint(0, height / 5)\\n # And width and height are between 80 and 100% of original\\n crop_width = random.randint((4 * width) / 5, width)\\n crop_height = random.randint((4 * height) / 5, height)\\n # If we have 20% offset plus 100% width or height that's not gonna work\\n crop_width = min(crop_width, width - x_offset)\\n crop_height = min(crop_height, height - y_offset)\\n\\n print(\\\"Cropping image {} at ({}, {}) to ({}, {}).\\\".format(image_file_name, x_offset, y_offset, crop_width, crop_height))\\n\\n # Crop image\\n cropped_image = image[y_offset:y_offset + crop_height, x_offset:x_offset + crop_width]\\n image_file_base_name, extension = os.path.splitext(image_file_name)\\n augmented_file_name = image_file_base_name + \\\"_cropped\\\" + extension\\n augmented_file_path = os.path.join(output_path, augmented_file_name)\\n cv2.imwrite(augmented_file_path, cropped_image)\\n\\n # Adjust the annotations file\\n\\n for key in json_data:\\n if image_file_name in key:\\n # We found the currently process image, now adjust bounding boxes and set the new sizes\\n image_data = json_data[key]\\n new_image_data = {\\\"base64_img_data\\\" : image_data[\\\"base64_img_data\\\"], \\\\\\n \\\"fileref\\\" : image_data[\\\"fileref\\\"], \\\\\\n \\\"file_attributes\\\" : image_data[\\\"file_attributes\\\"]}\\n new_image_data[\\\"regions\\\"] = {}\\n for region_key in image_data[\\\"regions\\\"]:\\n region_data = image_data[\\\"regions\\\"][region_key]\\n shape_attributes = region_data[\\\"shape_attributes\\\"]\\n box_x, box_y, box_width, box_height = shape_attributes[\\\"x\\\"], shape_attributes[\\\"y\\\"], \\\\\\n shape_attributes[\\\"width\\\"], shape_attributes[\\\"height\\\"]\\n # Same as in conversion.py, we need to care for negative x and y (outside of image)\\n box_x = max(box_x, 0)\\n box_y = max(box_y, 0)\\n # Adjust to regions that go beyond the image\\n box_width = min(box_width, width - box_x)\\n box_height = min(box_height, height - box_y)\\n\\n old_x, old_y, old_width, old_height = box_x, box_y, box_width, box_height\\n\\n box_too_far_left = box_x + box_width < x_offset\\n box_too_far_right = box_x > x_offset + crop_width\\n box_too_far_up = box_y + box_height < y_offset\\n box_too_far_down = box_y > y_offset + crop_height\\n if box_too_far_left or box_too_far_right or box_too_far_up or box_too_far_down:\\n # If box is outside of cropping skip adding it\\n continue\\n\\n # New x and y positions of the bounding box\\n box_x = box_x - x_offset\\n if box_x < 0:\\n # Old x was outside of cropping, we need to adjust width, i.e. subtract the offset\\n box_width = box_width + box_x\\n box_x = 0\\n if box_x + box_width > crop_width:\\n # To care for the new box exceeding the image size\\n box_width = crop_width - box_x\\n\\n box_y = box_y - y_offset\\n if box_y < 0:\\n # Same goes for height\\n box_height = box_height + box_y\\n box_y = 0\\n if box_y + box_height > crop_height:\\n box_height = crop_height - box_y\\n \\n shape_attributes[\\\"x\\\"] = box_x\\n shape_attributes[\\\"y\\\"] = box_y\\n shape_attributes[\\\"width\\\"] = box_width\\n shape_attributes[\\\"height\\\"] = box_height\\n new_image_data[\\\"regions\\\"][region_key] = region_data\\n\\n # Now adjust to the new file name\\n split = key.split(image_file_name)\\n statinfo = os.stat(augmented_file_path)\\n new_key = augmented_file_name + str(statinfo.st_size)\\n image_data = json_data[key]\\n new_image_data[\\\"filename\\\"] = augmented_file_name\\n new_image_data[\\\"size\\\"] = int(statinfo.st_size)\\n new_json_data[new_key] = new_image_data\\n\\n json.dump(new_json_data, modified_json_file)\",\n \"def backeruper(file_name, file_num=0):\\n\\n if not os.path.exists('%s.json' % file_name):\\n write_backup('%s.json' % file_name)\\n elif not os.path.exists('%s.%s.json' % (file_name, file_num)):\\n write_backup('%s.%s.json' % (file_name, file_num))\\n else:\\n file_num += 1\\n backeruper(file_name, file_num)\",\n \"def download_hero_images(file_name, output_dir):\\n with open(file_name,'r') as json_file:\\n hero_json = json.load(json_file) \\n try:\\n os.mkdir(output_dir)\\n except OSError:\\n print (\\\"Failed to create directory %s\\\" % output_dir)\\n return\\n for hero in hero_json:\\n print (\\\"Processing %s.\\\" % hero['name'])\\n hero_dir = output_dir + '/' + str(hero['hero_id'])\\n os.mkdir(hero_dir)\\n urlr.urlretrieve(hero['img_url'], hero_dir + '/main.' + IMAGE_EXTENSION);\\n urlr.urlretrieve(hero['portrait_img_url'], hero_dir + '/portrait.' + IMAGE_EXTENSION);\\n\\n for ability in hero['abilities']:\\n ability_img = hero_dir + '/ability_' + str(ability['ability_id']) + '.' + IMAGE_EXTENSION\\n urlr.urlretrieve(ability['img_url'], ability_img);\",\n \"def add_shapefile_data(self, output):\\n prefix = \\\"hazard\\\" if output.output_type == \\\"hazard_map\\\" else \\\"loss\\\"\\n dirname = os.path.dirname(output.path)\\n layer_name, _ = os.path.splitext(os.path.basename(output.path))\\n layer_name = layer_name.replace(\\\".\\\", \\\"-\\\")\\n dirname = os.path.join(dirname, \\\"%s-shapefiles\\\" % prefix)\\n output.shapefile_path = os.path.join(dirname, \\\"%s.shp\\\" % layer_name)\\n os.rename(self.touch(dir=dirname), output.shapefile_path)\\n output.min_value = random.random()\\n output.max_value = output.min_value * math.pi\\n output.save()\\n return output.shapefile_path\",\n \"def rename_files_remove_version_number(files_dir, output_dir, logger=None):\\n\\n file_name_map = {}\\n\\n # Get a list of all files\\n dirfiles = file_list(files_dir)\\n\\n for df in dirfiles:\\n filename = df.split(os.sep)[-1]\\n\\n # Get the new file name\\n file_name_map[filename] = None\\n\\n # TODO strip the -v1 from it\\n file_extension = filename.split('.')[-1]\\n if '-v' in filename:\\n # Use part before the -v number\\n part_without_version = filename.split('-v')[0]\\n else:\\n # No -v found, use the file name minus the extension\\n part_without_version = ''.join(filename.split('.')[0:-1])\\n\\n renamed_filename = part_without_version + '.' + file_extension\\n\\n if renamed_filename:\\n file_name_map[filename] = renamed_filename\\n else:\\n if logger:\\n logger.info('there is no renamed file for ' + filename)\\n\\n for old_name, new_name in file_name_map.iteritems():\\n if new_name is not None:\\n shutil.move(files_dir + os.sep + old_name, output_dir + os.sep + new_name)\\n\\n return file_name_map\",\n \"def fileResizeObscure(new_filepath):\\n # Resize\\n img1 = Image.open(new_filepath)\\n img2=image_reduce(img1)\\n *** Stopped working here\\n newpath=\\\"toupload\\\\\\\\%s\\\" % new_filepath\\n # Block ID\\n width=img2.size[0]\\n height=img2.size[1]\\n # Obscuring params were decided by trial and error using fraction of width and height\\n x1=int(0.16*width)\\n x2=int(0.28*width)\\n y1=int(0.94*height)\\n y2=int(0.98*height) \\n # Faster but easier to snoop? should not be since it changes the pixels\\n draw = ImageDraw.Draw(img2)\\n draw.rectangle([(x1,y1),(x2,y2)],fill=\\\"white\\\")\\n del draw\\n \\n img2.save(newpath,optimize=True,quality=95)\",\n \"def adjust_for_speed_of_light_in_water(df, tide_level):\\n speed_of_light_air = 300000\\n speed_of_light_water = 225000\\n coef = speed_of_light_water / speed_of_light_air\\n df['Height'] = (df['Height']- tide_level) * coef\\n return df\",\n \"def assumpfile_bad2():\\n afile = tempfile.NamedTemporaryFile(suffix='.json', mode='a', delete=False)\\n bad2_assump_contents = \\\"\\\"\\\"\\n {\\n \\\"consumption\\\": {},\\n \\\"behavior\\\": {},\\n \\\"growdiff_baseline\\\": {},\\n \\\"growdiff_response\\\": {\\\"_ABOOK\\\": {\\\"2015\\\": [-0.01]}}\\n }\\n \\\"\\\"\\\"\\n afile.write(bad2_assump_contents)\\n afile.close()\\n # must close and then yield for Windows platform\\n yield afile\\n if os.path.isfile(afile.name):\\n try:\\n os.remove(afile.name)\\n except OSError:\\n pass # sometimes we can't remove a generated temporary file\",\n \"def WriteOnDiff(filename):\\n\\n class Writer(object):\\n \\\"\\\"\\\"Wrapper around file which only covers the target if it differs.\\\"\\\"\\\"\\n def __init__(self):\\n # Pick temporary file.\\n tmp_fd, self.tmp_path = tempfile.mkstemp(\\n suffix='.tmp',\\n prefix=os.path.split(filename)[1] + '.gyp.',\\n dir=os.path.split(filename)[0]\\n )\\n try:\\n self.tmp_file = os.fdopen(tmp_fd, 'w')\\n except Exception:\\n # Don't leave turds behind.\\n os.unlink(self.tmp_path)\\n raise\\n\\n def __getattr__(self, attrname):\\n # Delegate everything else to self.tmp_file\\n return getattr(self.tmp_file, attrname)\\n\\n def close(self):\\n try:\\n # Close tmp file.\\n self.tmp_file.close()\\n # Determine if different.\\n same = False\\n try:\\n same = filecmp.cmp(self.tmp_path, filename, False)\\n except OSError as e:\\n if e.errno != errno.ENOENT:\\n raise\\n\\n if same:\\n # The new file is identical to the old one, just get rid of the new one.\\n os.unlink(self.tmp_path)\\n else:\\n # The new file is different from the old one, or there is no old one.\\n # Rename the new file to the permanent name.\\n #\\n # tempfile.mkstemp uses an overly restrictive mode, resulting in a\\n # file that can only be read by the owner, regardless of the umask.\\n # There's no reason to not respect the umask here, which means that\\n # an extra hoop is required to fetch it and reset the new file's mode.\\n #\\n # No way to get the umask without setting a new one? Set a safe one\\n # and then set it back to the old value.\\n umask = os.umask(0o77)\\n os.umask(umask)\\n os.chmod(self.tmp_path, 0o666 & ~umask)\\n if sys.platform == 'win32' and os.path.exists(filename):\\n # NOTE: on windows (but not cygwin) rename will not replace an\\n # existing file, so it must be preceded with a remove. Sadly there\\n # is no way to make the switch atomic.\\n os.remove(filename)\\n os.rename(self.tmp_path, filename)\\n except Exception:\\n # Don't leave turds behind.\\n os.unlink(self.tmp_path)\\n raise\\n\\n return Writer()\",\n \"def write_shapefile_combined(self, shpname):\\r\\n self.read_traveltime()\\r\\n \\r\\n westlats1 = []\\r\\n westlons1 = []\\r\\n eastlats1 = []\\r\\n eastlons1 = [] \\r\\n lines1 = []\\r\\n #### points ####\\r\\n lats1 = []\\r\\n lons1 = []\\r\\n for i in range(len(self.westPnts1)):\\r\\n westlat1, westlon1 = utm.to_latlon(self.westPnts1[i,0], self.westPnts1[i,1], 14, 'U')\\r\\n eastlat1, eastlon1 = utm.to_latlon(self.eastPnts1[i,0], self.eastPnts1[i,1], 14, 'U')\\r\\n lines1.append([[westlon1, westlat1], [eastlon1, eastlat1]])\\r\\n westlats1.append(westlat1)\\r\\n westlons1.append(westlon1)\\r\\n eastlats1.append(eastlat1)\\r\\n eastlons1.append(eastlon1)\\r\\n #### points ####\\r\\n lats1.append((westlat1+eastlat1)/2.)\\r\\n lons1.append((westlon1+eastlon1)/2.)\\r\\n \\r\\n \\r\\n \\r\\n \\r\\n \\r\\n westlats5 = []\\r\\n westlons5 = []\\r\\n eastlats5 = []\\r\\n eastlons5 = [] \\r\\n lines5 = []\\r\\n #### points ####\\r\\n lats5 = []\\r\\n lons5 = []\\r\\n for i in range(len(self.westPnts5)):\\r\\n westlat5, westlon5 = utm.to_latlon(self.westPnts5[i,0], self.westPnts5[i,1], 14, 'U')\\r\\n eastlat5, eastlon5 = utm.to_latlon(self.eastPnts5[i,0], self.eastPnts5[i,1], 14, 'U')\\r\\n lines5.append([[westlon5, westlat5], [eastlon5, eastlat5]])\\r\\n westlats5.append(westlat5)\\r\\n westlons5.append(westlon5)\\r\\n eastlats5.append(eastlat5)\\r\\n eastlons5.append(eastlon5)\\r\\n #### points ####\\r\\n lats5.append((westlat5+eastlat5)/2.)\\r\\n lons5.append((westlon5+eastlon5)/2.)\\r\\n \\r\\n \\r\\n Narray_branch1 = len(self.inarrays_branch1)\\r\\n Narray_branch5 = len(self.inarrays_branch5)\\r\\n \\r\\n #### travel time for branch 1\\r\\n Ttime = self.inarrays_branch1[0][:,2]\\r\\n ind0 = np.nonzero(Ttime)[0][0]\\r\\n ind = np.arange(ind0, Ttime.shape[0])\\r\\n \\r\\n\\r\\n branchIDs_branch1 = []\\r\\n SegIDs_branch1 = []\\r\\n lines_branch1 = []\\r\\n westlats_branch1 = []\\r\\n westlons_branch1 = []\\r\\n eastlats_branch1 = []\\r\\n eastlons_branch1 = []\\r\\n lats_branch1 = []\\r\\n lons_branch1 = []\\r\\n Ttimes_branch1 = []\\r\\n Density_branch1 = []\\r\\n Initial_loc_branch1 = []\\r\\n solubility_branch1 = []\\r\\n flow_condition_branch1 = []\\r\\n concentration_branch1 = []\\r\\n water_level_branch1 = []\\r\\n dist_branch1 = []\\r\\n \\r\\n \\r\\n \\r\\n for iarray in range(Narray_branch1):\\r\\n \\r\\n #### find indexes which segment has travel time\\r\\n Ttime_tem = self.inarrays_branch1[iarray][:,2]\\r\\n ind0 = np.nonzero(Ttime_tem)[0][0]\\r\\n ind = np.arange(ind0, Ttime_tem.shape[0])\\r\\n \\r\\n for i in range(self.inarrays_branch1[0].shape[0]):\\r\\n \\r\\n if i in ind:\\r\\n branchIDs_branch1.append(self.inarrays_branch1[iarray][i,0])\\r\\n SegIDs_branch1.append(self.inarrays_branch1[iarray][i,1])\\r\\n lines_branch1.append(lines1[i])\\r\\n westlats_branch1.append(westlats1[i])\\r\\n westlons_branch1.append(westlons1[i])\\r\\n eastlats_branch1.append(eastlats1[i])\\r\\n eastlons_branch1.append(eastlons1[i])\\r\\n lats_branch1.append(lats1[i])\\r\\n lons_branch1.append(lons1[i])\\r\\n \\r\\n Ttimes_branch1.append(self.inarrays_branch1[iarray][i,2])\\r\\n if self.inarrays_branch1[iarray][i,3] == 0:\\r\\n Density_branch1.append('Light')\\r\\n elif self.inarrays_branch1[iarray][i,3] == 1:\\r\\n Density_branch1.append('Heavy')\\r\\n elif self.inarrays_branch1[iarray][i,3] == 9:\\r\\n Density_branch1.append('None')\\r\\n \\r\\n Initial_loc_branch1.append('East')\\r\\n \\r\\n if self.inarrays_branch1[iarray][i,5] == 0:\\r\\n solubility_branch1.append('Insoluble')\\r\\n elif self.inarrays_branch1[iarray][i,5] == 1:\\r\\n solubility_branch1.append('Soluble')\\r\\n \\r\\n if self.inarrays_branch1[iarray][i,6] == 3:\\r\\n #flow_condition_branch1.append('High')\\r\\n flow_condition_branch1.append('> 945 cfs')\\r\\n elif self.inarrays_branch1[iarray][i,6] == 2:\\r\\n #flow_condition_branch1.append('Medium')\\r\\n flow_condition_branch1.append('110 ~ 945 cfs')\\r\\n elif self.inarrays_branch1[iarray][i,6] == 1:\\r\\n #flow_condition_branch1.append('Low')\\r\\n flow_condition_branch1.append('< 110 cfs')\\r\\n \\r\\n if self.inarrays_branch1[iarray][i,7] != 0:\\r\\n concentration_branch1.append(\\\"{:.3E}\\\".format(Decimal(self.inarrays_branch1[iarray][i,7])))\\r\\n else:\\r\\n concentration_branch1.append(str(self.inarrays_branch1[iarray][i,7]))\\r\\n \\r\\n water_level_branch1.append(self.inarrays_branch1[iarray][i,8])\\r\\n dist_branch1.append(self.inarrays_branch1[iarray][i,9])\\r\\n \\r\\n #### travel time for branch 5\\r\\n #Ttime = self.inarrays_particle_branch5[0][:,2]\\r\\n #ind1 = np.arange(43, 45) -1 #### hard coded, for release in branch 5\\r\\n #ind5 = np.nonzero(Ttime)[0]\\r\\n \\r\\n \\r\\n branchIDs_branch5 = []\\r\\n SegIDs_branch5 = []\\r\\n lines_branch5 = []\\r\\n westlats_branch5 = []\\r\\n westlons_branch5 = []\\r\\n eastlats_branch5 = []\\r\\n eastlons_branch5 = []\\r\\n lats_branch5 = []\\r\\n lons_branch5 = []\\r\\n Ttimes_branch5 = []\\r\\n Density_branch5 = []\\r\\n Initial_loc_branch5 = []\\r\\n solubility_branch5 = []\\r\\n flow_condition_branch5 = []\\r\\n concentration_branch5 = []\\r\\n water_level_branch5 = []\\r\\n dist_branch5 = []\\r\\n \\r\\n \\r\\n ## loop over all travel time for each array, find which is in branch 1 and which is in branch 5\\r\\n for iarray in range(Narray_branch5): \\r\\n \\r\\n #### find indexes which segment has travel time\\r\\n Ttime_tem = self.inarrays_branch5[iarray][:,2]\\r\\n \\r\\n nbr5 = len(lines5) ## number of elements in branch 5\\r\\n ind1 = np.arange(43, 45) -1 + nbr5 #### hard coded, for release in branch 5 len(branch5)+ [43,44] - 1\\r\\n ind5 = np.nonzero(Ttime_tem)[0]\\r\\n \\r\\n for i in range(self.inarrays_branch5[0].shape[0]):\\r\\n #if iarray==6 and i == 44:\\r\\n # pdb.set_trace()\\r\\n if self.inarrays_branch5[iarray][i,0] == 5: ## at branch 5\\r\\n \\r\\n if i in ind5:\\r\\n branchIDs_branch5.append(self.inarrays_branch5[iarray][i,0])\\r\\n SegIDs_branch5.append(self.inarrays_branch5[iarray][i,1])\\r\\n lines_branch5.append(lines5[i])\\r\\n westlats_branch5.append(westlats5[i])\\r\\n westlons_branch5.append(westlons5[i])\\r\\n eastlats_branch5.append(eastlats5[i])\\r\\n eastlons_branch5.append(eastlons5[i])\\r\\n lats_branch5.append(lats5[i])\\r\\n lons_branch5.append(lons5[i])\\r\\n \\r\\n Ttimes_branch5.append(self.inarrays_branch5[iarray][i,2])\\r\\n if self.inarrays_branch5[iarray][i,3] == 0:\\r\\n Density_branch5.append('Light')\\r\\n elif self.inarrays_branch5[iarray][i,3] == 1:\\r\\n Density_branch5.append('Heavy')\\r\\n elif self.inarrays_branch5[iarray][i,3] == 9:\\r\\n Density_branch5.append('None')\\r\\n \\r\\n if self.inarrays_branch5[iarray][i,4] == 1:\\r\\n Initial_loc_branch5.append('East')\\r\\n elif self.inarrays_branch5[iarray][i,4] == 5:\\r\\n Initial_loc_branch5.append('West')\\r\\n \\r\\n if self.inarrays_branch5[iarray][i,5] == 0:\\r\\n solubility_branch5.append('Insoluble')\\r\\n elif self.inarrays_branch5[iarray][i,5] == 1:\\r\\n solubility_branch5.append('Soluble')\\r\\n \\r\\n if self.inarrays_branch5[iarray][i,6] == 3:\\r\\n flow_condition_branch5.append('> 945 cfs')\\r\\n elif self.inarrays_branch5[iarray][i,6] == 2:\\r\\n flow_condition_branch5.append('110 ~ 945 cfs')\\r\\n elif self.inarrays_branch5[iarray][i,6] == 1:\\r\\n flow_condition_branch5.append('< 110 cfs')\\r\\n \\r\\n if self.inarrays_branch5[iarray][i,7] != 0:\\r\\n concentration_branch5.append(\\\"{:.3E}\\\".format(Decimal(self.inarrays_branch5[iarray][i,7])))\\r\\n else: \\r\\n concentration_branch5.append(str(self.inarrays_branch5[iarray][i,7]))\\r\\n \\r\\n water_level_branch5.append(self.inarrays_branch5[iarray][i,8])\\r\\n dist_branch5.append(self.inarrays_branch5[iarray][i,9])\\r\\n \\r\\n \\r\\n elif self.inarrays_branch5[iarray][i,0] == 1: ## at branch 1\\r\\n \\r\\n if i in ind1:\\r\\n \\r\\n branchIDs_branch5.append(self.inarrays_branch5[iarray][i,0])\\r\\n SegIDs_branch5.append(self.inarrays_branch5[iarray][i,1])\\r\\n lines_branch5.append(lines1[i-nbr5])\\r\\n westlats_branch5.append(westlats1[i-nbr5])\\r\\n westlons_branch5.append(westlons1[i-nbr5])\\r\\n eastlats_branch5.append(eastlats1[i-nbr5])\\r\\n eastlons_branch5.append(eastlons1[i-nbr5])\\r\\n lats_branch5.append(lats1[i-nbr5])\\r\\n lons_branch5.append(lons1[i-nbr5])\\r\\n \\r\\n Ttimes_branch5.append(self.inarrays_branch5[iarray][i,2])\\r\\n if self.inarrays_branch5[iarray][i,3] == 0:\\r\\n Density_branch5.append('Light')\\r\\n elif self.inarrays_branch5[iarray][i,3] == 1:\\r\\n Density_branch5.append('Heavy')\\r\\n elif self.inarrays_branch5[iarray][i,3] == 9:\\r\\n Density_branch5.append('None')\\r\\n \\r\\n if self.inarrays_branch5[iarray][i,4] == 1:\\r\\n Initial_loc_branch5.append('East')\\r\\n elif self.inarrays_branch5[iarray][i,4] == 5:\\r\\n Initial_loc_branch5.append('West')\\r\\n \\r\\n if self.inarrays_branch5[iarray][i,5] == 0:\\r\\n solubility_branch5.append('Insoluble')\\r\\n elif self.inarrays_branch5[iarray][i,5] == 1:\\r\\n solubility_branch5.append('Soluble')\\r\\n \\r\\n if self.inarrays_branch5[iarray][i,6] == 3:\\r\\n flow_condition_branch5.append('> 945 cfs')\\r\\n elif self.inarrays_branch5[iarray][i,6] == 2:\\r\\n flow_condition_branch5.append('110 ~ 945 cfs')\\r\\n elif self.inarrays_branch5[iarray][i,6] == 1:\\r\\n flow_condition_branch5.append('< 110 cfs')\\r\\n \\r\\n if self.inarrays_branch5[iarray][i,7] != 0:\\r\\n concentration_branch5.append(\\\"{:.3E}\\\".format(Decimal(self.inarrays_branch5[iarray][i,7])))\\r\\n else:\\r\\n concentration_branch5.append(str(self.inarrays_branch5[iarray][i,7]))\\r\\n \\r\\n water_level_branch5.append(self.inarrays_branch5[iarray][i,8])\\r\\n dist_branch5.append(self.inarrays_branch5[iarray][i,9])\\r\\n \\r\\n\\r\\n #### combine all data into one big array\\r\\n branchIDs_combined = branchIDs_branch1 + branchIDs_branch5\\r\\n SegIDs_combined = SegIDs_branch1 + SegIDs_branch5 \\r\\n lines_combined = lines_branch1 + lines_branch5\\r\\n# westlats_combined = westlats_branch1 + westlats_branch5\\r\\n# westlons_combined = westlons_branch1 + westlons_branch5\\r\\n# eastlats_combined = eastlats_branch1 + eastlats_branch5\\r\\n# eastlons_combined = eastlons_branch1 + eastlons_branch5\\r\\n lats_combined = lats_branch1 + lats_branch5\\r\\n lons_combined = lons_branch1 + lons_branch5\\r\\n \\r\\n Ttimes_combined = Ttimes_branch1 + Ttimes_branch5\\r\\n Density_combined = Density_branch1 + Density_branch5\\r\\n Initial_loc_combined = Initial_loc_branch1 + Initial_loc_branch5\\r\\n solubility_combined = solubility_branch1 + solubility_branch5\\r\\n flow_combined = flow_condition_branch1 + flow_condition_branch5\\r\\n concentration_combined = concentration_branch1 + concentration_branch5 \\r\\n water_level_combined = water_level_branch1 + water_level_branch5 \\r\\n dist_combined = dist_branch1 + dist_branch5\\r\\n \\r\\n #### Create the shapefile\\r\\n # Create the projection\\r\\n spatialReference = osgeo.osr.SpatialReference()\\r\\n spatialReference.ImportFromProj4('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')\\r\\n \\r\\n # Create the shape file\\r\\n outfile = r'ArcGIS_online\\\\%s'%shpname\\r\\n driver = osgeo.ogr.GetDriverByName('ESRI Shapefile')\\r\\n shapeData = driver.CreateDataSource(outfile)\\r\\n \\r\\n # Create the layer\\r\\n layer = shapeData.CreateLayer('Contour', spatialReference, osgeo.ogr.wkbPoint)\\r\\n layerDefinition = layer.GetLayerDefn()\\r\\n \\r\\n # Create fields containing segment infos\\r\\n field_def = osgeo.ogr.FieldDefn('BranchID', osgeo.ogr.OFTInteger)\\r\\n layer.CreateField(field_def)\\r\\n \\r\\n field_def = osgeo.ogr.FieldDefn('SegID', osgeo.ogr.OFTInteger)\\r\\n layer.CreateField(field_def)\\r\\n \\r\\n field_def = osgeo.ogr.FieldDefn('Lon', osgeo.ogr.OFTReal)\\r\\n layer.CreateField(field_def)\\r\\n \\r\\n field_def = osgeo.ogr.FieldDefn('Lat', osgeo.ogr.OFTReal)\\r\\n layer.CreateField(field_def)\\r\\n \\r\\n #field_def = osgeo.ogr.FieldDefn('Lon_east', osgeo.ogr.OFTReal)\\r\\n #layer.CreateField(field_def)\\r\\n \\r\\n #field_def = osgeo.ogr.FieldDefn('Lat_east', osgeo.ogr.OFTReal)\\r\\n #layer.CreateField(field_def)\\r\\n \\r\\n field_def = osgeo.ogr.FieldDefn('T (day)', osgeo.ogr.OFTInteger)\\r\\n layer.CreateField(field_def)\\r\\n \\r\\n ## density - type: string, option: light-0, heavey-1 \\r\\n field_def = osgeo.ogr.FieldDefn('Density', osgeo.ogr.OFTString)\\r\\n layer.CreateField(field_def)\\r\\n \\r\\n ## initial release location - type: string, option: East-1, West-5\\r\\n field_def = osgeo.ogr.FieldDefn('Initial', osgeo.ogr.OFTString)\\r\\n layer.CreateField(field_def)\\r\\n \\r\\n ## solubility\\r\\n field_def = osgeo.ogr.FieldDefn('Solubility', osgeo.ogr.OFTString)\\r\\n layer.CreateField(field_def)\\r\\n \\r\\n ## flow condition\\r\\n field_def = osgeo.ogr.FieldDefn('Flow', osgeo.ogr.OFTString)\\r\\n layer.CreateField(field_def)\\r\\n \\r\\n ## concentration\\r\\n field_def = osgeo.ogr.FieldDefn('C (mg/L)', osgeo.ogr.OFTString)\\r\\n layer.CreateField(field_def)\\r\\n \\r\\n ## water surface elevation\\r\\n field_def = osgeo.ogr.FieldDefn('WSE (ft)', osgeo.ogr.OFTReal)\\r\\n layer.CreateField(field_def)\\r\\n \\r\\n ## distance to WTP gate\\r\\n field_def = osgeo.ogr.FieldDefn('D (ft)', osgeo.ogr.OFTReal)\\r\\n layer.CreateField(field_def)\\r\\n \\r\\n \\r\\n def add_feature(layer, branchID, segs, lines, lon, lat, Ttime, density, Initial_loc, solubility, flows, concentration, water_level, dist):\\r\\n \\\"\\\"\\\"\\r\\n function that adds feature to layer\\r\\n \\\"\\\"\\\" \\r\\n ctr=0\\r\\n for i in range(len(lines)):\\r\\n ctr+=1\\r\\n point = osgeo.ogr.Geometry(osgeo.ogr.wkbPoint)\\r\\n # Add points individually to the line\\r\\n #xy = lines[i]\\r\\n \\r\\n #line.AddPoint_2D(xy[0][0],xy[0][1])\\r\\n #line.AddPoint_2D(xy[1][0],xy[1][1])\\r\\n point.AddPoint(lon[i], lat[i])\\r\\n # Update the feature with the line data\\r\\n featureIndex = ctr\\r\\n feature = osgeo.ogr.Feature(layerDefinition)\\r\\n #feature.SetStyleString(\\\"PEN(c:r,w:5px)\\\") \\r\\n feature.SetGeometry(point)\\r\\n feature.SetFID(featureIndex)\\r\\n feature.SetGeometryDirectly(point)\\r\\n \\r\\n # Set the attribute table\\r\\n feature.SetField('BranchID', int(branchID[i])) \\r\\n feature.SetField('SegID', int(segs[i])) # convert to int() is necessary, osgeo cannot recognize numpy int32 type\\r\\n feature.SetField('Lon', \\\"{:.3f}\\\".format(lon[i]))\\r\\n feature.SetField('Lat', \\\"{:.3f}\\\".format(lat[i]))\\r\\n #feature.SetField('Lon_east', \\\"{:.3f}\\\".format(eastlon[i]))\\r\\n #feature.SetField('Lat_east', \\\"{:.3f}\\\".format(eastlat[i]))\\r\\n feature.SetField('T (day)', int(Ttime[i]))\\r\\n feature.SetField('Density', density[i])\\r\\n feature.SetField('Initial', Initial_loc[i])\\r\\n feature.SetField('Solubility', solubility[i])\\r\\n feature.SetField('Flow', flows[i])\\r\\n feature.SetField('C (mg/L)', concentration[i])\\r\\n feature.SetField('WSE (ft)', water_level[i])\\r\\n feature.SetField('D (ft)', dist[i])\\r\\n \\r\\n layer.CreateFeature(feature)\\r\\n \\r\\n \\r\\n add_feature(layer, branchIDs_combined, SegIDs_combined, lines_combined, \\\\\\r\\n lons_combined, lats_combined,\\\\\\r\\n Ttimes_combined, Density_combined, Initial_loc_combined, solubility_combined, \\\\\\r\\n flow_combined, concentration_combined, water_level_combined, dist_combined)\",\n \"def fix_name_table(font):\\n modified = False\\n name_records = font_data.get_name_records(font)\\n\\n copyright_data = name_records[0]\\n years = re.findall('20[0-9][0-9]', copyright_data)\\n year = min(years)\\n copyright_data = u'Copyright %s Google Inc. All Rights Reserved.' % year\\n\\n if copyright_data != name_records[0]:\\n print('Updated copyright message to \\\"%s\\\"' % copyright_data)\\n font_data.set_name_record(font, 0, copyright_data)\\n modified = True\\n\\n for name_id in [1, 3, 4, 6]:\\n record = name_records[name_id]\\n for source in NAME_CORRECTIONS:\\n if source in record:\\n oldrecord = record\\n record = record.replace(source, NAME_CORRECTIONS[source])\\n break\\n if record != name_records[name_id]:\\n font_data.set_name_record(font, name_id, record)\\n print('Updated name table record #%d from \\\"%s\\\" to \\\"%s\\\"' % (\\n name_id, oldrecord, record))\\n modified = True\\n\\n trademark_names = ['Noto', 'Arimo', 'Tinos', 'Cousine']\\n trademark_name = None\\n font_family = name_records[1]\\n for name in trademark_names:\\n if font_family.find(name) != -1:\\n trademark_name = name\\n break\\n if not trademark_name:\\n print('no trademarked name in \\\\'%s\\\\'' % font_family)\\n else:\\n trademark_line = TRADEMARK_TEMPLATE % trademark_name\\n if name_records[7] != trademark_line:\\n old_line = name_records[7]\\n font_data.set_name_record(font, 7, trademark_line)\\n modified = True\\n print('Updated name table record 7 from \\\"%s\\\" to \\\"%s\\\"' % (old_line, trademark_line))\\n\\n if name_records[11] != NOTO_URL:\\n font_data.set_name_record(font, 11, NOTO_URL)\\n modified = True\\n print('Updated name table record 11 to \\\"%s\\\"' % NOTO_URL)\\n\\n if name_records[_LICENSE_ID] != _SIL_LICENSE:\\n font_data.set_name_record(font, _LICENSE_ID, _SIL_LICENSE)\\n modified = True\\n print('Updated license id')\\n\\n if name_records[_LICENSE_URL_ID] != _SIL_LICENSE_URL:\\n font_data.set_name_record(font, _LICENSE_URL_ID, _SIL_LICENSE_URL)\\n modified = True\\n print('Updated license url')\\n\\n # TODO: check preferred family/subfamily(16&17)\\n\\n return modified\",\n \"def crudo_rename(fecha):\\n os.rename(\\\"/var/lib/reportes-zabbix/crudos/Merged-Trends-{}.pickle\\\".format(datetime.today().date()),\\\"/var/lib/reportes-zabbix/crudos/Merged-Trends-{}.pickle\\\".format(fecha))\\n os.rename(\\\"/var/lib/reportes-zabbix/crudos/Merged-Trends-{}_ONT.pickle\\\".format(datetime.today().date()),\\\"/var/lib/reportes-zabbix/crudos/Merged-Trends-{}_ONT.pickle\\\".format(fecha))\",\n \"def WriteStructuralMaterialsjson(save_path,dic_in_json_format):\\n complete_name=os.path.join(save_path,\\\"StructuralMaterials.json\\\") \\n with open(complete_name, \\\"w\\\") as save_file:\\n save_file.write(dic_in_json_format)\\n if(DEBUG):\\n print(\\\"StructuralMaterials.json written\\\")\",\n \"def autorename_shots(context):\\n\\n for index, shot in enumerate(context.scene.milkshake_shots):\\n shot.code = f\\\"SH{index + 1 :02}\\\"\\n shot.camera.name = f\\\"{shot.code}.CAMX.000\\\"\\n for obj in bpy.data.objects:\\n if obj.data == shot.camera:\\n obj.name = shot.camera.name\\n break\\n core.log(f\\\"Renamed shot {shot.code} and camera {shot.camera.name}.\\\")\",\n \"def rename_bones(s='', t='unreal'):\\r\\n unreal = {\\r\\n 'root': 'Root',\\r\\n 'Hips': 'Pelvis',\\r\\n 'Spine': 'spine_01',\\r\\n 'Spine1': 'spine_02',\\r\\n 'Spine2': 'spine_03',\\r\\n 'LeftShoulder': 'clavicle_l',\\r\\n 'LeftArm': 'upperarm_l',\\r\\n 'LeftForeArm': 'lowerarm_l',\\r\\n 'LeftHand': 'hand_l',\\r\\n 'RightShoulder': 'clavicle_r',\\r\\n 'RightArm': 'upperarm_r',\\r\\n 'RightForeArm': 'lowerarm_r',\\r\\n 'RightHand': 'hand_r',\\r\\n 'Neck1': 'neck_01',\\r\\n 'Neck': 'neck_01',\\r\\n 'Head': 'head',\\r\\n 'LeftUpLeg': 'thigh_l',\\r\\n 'LeftLeg': 'calf_l',\\r\\n 'LeftFoot': 'foot_l',\\r\\n 'RightUpLeg': 'thigh_r',\\r\\n 'RightLeg': 'calf_r',\\r\\n 'RightFoot': 'foot_r',\\r\\n 'LeftHandIndex1': 'index_01_l',\\r\\n 'LeftHandIndex2': 'index_02_l',\\r\\n 'LeftHandIndex3': 'index_03_l',\\r\\n 'LeftHandMiddle1': 'middle_01_l',\\r\\n 'LeftHandMiddle2': 'middle_02_l',\\r\\n 'LeftHandMiddle3': 'middle_03_l',\\r\\n 'LeftHandPinky1': 'pinky_01_l',\\r\\n 'LeftHandPinky2': 'pinky_02_l',\\r\\n 'LeftHandPinky3': 'pinky_03_l',\\r\\n 'LeftHandRing1': 'ring_01_l',\\r\\n 'LeftHandRing2': 'ring_02_l',\\r\\n 'LeftHandRing3': 'ring_03_l',\\r\\n 'LeftHandThumb1': 'thumb_01_l',\\r\\n 'LeftHandThumb2': 'thumb_02_l',\\r\\n 'LeftHandThumb3': 'thumb_03_l',\\r\\n 'RightHandIndex1': 'index_01_r',\\r\\n 'RightHandIndex2': 'index_02_r',\\r\\n 'RightHandIndex3': 'index_03_r',\\r\\n 'RightHandMiddle1': 'middle_01_r',\\r\\n 'RightHandMiddle2': 'middle_02_r',\\r\\n 'RightHandMiddle3': 'middle_03_r',\\r\\n 'RightHandPinky1': 'pinky_01_r',\\r\\n 'RightHandPinky2': 'pinky_02_r',\\r\\n 'RightHandPinky3': 'pinky_03_r',\\r\\n 'RightHandRing1': 'ring_01_r',\\r\\n 'RightHandRing2': 'ring_02_r',\\r\\n 'RightHandRing3': 'ring_03_r',\\r\\n 'RightHandThumb1': 'thumb_01_r',\\r\\n 'RightHandThumb2': 'thumb_02_r',\\r\\n 'RightHandThumb3': 'thumb_03_r',\\r\\n 'LeftToeBase': 'ball_l',\\r\\n 'RightToeBase': 'ball_r'\\r\\n }\\r\\n schema = {'unreal': unreal }\\r\\n if type(s) == str:\\r\\n i = schema[t].get(s)\\r\\n if i:\\r\\n return i\\r\\n else:\\r\\n log.warning('WARNING %s bone is missing', s)\\r\\n return s\\r\\n elif type(s) == Object:\\r\\n if s.type == 'ARMATURE':\\r\\n for bone in s.data.bones:\\r\\n bone.name = rename_bones(remove_namespace(bone.name))\\r\\n s.name = rename_bones(s.name)\\r\\n return 1\\r\\n return -1\",\n \"def updateHeightsTexture(self, gl):\\n\\n if (self.heightsTexture.width() != self.logicalResources.n or \\n self.heightsTexture.height() != self.logicalResources.m):\\n self.heightsTexture.destroy()\\n\\n self.heightsTexture = self.createTexture(gl, self.logicalResources.m, self.logicalResources.n, \\n format=QOpenGLTexture.RG32F, filter=QOpenGLTexture.Nearest)\\n \\n data = []\\n for i in range(self.logicalResources.n):\\n for j in range(self.logicalResources.m):\\n data.extend([ self.logicalResources.landscapeHeightsMatrix[i][j] * ZScale\\n , self.logicalResources.waterHeightsMatrix[i][j] * ZScale])\\n data = struct.pack('{}f'.format(len(data)), *data)\\n\\n self.heightsTexture.setData(QOpenGLTexture.RG, QOpenGLTexture.Float32, data)\",\n \"def add_heights():\\n fac_min = 50\\n fac_max = 40\\n\\n print 'Get lands and oceans'\\n t = time.time()\\n lands, oceans = get_lands_oceans()\\n print 'lands and oceans getted: ', time.time() - t\\n\\n # TODO: create one def with params: mount_level and other for create heights\\n # add default heights\\n for coord in lands:\\n self[coord] = self.config.land_mount_level[1]\\n\\n for coord in oceans:\\n self[coord] = -self.config.mid_mount_level[1]\\n\\n # add low heights for lands\\n count_land = int(round(len(lands) * config.factor_low_mount / 100.))\\n land_coords = []\\n\\n starts = random.randint(count_land / fac_min, count_land / fac_max)\\n for start in xrange(starts):\\n start_coord = lands[random.randint(0, len(lands)-1)]\\n land_coords.append(start_coord)\\n self[start_coord] = random.randint(self.config.low_mount_level[0], self.config.low_mount_level[1])\\n\\n while count_land > 0:\\n # for lands\\n if count_land > 0:\\n dx = random.randint(-1,1)\\n dy = random.randint(-1,1)\\n coord = land_coords[random.randint(0, len(land_coords) - 1)]\\n coord = coord[0] + dx, coord[1] + dy\\n if coord not in land_coords:\\n self[coord] = random.randint(self.config.low_mount_level[0], self.config.low_mount_level[1])\\n land_coords.append(coord)\\n count_land -= 1\\n\\n\\n target_lands = land_coords\\n\\n # -------------------------------------------------------------------------------\\n # add mid heights for lands\\n count_land = int(round(len(target_lands) * (config.factor_mid_mount / 100.)))\\n land_coords = []\\n\\n starts = random.randint(count_land / (fac_min * 3), count_land / (fac_max*3))\\n for start in xrange(starts):\\n start_coord = target_lands[random.randint(0, len(target_lands)-1)]\\n land_coords.append(start_coord)\\n self[start_coord] = random.randint(self.config.mid_mount_level[0],\\n self.config.mid_mount_level[1])\\n\\n if land_coords == []:\\n return\\n\\n while count_land > 0:\\n # for lands\\n if count_land > 0:\\n dx = random.randint(-1,1)\\n dy = random.randint(-1,1)\\n coord = land_coords[random.randint(0, len(land_coords) - 1)]\\n coord = coord[0] + dx, coord[1] + dy\\n #if coord not in land_coords:\\n self[coord] = random.randint(self.config.mid_mount_level[0],\\n self.config.mid_mount_level[1])\\n land_coords.append(coord)\\n count_land -= 1\\n\\n\\n target_lands = land_coords\\n\\n\\n # -------------------------------------------------------------------------------\\n # add high heights for lands\\n count_land = int(round(len(target_lands) * (config.factor_high_mount / 100.)))\\n land_coords = []\\n\\n starts = random.randint(count_land / (fac_min * 4), count_land / (fac_max * 3))\\n for start in xrange(starts):\\n start_coord = target_lands[random.randint(0, len(target_lands)-1)]\\n land_coords.append(start_coord)\\n self[start_coord] = random.randint(self.config.high_mount_level[0],\\n self.config.high_mount_level[1])\\n\\n while count_land > 0:\\n # for lands\\n if count_land > 0:\\n dx = random.randint(-1,1)\\n dy = random.randint(-1,1)\\n try:\\n coord = land_coords[random.randint(0, len(land_coords) - 1)]\\n except ValueError:\\n coord = lands[random.randint(0, len(lands) - 1)]\\n coord = coord[0] + dx, coord[1] + dy\\n #if coord not in land_coords:\\n self[coord] = random.randint(self.config.high_mount_level[0],\\n self.config.high_mount_level[1])\\n land_coords.append(coord)\\n count_land -= 1\",\n \"def add_hydrogens_by_reduce(pdb, pdb_path=None):\\n if pdb_path is None:\\n pdb_path = PDB_PATH\\n # Check if hydrogens were added before\\n if not Path(str(Path(pdb_path) / (pdb + 'h.pdb'))).is_file():\\n print(str(Path(pdb_path) / (pdb + '.pdb')))\\n subprocess.check_output(REDUCE_PATH + \\\\\\n ' -p ' + str(Path(pdb_path) / (pdb + '.pdb')) + \\\\\\n ' > ' + str(Path(pdb_path) / (pdb + 'h.pdb')), shell=True\\n ) # Somehow with list of parameters does't work properly\\n print(f'Added hydrogens to {pdb}.pdb')\\n else:\\n print(f'Were before added hydrogens to {pdb}.pdb')\",\n \"def drename(filepath, namelength = 15):\\n\\tfilepath = os.path.abspath(filepath)\\n\\tif not os.path.isfile(filepath):\\n\\t\\traise ValueError(\\\"The path is not a valid file path: \\\"+str(filepath))\\n\\t\\n\\tpath, name = os.path.split(filepath)\\n\\tname, ext = os.path.splitext(name)\\n\\tos.rename(filepath, os.path.join(path, dname(namelength)+ext)) #We replace name by the random name and reconstruct the path\",\n \"def assumpfile_bad1():\\n afile = tempfile.NamedTemporaryFile(suffix='.json', mode='a', delete=False)\\n bad1_assump_contents = \\\"\\\"\\\"\\n {\\n \\\"consumption\\\": {},\\n \\\"behavior\\\": {\\\"_BE_sub\\\": {\\\"2020\\\": [0.05]}},\\n \\\"growdiff_baseline\\\": {},\\n \\\"growdiff_response\\\": {}\\n }\\n \\\"\\\"\\\"\\n afile.write(bad1_assump_contents)\\n afile.close()\\n # must close and then yield for Windows platform\\n yield afile\\n if os.path.isfile(afile.name):\\n try:\\n os.remove(afile.name)\\n except OSError:\\n pass # sometimes we can't remove a generated temporary file\",\n \"def fix_image_dict(folder, image_dict):\\n image_pattern = os.path.join(LOCAL_IMAGE_PATH, \\\"*.*\\\")\\n for file_path in glob.glob(image_pattern):\\n file_name = os.path.basename(file_path)\\n if file_name not in image_dict:\\n image_dict[file_name] = [replace_underscore(os.path.splitext(file_name)[0])]\",\n \"def trim_long_colnames(cat):\\n import re\\n long_short_pairs = [\\n ('GeneralShapeletPsf', 'GSPsf'),\\n ('DoubleShapelet', 'DS'),\\n ('noSecondDerivative', 'NoSecDer')]\\n for long, short in long_short_pairs:\\n long_re = re.compile(long)\\n for col_name in cat.colnames:\\n if long_re.search(col_name):\\n new_col_name = long_re.sub(short, col_name)\\n cat.rename_column(col_name, new_col_name)\",\n \"def _update_stat_json(self, stat_name):\\n\\n pass\",\n \"def _make_names_unique(animations):\\n counts = {}\\n for a in animations:\\n c = counts.get(a['name'], 0) + 1\\n counts[a['name']] = c\\n if c > 1:\\n a['name'] += '_' + str(c - 1)\\n\\n dupes = set(k for k, v in counts.items() if v > 1)\\n for a in animations:\\n if a['name'] in dupes:\\n a['name'] += '_0'\",\n \"def save_species(filename, destinationfolder='', norm=False):\\n \\n if not os.path.exists(destinationfolder):\\n os.makedirs(destinationfolder)\\n \\n od = os.path.join(destinationfolder, filename) + '_fit'\\n \\n for i in np.arange(0,500,1):\\n d = od + str(i+1)\\n if norm:\\n d = d + '_norm'\\n condition = os.path.exists(d+'_species.svg') or os.path.exists(d+'_species.png')\\n if condition:\\n pass\\n\\t\\t\\t\\n else:\\n plt.savefig(d+'_species.svg', format='svg')\\n print('Saved ' + d + '_species.svg')\\n plt.savefig(d+'_species.png', format='png')\\n print('Saved ' + d + '_species.png')\\n break\",\n \"def combine_sky_spectra(name):\\n sky_list = get_sky_spectra(name)\\n sizes = get(name, 'sizes')\\n scaled = []\\n for spectra in sky_list:\\n scale = sizes[spectra] # scale by the number of pixels arcoss\\n num = zerocount(spectra)\\n sarith('%s/disp/%s.1d' % (name, num), '/', scale,\\n '%s/sky/%s.scaled' % (name, num))\\n scaled.append('%s/sky/%s.scaled' % (name, num))\\n if os.path.isfile('%s/sky.1d' % name):\\n os.remove('%s/sky.1d' % name)\\n scombine(list_convert(scaled), '%s/sky.1d' % name)\",\n \"def rename_weights(traindir, kkey, mon):\\n # First load in the training.csv\\n r = np.genfromtxt(os.path.join(traindir, \\\"training.csv\\\"), delimiter=\\\",\\\", names=True)\\n e = r[\\\"epoch\\\"]\\n q = r[mon]\\n minq = np.min(q)\\n beste = e[np.argmin(q)]\\n\\n newname = \\\"weights.\\\" + str(int(beste)) + \\\"-\\\" + \\\"{:.5f}\\\".format(minq) + \\\".hdf5\\\"\\n\\n os.rename(os.path.join(traindir, kkey), os.path.join(traindir, newname))\",\n \"def create_json(fl, name):\\n obj = json.dumps(fl, indent=4)\\n with open(f\\\"new_json/{name}.json\\\", \\\"w\\\") as outfile:\\n outfile.write(obj)\\n return\",\n \"def create_dictionary_of_old_and_new_paths(raw_dir: Path, bids_dir: Path, exclude_fieldmaps: bool) -> dict:\\n\\n old_and_new_paths = {}\\n old_paths = list(raw_dir.rglob(\\\"*\\\"))\\n print(f\\\"Sorting {len(old_paths)} paths into a dictionary.\\\") \\n\\n def task_name_of(path_to_func_or_json):\\n \\\"\\\"\\\"\\n Returns the task name of a func or json file. This function OVERWRITES the function\\n \\\"task_name_of\\\" that we imported at the top of this script. BUT! It only overwrites it\\n HERE, in \\\"create_dictionary_of_old_and_new_paths\\\".\\n \\\"\\\"\\\"\\n\\n list_of_lines_containing_raw_subject_info = []\\n for path in old_paths:\\n if filetype_of(path) == \\\"subject info\\\":\\n list_of_lines_containing_raw_subject_info = path.read_text().splitlines()\\n break\\n\\n for line in list_of_lines_containing_raw_subject_info:\\n if path_to_func_or_json.stem in line:\\n return line.split(\\\"z\\\")[1]\\n\\n\\n for old_path in old_paths:\\n\\n new_path = old_path\\n\\n if filetype_of(old_path.with_suffix(\\\".nii\\\")) == \\\"anat\\\" and acquisition_number_of(old_path) == \\\"14\\\":\\n new_path = bids_dir / f\\\"sub-{subject_id_of(old_path)}\\\" / \\\"anat\\\" / f\\\"sub-{subject_id_of(old_path)}_T1w{old_path.suffix}\\\"\\n\\n elif filetype_of(old_path.with_suffix(\\\".nii\\\")) == \\\"func\\\" and acquisition_number_of(old_path) != \\\"02\\\":\\n new_path = bids_dir / f\\\"sub-{subject_id_of(old_path)}\\\" / \\\"func\\\" / f\\\"sub-{subject_id_of(old_path)}_task-{task_name_of(old_path)}_acq-{acquisition_number_of(old_path)}_bold{old_path.suffix}\\\"\\n\\n elif filetype_of(old_path.with_suffix(\\\".nii\\\")) == \\\"fieldmap\\\" and not exclude_fieldmaps:\\n old_affix = old_path.stem.split(\\\"_\\\")[-1]\\n new_affix = \\\"phasediff\\\"\\n if old_affix == \\\"e1\\\":\\n new_affix = \\\"magnitude1\\\"\\n if old_affix == \\\"e2\\\":\\n new_affix = \\\"magnitude2\\\"\\n new_path = bids_dir / f\\\"sub-{subject_id_of(old_path)}\\\" / \\\"fmap\\\" / f\\\"sub-{subject_id_of(old_path)}_{new_affix}{old_path.suffix}\\\"\\n\\n old_and_new_paths[old_path] = new_path\\n\\n print(\\\"Paths sorted.\\\")\\n\\n return old_and_new_paths\",\n \"def write_map(self, file_name):\\n\\n if self.pixel == \\\"HEALPIX\\\":\\n hp.fitsfunc.write_map(file_name, self.data, overwrite=True)\\n if self.pixel == \\\"CAR\\\":\\n enmap.write_map(file_name, self.data)\",\n \"def save_new_dataset_by_ids(old_json, ecg_ids_to_save, name_new_dataset):\\n import json\\n from settings import PATH_TO_METADATASETS_FOLDER\\n new_json_data = {}\\n for ecg_id in old_json.keys():\\n if ecg_id in ecg_ids_to_save:\\n new_json_data[ecg_id]= old_json[ecg_id]\\n result_file_path = PATH_TO_METADATASETS_FOLDER + \\\"\\\\\\\\\\\" + name_new_dataset\\n with open(result_file_path, 'w') as outfile:\\n json.dump(new_json_data, outfile)\",\n \"def make_diff(file_before, file_after, file_output_name):\\n if os.path.exists(file_output_name):\\n shutil.rmtree(file_output_name)\\n os.mkdir(file_output_name)\\n psd_diff = diff(file_before, file_after)\\n diff_content = {}\\n for attr in [\\\"header\\\", \\\"layer\\\"]:\\n diff_content[attr] = getattr(psd_diff, attr)\\n with open(os.path.join(file_output_name, \\\"diff.json\\\"), \\\"w\\\") as diff_file:\\n json.dump(diff_content, diff_file, indent=4)\\n saved_files = []\\n for layer_id in psd_diff.layer.keys():\\n if len(psd_diff.layer_image[layer_id]) > 1:\\n output_image = os.path.join(file_output_name, layer_id)\\n psd_diff.layer_image[layer_id][\\\"before\\\"].save(output_image + \\\".before.png\\\")\\n psd_diff.layer_image[layer_id][\\\"after\\\"].save(output_image + \\\".after.png\\\")\\n diff_image_before = Image.new(\\\"RGBA\\\", psd_diff.layer_image[layer_id][\\\"before\\\"].size)\\n diff_image_before_data = diff_image_before.load()\\n diff_image_after = Image.new(\\\"RGBA\\\", psd_diff.layer_image[layer_id][\\\"after\\\"].size)\\n diff_image_after_data = diff_image_after.load()\\n width, height = diff_image_before.size\\n pixel_index = 1\\n for y in xrange(height):\\n for x in xrange(width):\\n if str(pixel_index) in diff_content[\\\"layer\\\"][layer_id][\\\"pixel\\\"]:\\n diff_image_before_data[x, y] = tuple(diff_content[\\\"layer\\\"][layer_id][\\\"pixel\\\"][str(pixel_index)][\\\"before\\\"])\\n diff_image_after_data[x, y] = tuple(diff_content[\\\"layer\\\"][layer_id][\\\"pixel\\\"][str(pixel_index)][\\\"after\\\"])\\n else:\\n diff_image_before_data[x, y] = (0, 0, 0, 0)\\n diff_image_after_data[x, y] = (0, 0, 0, 0)\\n pixel_index += 1\\n diff_image_before.save(output_image + \\\".before.diff.png\\\", \\\"PNG\\\")\\n diff_image_after.save(output_image + \\\".after.diff.png\\\", \\\"PNG\\\")\\n saved_files.append(output_image + \\\".before.png\\\")\\n saved_files.append(output_image + \\\".before.diff.png\\\")\\n saved_files.append(output_image + \\\".after.diff.png\\\")\\n saved_files.append(output_image + \\\".after.png\\\")\\n saved_files.append(file_output_name + \\\"/diff.json\\\")\\n return saved_files\",\n \"def regenerate_json_file():\\n \\n # filepaths used in generating json data...\\n dir_export = f\\\"C:\\\\\\\\Users\\\\\\\\{os.getlogin()}\\\\\\\\Downloads\\\"\\n list_name = 'my-favourite-films.csv'\\n json_output_filename = 'reviews_web_data.json'\\n path_to_rootreducer = f'D:\\\\\\\\Programming-Projects\\\\\\\\nathansteele\\\\\\\\src\\\\\\\\reducers\\\\\\\\RootReducer.js';\\n path_to_json_output = f'D:\\\\\\\\Programming-Projects\\\\\\\\nathansteele\\\\\\\\src\\\\\\\\components\\\\\\\\films\\\\\\\\{json_output_filename}'\\n \\n # 1) find letterboxd zip export...\\n prefix = 'letterboxd'\\n postfix = 'utc.zip'\\n zip_file_name = \\\"\\\"\\n download_folder = sorted(glob.glob(f\\\"{dir_export}/*.zip\\\"), key=os.path.getmtime)\\n download_folder.reverse() # reversing the list means most recent downloads are first in the list...\\n for filepath in download_folder:\\n filename = filepath.split('\\\\\\\\')[-1]\\n if filename.split('-')[0] == prefix and filename.split('-')[-1] == postfix:\\n zip_file_name = filename\\n print(f\\\"Found the zip export! -> {zip_file_name}\\\")\\n break\\n else:\\n continue\\n\\n path_to_zip_file = f\\\"{dir_export}\\\\\\\\{zip_file_name}\\\" # path to zip file we downlodaded from letterboxd...\\n path_to_extracted_zip = f\\\"{dir_export}\\\\\\\\{zip_file_name[:-4]}\\\" # path to extracted zip (which we are about to do)...\\n\\n # 2) extract zip automatically (if not done already)...\\n if os.path.exists(path=path_to_zip_file):\\n if not os.path.exists(path=path_to_extracted_zip):\\n with zipfile.ZipFile(file=path_to_zip_file , mode='r') as z:\\n z.extractall(path_to_extracted_zip)\\n print(f\\\"Extract complete! -> {path_to_extracted_zip}\\\")\\n else:\\n print(f'Zip file already exists... No need to extract again... -> ({path_to_extracted_zip})')\\n else:\\n print(f'Zip file could not be found... -> ({path_to_zip_file})')\\n\\n\\n # local version of letterboxd data list\\n letterboxd_list = []\\n \\n # 3) locate the csv file of interest\\n if os.path.exists(path_to_extracted_zip): \\n # open csv file...\\n path_to_list = f'{path_to_extracted_zip}\\\\\\\\lists\\\\\\\\{list_name}'\\n with open(path_to_list, 'r') as f:\\n # csv reader object\\n csv_reader = csv.reader(f)\\n \\n # skip header in the csv file...\\n rows_to_skip = 5\\n for i in range(0, rows_to_skip):\\n next(csv_reader)\\n \\n # 4) iterate over each row (i.e. each film) in csv file...\\n for csv_row in csv_reader:\\n pos = csv_row[0]\\n title = csv_row[1]\\n year = csv_row[2]\\n letterboxd_url = csv_row[3]\\n letterboxd_film_id = letterboxd_url.split('/')[-1]\\n genres = []\\n directors = []\\n duration = 0\\n language = \\\"\\\"\\n imdb_url = \\\"\\\"\\n imdb_avg_rating = \\\"\\\"\\n imdb_num_votes = \\\"\\\"\\n tmdb_url = \\\"\\\"\\n poster_url = \\\"\\\"\\n \\n # parse data from letterboxd web page... (this takes ~1.21s)\\n page = session.get(url=letterboxd_url, verify=False, stream=True)\\n soup = BeautifulSoup(page.content, 'html.parser')\\n \\n # retrieve list of genres...\\n div_genres = soup.select_one('#tab-genres')\\n for link in div_genres.select('div.text-sluglist a.text-slug[href]'):\\n if 'genre' in link['href']:\\n genre = link.text.capitalize()\\n if genre == 'Science-fiction':\\n genre = 'Sci-fi'\\n genres.append(genre)\\n\\n # retrieve duration\\n textfooter = soup.select_one('section.col-main > p.text-footer').text\\n if 'mins' in textfooter:\\n minstext = textfooter.find('mins', 0, len(textfooter))\\n duration = textfooter[minstext-5:minstext].strip()\\n \\n # retrieve the first spoken language\\n div_details = soup.select_one('#tab-details')\\n for link in div_details.select('div.text-sluglist a.text-slug[href]'):\\n if 'language' in link['href']:\\n language = link.text.capitalize()\\n break\\n \\n # retrieve IMDB url\\n footer = soup.select_one('section.col-main p.text-footer')\\n url_buttons = footer.select('a.micro-button')\\n for url in url_buttons:\\n if 'imdb' in url.text.lower():\\n # get IMDB URL\\n imdb_url = url['href']\\n elif 'tmdb' in url.text.lower():\\n # get TMDB URL\\n tmdb_url = url['href']\\n if len(url_buttons) == 1:\\n # if there's only 1 url_button, it's usually the IMDB link that's missing...\\n if soup.select_one('#featured-film-header > h1').text == 'xxxHOLiC':\\n imdb_url = 'https://www.imdb.com/title/tt16233104/'\\n\\n # retrieve avg rating on letterboxd\\n # page_content_str = page.content.decode('utf-8')\\n # letterboxd_avg_rating = soup.select_one('.average-rating')\\n\\n # Use the OMDB API (https://www.omdbapi.com/) to retrieve some additional data from IMDB website...\\n omdb_api_key = '4af56bed' # apparently this expires after 1000 days (today is 07/02/2023, 1000 days from now is 03/11/2025... holy shit!)\\n imdb_film_id = imdb_url.split('/')[-2]\\n url = f'http://www.omdbapi.com/?i={imdb_film_id}&apikey={omdb_api_key}'\\n imdb = requests.get(url=url, verify=False)\\n imdb_json = json.loads(imdb.text)\\n\\n # retrieve avg IMD rating\\n imdb_avg_rating = imdb_json['imdbRating']\\n \\n # retrieve number of votes on IMDB (we remove the comma, because react is fucking stupid and cant sort numbers when they contain commas)\\n imdb_num_votes = imdb_json['imdbVotes'].replace(',', '')\\n \\n # retrieve poster from IMDB\\n poster_url = imdb_json['Poster']\\n if 'SX300' in poster_url:\\n poster_url = poster_url.split('SX300')[0]\\n \\n # retrieve title from IMDB (because letterboxd parsing is shite!)\\n # title = imdb_json['Title']\\n \\n # retrieve list of directors (because letterboxd parsing is shite!)\\n directors = imdb_json['Director'].split(', ')\\n \\n # id of my review!\\n titlev2 = Helpers.simplify_movie_title(title=title)\\n review_id = f\\\"{titlev2}-{letterboxd_film_id}-review\\\"\\n \\n \\\"\\\"\\\"\\n # iterate over \\\\\\\\img\\\\\\\\films\\\\\\\\\\n screenshots = []\\n directory_in_str = f'D:\\\\\\\\Programming-Projects\\\\\\\\nathansteele\\\\\\\\src\\\\\\\\img\\\\\\\\films';\\n for subdir, dirs, files in os.walk(directory_in_str):\\n for file in files:\\n # find the right directory...\\n title_from_directory_storing_screenshots = subdir.split('\\\\\\\\')[-1]\\n titlev3 = Helpers.simplify_movie_title(title=title_from_directory_storing_screenshots)\\n if titlev3 == titlev2:\\n # get my screenshots...\\n if 'screenshot' in file:\\n screenshot = os.path.join(subdir, file)\\n screenshots.append(screenshot)\\n \\n # use my custom poster if I put one there...\\n if 'custom_poster' in file:\\n poster_url = os.path.join(subdir, file)\\n \\\"\\\"\\\"\\n \\n # DEBUGGING....\\n print(f\\\" > {pos}: {title}\\\")\\n #print(f' > Title = ({title})')\\n #print(f' > IMDB url = ({imdb_url})')\\n #print(f' > Language = ({language})')\\n #print(f' > Duration = ({duration})')\\n #print(f' > Genres = ({genres})')\\n #print(f' > IMDB avg rating = ({imdb_avg_rating})')\\n #print(f' > IMDB num votes = ({imdb_num_votes})')\\n #print(f' > Poster = ({poster_url})')\\n #print(f' > Directors = ({directors})')\\n #print(f' > Tags = ({my_tags})')\\n \\n # append to list...\\n letterboxd_list.append({\\n 'letterboxdFilmId': letterboxd_film_id,\\n 'imdbFilmId': imdb_film_id,\\n 'letterboxdUrl': letterboxd_url,\\n 'imdbUrl': imdb_url,\\n 'posterUrl': poster_url,\\n 'position': pos,\\n 'title': title,\\n 'year': year,\\n 'duration': duration,\\n 'language': language,\\n 'imdbAvgRating': imdb_avg_rating,\\n 'imdbNumVotes': imdb_num_votes,\\n 'tmdbUrl': tmdb_url,\\n 'directors': directors,\\n 'genres': genres,\\n 'reviewId': review_id\\n })\\n \\n # clear json file first...\\n open(path_to_json_output, 'w').close()\\n \\n # write new content...\\n with open(path_to_json_output, 'w') as f:\\n json.dump(letterboxd_list, f, indent=4)\\n \\n print(f'JSON export finished! -> {path_to_json_output}')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.55360186","0.5124106","0.5096552","0.5074441","0.5036425","0.49875963","0.49749434","0.4938649","0.4931775","0.49261597","0.48441556","0.4823751","0.47443646","0.46914992","0.46750745","0.46672103","0.46231896","0.46168032","0.45954028","0.4571667","0.4567506","0.45660365","0.45571652","0.45557263","0.45403972","0.45362985","0.453263","0.45170727","0.45145765","0.45129612","0.45056814","0.4492766","0.44712818","0.44663393","0.44429266","0.44395268","0.44344315","0.44181368","0.4406352","0.4402093","0.44013283","0.43995512","0.4398002","0.43975422","0.43960598","0.43636563","0.43573892","0.4356327","0.435215","0.4350971","0.4339177","0.43153408","0.43112445","0.4308506","0.43084648","0.43007025","0.43003643","0.42991954","0.42916667","0.42913413","0.4291259","0.42861813","0.4284866","0.4282513","0.42641646","0.42581716","0.4243137","0.424246","0.4224862","0.42220128","0.4220747","0.42165256","0.42152563","0.4214045","0.4213127","0.42120424","0.4208068","0.42067754","0.4205185","0.42027426","0.41975385","0.41922858","0.4189225","0.41885808","0.41861388","0.4184298","0.4182811","0.41710836","0.4170815","0.41689998","0.4163296","0.4163047","0.41606575","0.41599038","0.41584238","0.41550684","0.4153881","0.41530693","0.4150777","0.41439062"],"string":"[\n \"0.55360186\",\n \"0.5124106\",\n \"0.5096552\",\n \"0.5074441\",\n \"0.5036425\",\n \"0.49875963\",\n \"0.49749434\",\n \"0.4938649\",\n \"0.4931775\",\n \"0.49261597\",\n \"0.48441556\",\n \"0.4823751\",\n \"0.47443646\",\n \"0.46914992\",\n \"0.46750745\",\n \"0.46672103\",\n \"0.46231896\",\n \"0.46168032\",\n \"0.45954028\",\n \"0.4571667\",\n \"0.4567506\",\n \"0.45660365\",\n \"0.45571652\",\n \"0.45557263\",\n \"0.45403972\",\n \"0.45362985\",\n \"0.453263\",\n \"0.45170727\",\n \"0.45145765\",\n \"0.45129612\",\n \"0.45056814\",\n \"0.4492766\",\n \"0.44712818\",\n \"0.44663393\",\n \"0.44429266\",\n \"0.44395268\",\n \"0.44344315\",\n \"0.44181368\",\n \"0.4406352\",\n \"0.4402093\",\n \"0.44013283\",\n \"0.43995512\",\n \"0.4398002\",\n \"0.43975422\",\n \"0.43960598\",\n \"0.43636563\",\n \"0.43573892\",\n \"0.4356327\",\n \"0.435215\",\n \"0.4350971\",\n \"0.4339177\",\n \"0.43153408\",\n \"0.43112445\",\n \"0.4308506\",\n \"0.43084648\",\n \"0.43007025\",\n \"0.43003643\",\n \"0.42991954\",\n \"0.42916667\",\n \"0.42913413\",\n \"0.4291259\",\n \"0.42861813\",\n \"0.4284866\",\n \"0.4282513\",\n \"0.42641646\",\n \"0.42581716\",\n \"0.4243137\",\n \"0.424246\",\n \"0.4224862\",\n \"0.42220128\",\n \"0.4220747\",\n \"0.42165256\",\n \"0.42152563\",\n \"0.4214045\",\n \"0.4213127\",\n \"0.42120424\",\n \"0.4208068\",\n \"0.42067754\",\n \"0.4205185\",\n \"0.42027426\",\n \"0.41975385\",\n \"0.41922858\",\n \"0.4189225\",\n \"0.41885808\",\n \"0.41861388\",\n \"0.4184298\",\n \"0.4182811\",\n \"0.41710836\",\n \"0.4170815\",\n \"0.41689998\",\n \"0.4163296\",\n \"0.4163047\",\n \"0.41606575\",\n \"0.41599038\",\n \"0.41584238\",\n \"0.41550684\",\n \"0.4153881\",\n \"0.41530693\",\n \"0.4150777\",\n \"0.41439062\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5183655"},"document_rank":{"kind":"string","value":"1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":931,"numItemsPerPage":100,"numTotalItems":95772,"offset":93100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTU1OTU0MCwianRpIjoiN2QxYzYwNTAtMDNkOC00YmVkLWFkZGYtOWRkNjJhNmFiZmMxIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU1NjMxNDAsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.qoW-KRRhjwF_kqUFqn2kmnlBxYIq8M7ik1uya4qtWnNNKFI7-qhIqYLkwQXH2iiRo5-iJOyUglpMEzQ_H0dCDA","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 |
|---|---|---|---|---|---|---|
1 convolution from f {l1}{r1} 2 transposed convolution from f {l} {k} 3 convolution the one to be summed with result of f {l}{k} (2) convolution 4 convolution the one to be producted with result of f {l}{k} (2) convolution | def __init__(self,
in_channels_1, in_channels_2, out_channels,
kernel_size_1, kernel_size_2,
stride_1, up_stride_2,
padding_1, up_padding_2, output_padding=0,
activation_in='relu', activation_out='lrelu',
norm_in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convolve_one_image(self,input4D, one_image, image_shape, \n Pstruct, filter_shape,\n image_index,\n channel_index): \n \n \n ## We look at the composition for the first channel in the beginning \n ... | [
"0.65440655",
"0.63747793",
"0.6343745",
"0.6302786",
"0.62567025",
"0.6233646",
"0.61736387",
"0.61276245",
"0.6091118",
"0.60858166",
"0.60557085",
"0.60371697",
"0.6027836",
"0.60214156",
"0.6019738",
"0.6014391",
"0.59943557",
"0.598205",
"0.59798104",
"0.5973679",
"0.595... | 0.0 | -1 |
Return the contents of file f_relative_path as a string, or a list of strings if read_lines is True. | def read(f_relative_path: str) -> str:
here = path.dirname(path.abspath(__file__))
with io.open(path.join(here, f_relative_path), mode="rt", encoding="utf8") as f:
return f.read() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_txt_file(relative_path_to_txt_file: str):\n with open(file=relative_path_to_txt_file) as f:\n lines = f.read()\n return lines",
"def read(rel_path):\n here = os.path.abspath(os.path.dirname(__file__))\n with open(os.path.join(here, rel_path), \"r\") as fp:\n return ... | [
"0.70846015",
"0.6535189",
"0.6128279",
"0.6120097",
"0.60881114",
"0.60569876",
"0.60376364",
"0.60376364",
"0.6030412",
"0.6026531",
"0.60046923",
"0.5990986",
"0.59522074",
"0.5950833",
"0.5945287",
"0.5945108",
"0.59425455",
"0.5916451",
"0.5888799",
"0.58768487",
"0.5855... | 0.7501114 | 0 |
Return the package version as defined in kx_core/__init__.py. | def get_version() -> str:
version = read("pdf_utils/__version__.py")
return re.search(r"__version__ = \"(.*?)\"", version).group(1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_package_version():\n major, minor, micro, patch, tag, relnum = __version_info__\n\n version = '%s.%s' % (major, minor)\n\n if micro or patch:\n version += '.%s' % micro\n\n if patch:\n version += '.%s' % patch\n\n if tag != 'final':\n version += '%s%s' % (\n ... | [
"0.78866553",
"0.7815516",
"0.7810721",
"0.77791893",
"0.7775338",
"0.7742583",
"0.77370197",
"0.7723235",
"0.772063",
"0.772063",
"0.772063",
"0.7707923",
"0.76899326",
"0.7682685",
"0.7641668",
"0.7622068",
"0.7620161",
"0.7611079",
"0.7575101",
"0.7563609",
"0.75628847",
... | 0.71431565 | 62 |
Run model prediction on image | def predict(model, img, target_size):
if img.size != target_size:
img = img.resize(target_size)
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
return preds[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(model, img):\n\tx = image.img_to_array(img)\n\tx = np.expand_dims(x, axis=0)\n\tx = preprocess_input(x)\n\tpreds = model.predict(x)\n\treturn preds[0]",
"def singlePrediction(self,img):\n self.optimizer = SGD(lr = 0,momentum=0,decay = 0)\n self.createModel()\n output = self.model... | [
"0.8034563",
"0.78639364",
"0.78413767",
"0.78063333",
"0.77723986",
"0.77677476",
"0.7742839",
"0.7671268",
"0.7654957",
"0.76024014",
"0.7555368",
"0.7520583",
"0.7502367",
"0.7493451",
"0.7483869",
"0.7474726",
"0.7407818",
"0.74024296",
"0.7376098",
"0.73710203",
"0.72536... | 0.75804126 | 11 |
Displays image and the topn predicted probabilities in a bar graph | def plot_preds(image, preds):
plt.imshow(image)
plt.axis('off')
plt.figure()
"""labels = ("BEANS", "CAKE","CANDY","CEREAL","CHIPS",
"CHOCOLATE", "COFFEE", "CORN", "FISH", "FLOUR",
"HONEY", "JAM", "JUICE", "MILK", "NUTS","OIL","PASTA",
"RICE", "SODA", "SPICES", "SUGAR", "TEA"... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_preds(image, preds): \r\n #image\r\n plt.imshow(image)\r\n plt.axis('off')\r\n \r\n #bar graph\r\n plt.figure() \r\n order = list(reversed(range(len(preds)))) \r\n bar_preds = [pr[2] for pr in preds]\r\n labels = (pr[1] for pr in preds)\r\n plt.barh(order, bar_preds, alpha=0.5)\r\n plt.ytick... | [
"0.7922684",
"0.77978665",
"0.7721485",
"0.769006",
"0.76070917",
"0.71370405",
"0.70984143",
"0.7009505",
"0.68326867",
"0.6766593",
"0.6606671",
"0.6594294",
"0.6510035",
"0.64082754",
"0.63103276",
"0.63035893",
"0.62614477",
"0.6234734",
"0.6204136",
"0.62028116",
"0.6188... | 0.7603528 | 5 |
dynamic programmin + memoryless > status machine | def minSwap(self, A: List[int], B: List[int]) -> int:
n = len(A)
# x, s: num of swaps if A[i], B[i] stay at place, swap with each other.
x0, s0 = 0, 1
for i in range(1, n):
x1 = s1 = float('inf')
if A[i] > A[i - 1] and B[i] > B[i - 1]:
x1, s1 = min(x1, x0), min(s1, s0 + 1)
if ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def min_system_resources(node):\n\n min_sys_res = True\n\n # CPUs\n if \"layout\" in node[\"cpu\"]:\n total_cpus = len(node[\"cpu\"][\"layout\"])\n if total_cpus < 2:\n print(\n \"\\nThere is only {} CPU(s) available on this system. \"\n ... | [
"0.6102139",
"0.6019507",
"0.58828735",
"0.58289593",
"0.5748978",
"0.5737699",
"0.57305235",
"0.56923175",
"0.56910443",
"0.56457454",
"0.55919945",
"0.5578943",
"0.55744416",
"0.55678797",
"0.5566923",
"0.5564943",
"0.5564556",
"0.5538612",
"0.55296224",
"0.5498537",
"0.549... | 0.0 | -1 |
Place this in a function to avoid circular imports | def get_user_model():
try:
from django.contrib.auth import get_user_model
User = get_user_model()
except ImportError:
from django.contrib.auth.models import User
return User | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _to_be_wrapped(self) -> None:",
"def __call__( self ):\n pass",
"def __call__(self) -> None:",
"def __call__(self):\n\t\treturn",
"def __call__(self):\n pass",
"def __call__(self):\n pass",
"def use(self):",
"def __call__(self):\n raise NotImplementedError",
"def __c... | [
"0.66183394",
"0.65979433",
"0.6568104",
"0.65579677",
"0.6547573",
"0.6547573",
"0.64392775",
"0.6418379",
"0.6324917",
"0.6324917",
"0.6324917",
"0.6324917",
"0.6324917",
"0.6271522",
"0.6164478",
"0.6067886",
"0.60657114",
"0.60547066",
"0.59856945",
"0.59455687",
"0.59242... | 0.0 | -1 |
callback function for the 'min,max' entry | def on_entry():
try: # try to parse the entry string as a couple of integer values
minvalue, maxvalue = win.entry.state.split(',')
minvalue, maxvalue = int(minvalue), int(maxvalue)
win.min, win.max = min(minvalue, maxvalue), max(minvalue, maxvalue)
except Exception:
pass # keep previous values... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def minmin_maxmax( *args ):\n rmin = min( [ mv.min() for mv in args ] )\n rmax = max( [ mv.max() for mv in args ] )\n rmv = cdms2.createVariable( [rmin,rmax] )\n return rmv",
"def min_max(my_list):\n print(\"Min = \",min(my_list,key = abs))\n print(\"Max = \",max(my_list,key = abs))",
"def __... | [
"0.7155907",
"0.68623936",
"0.658245",
"0.658245",
"0.6571199",
"0.6566627",
"0.65426695",
"0.65389234",
"0.65389234",
"0.65389234",
"0.65389234",
"0.65244204",
"0.64892435",
"0.6459422",
"0.64441377",
"0.643262",
"0.6422386",
"0.64124906",
"0.6403266",
"0.6400628",
"0.637073... | 0.6654227 | 2 |
callback function for the 'RANDOM' button | def on_random():
on_entry() # reparse the entry string as user may forget to hit 'ENTER'
minvalue, maxvalue, size = win.min, win.max, len(win.box)
values = ["%2s" % randrange(minvalue,maxvalue+1) for loop in range(size+1)]
win.box.append(' '.join(values)) # append new values as a single line
#win.box(' '... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def OnButton(self, event):\n chicloVrach = random.randint(123, 130)\n\n print('chislo',chicloVrach )\n self.Glavnaja()",
"def _random_function(self, random_state):\n return random_state.rand",
"def getRandom(self) -> int:",
"def getRandom(self) -> int:",
"def sample_action(self,... | [
"0.6767691",
"0.65743977",
"0.6498399",
"0.6498399",
"0.6495831",
"0.6441599",
"0.6363457",
"0.6363457",
"0.63090175",
"0.62606764",
"0.62202805",
"0.62098545",
"0.6183875",
"0.61090285",
"0.6106403",
"0.6105227",
"0.6073028",
"0.60634625",
"0.6058298",
"0.6045589",
"0.604384... | 0.61859345 | 12 |
callback function for the 'DELETE' button | def on_delete():
del win.box[-1] # delete last line
#del win.box[0:-1] # delete all lines
| {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_callback(self):\n pass",
"def delete():\n click.echo('delete was called.')",
"def delete(self, *args, **kwargs):\n return 0",
"def delete(self):\n ...",
"def delete(self, *args, **kwargs):\n pass",
"def delete(self, *args, **kwargs):\n pass",
"de... | [
"0.7944691",
"0.78292483",
"0.746378",
"0.7459333",
"0.7426043",
"0.7426043",
"0.74164665",
"0.7381844",
"0.7363654",
"0.7208855",
"0.71957994",
"0.71466476",
"0.713544",
"0.7100271",
"0.70068383",
"0.69945234",
"0.69591475",
"0.6939772",
"0.688547",
"0.68721384",
"0.68721384... | 0.0 | -1 |
create the main window and pack the widgets | def main(minvalue=0, maxvalue=99):
global win
win = Win(title='RANDOM', op=5)
# ----------------------------------------------------------------------------
frame1 = Frame(win, border=1, op=5, grow=False)
Label(frame1, text='Enter min,max :', grow=False)
Entry(frame1, width=10, command=on_entry)
fr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createWidgets(self):\r\n top = self.winfo_toplevel()\r\n top.rowconfigure(0, weight=1)\r\n top.columnconfigure(0, weight=1)\r\n self.rowconfigure(0, weight=1)\r\n self.columnconfigure(0, weight=1) \r\n\r\n self.button_quit = tk.Button(self, text='Quit', command=self.qu... | [
"0.7809217",
"0.7317288",
"0.72833616",
"0.7258088",
"0.7197436",
"0.7180559",
"0.71751744",
"0.71621305",
"0.7132849",
"0.7054788",
"0.704204",
"0.7019027",
"0.69854087",
"0.6966003",
"0.69308066",
"0.6913024",
"0.68897957",
"0.6888335",
"0.6886561",
"0.685545",
"0.6836567",... | 0.0 | -1 |
Yield job postings in common schema format | def postings(self, quarter, stats_counter=None):
logging.info('Finding postings for %s', quarter)
for posting in self._iter_postings(quarter):
transformed = self._transform(posting)
transformed['id'] = '{}_{}'.format(
self.partner_id,
self._id(post... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_schedd_jobs(schedd_classad=None, job_attrs=JOB_ATTRS.keys()):\n job_records = []\n schedd = htcondor.Schedd(schedd_classad)\n timezone = pytz.timezone(get_timezone())\n current_time = timezone.localize(datetime.datetime.now())\n jobs = schedd.query(\"True\", job_attrs)\n for job in jobs:\... | [
"0.63377845",
"0.59094715",
"0.5628101",
"0.5623778",
"0.5564661",
"0.5475286",
"0.54702526",
"0.5438533",
"0.5423452",
"0.54123676",
"0.54086095",
"0.5400352",
"0.5397553",
"0.53925645",
"0.5333178",
"0.5325623",
"0.5307127",
"0.530603",
"0.5302847",
"0.52863455",
"0.5273875... | 0.50936055 | 55 |
Given a document, compute a sourcespecific id for the job posting. To be implemented by subclasses | def _id(self, document):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resourceDocumentId(self, resource: Resource) -> str:",
"def getDocumentId(self): #$NON-NLS-1$\r",
"def doc_id(self):\n return self._id",
"def get_doc_id(self):\n return self.__doc_id",
"def source_id(self) -> str:\n return self._source_id",
"def source_id(self) -> str:\n r... | [
"0.6282072",
"0.60269284",
"0.5852061",
"0.5735901",
"0.5694973",
"0.5694973",
"0.5641792",
"0.5626624",
"0.562359",
"0.56151587",
"0.56097937",
"0.55504596",
"0.5522015",
"0.5411822",
"0.5347779",
"0.5347779",
"0.5342647",
"0.5319721",
"0.5319721",
"0.52834874",
"0.52826506"... | 0.694908 | 0 |
Given a quarter, yield all relevant raw job posting documents. To be implemented by subclasses | def _iter_postings(self, quarter):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def postings(self, quarter, stats_counter=None):\n logging.info('Finding postings for %s', quarter)\n for posting in self._iter_postings(quarter):\n transformed = self._transform(posting)\n transformed['id'] = '{}_{}'.format(\n self.partner_id,\n se... | [
"0.73558885",
"0.51440305",
"0.5119742",
"0.49251112",
"0.48970717",
"0.48621002",
"0.48428088",
"0.47837812",
"0.4715076",
"0.47008112",
"0.4682589",
"0.46730265",
"0.46716323",
"0.46703556",
"0.46643853",
"0.4660238",
"0.4606574",
"0.46021757",
"0.45960665",
"0.45927292",
"... | 0.72257715 | 1 |
Given a job posting document, transform it into the common schema. | def _transform(self, document):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess_post(self, post):\n # tokenize, clean, & tag part-of-speech for all words\n if self.document_level == 'postwise':\n\n doc_text = all_comments_from_post(post)\n # leave early if there's nothing there\n if doc_text == '':\n return []\n\n ... | [
"0.53246874",
"0.5321279",
"0.53042996",
"0.5169809",
"0.50002706",
"0.49604833",
"0.49088973",
"0.48935318",
"0.48701125",
"0.4867622",
"0.48573858",
"0.4856788",
"0.4853556",
"0.4847017",
"0.48415366",
"0.4838086",
"0.47773227",
"0.47739896",
"0.47737083",
"0.47646734",
"0.... | 0.51903456 | 3 |
Look up the numerical gate representation and a proposed 'noisy' name. | def get_modified_noisy_gate(gate_name: str, params: Iterable[ParameterDesignator]) -> Tuple[np.ndarray, str]:
params = tuple(params)
if gate_name == "I":
assert params == ()
return np.eye(2), "NOISY-I"
if gate_name == "RX":
angle, = params
if np.isclose(angle, np.pi / 2, atol... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_nonphylogenetic_metric(name):\r\n # looks for name, inserting possible dist_ to find functions\r\n # in distance_transform.py named e.g.:\r\n # binary_dist_chisq / dist_bray_curtis\r\n try:\r\n return getattr(distance_transform, 'dist_' + name.lower())\r\n except AttributeError:\r\n ... | [
"0.6031811",
"0.6019712",
"0.5505304",
"0.5480643",
"0.5449328",
"0.53937733",
"0.53687114",
"0.53385764",
"0.5300645",
"0.5300645",
"0.5279134",
"0.52615255",
"0.5232032",
"0.5215277",
"0.51930237",
"0.515612",
"0.51222146",
"0.50935143",
"0.5086529",
"0.5076165",
"0.5069962... | 0.6819791 | 0 |
The default noise parameters T1 = 30 us T2 = 30 us 1q gate time = 50 ns 2q gate time = 150 ns are currently typical for nearterm devices. This function will define new gates and add Kraus noise to these gates. It will translate the input program to use the noisy version of the gates. | def _modified_decoherence_noise_model(
gates: Sequence[Gate],
T1: Union[Dict[int, float], float] = 30e-6,
T2: Union[Dict[int, float], float] = 30e-6,
gate_time_1q: float = 50e-9,
gate_time_2q: float = 150e-09,
ro_fidelity: Union[Dict[int, float], float] = 0.95,
) -> NoiseModel:
all_qubits = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_modified_decoherence_noise(\n prog: \"Program\",\n T1: Union[Dict[int, float], float] = 30e-6,\n T2: Union[Dict[int, float], float] = 30e-6,\n gate_time_1q: float = 50e-9,\n gate_time_2q: float = 150e-09,\n ro_fidelity: Union[Dict[int, float], float] = 0.95,\n) -> \"Program\":\n gates ... | [
"0.6628927",
"0.58579427",
"0.5831026",
"0.56987023",
"0.55713624",
"0.5551751",
"0.5513629",
"0.54612297",
"0.5435982",
"0.53606707",
"0.53522336",
"0.53512543",
"0.5348637",
"0.5332393",
"0.53229153",
"0.52960086",
"0.5282946",
"0.52718014",
"0.52508575",
"0.5249883",
"0.52... | 0.7118521 | 0 |
Generate the header for a pyquil Program that uses ``noise_model`` to overload noisy gates. | def _modified_noise_model_program_header(noise_model: NoiseModel) -> "Program":
from pyquil.quil import Program
p = Program()
defgates: Set[str] = set()
for k in noise_model.gates:
# obtain ideal gate matrix and new, noisy name by looking it up in the NOISY_GATES dict
try:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_model_header(env: jinja2.environment.Environment, model: onnx.ModelProto) -> str:\n header_template = env.get_template(\"model_header.dml.jinja\")\n header_infos = dict()\n\n header_infos[\"ir_version\"] = model.ir_version\n opset_import = list()\n for opset in model.opset_import:\n i... | [
"0.6443",
"0.60880536",
"0.5795828",
"0.56925726",
"0.56897265",
"0.56873477",
"0.5668974",
"0.5653915",
"0.5571958",
"0.5570082",
"0.55554986",
"0.55474067",
"0.55420685",
"0.5530725",
"0.550911",
"0.54856914",
"0.5472454",
"0.5466979",
"0.5424813",
"0.5413869",
"0.54122144"... | 0.79720664 | 0 |
Apply a noise model to a program and generated a 'noisyfied' version of the program. | def apply_modified_noise_model(prog: "Program", noise_model: NoiseModel) -> "Program":
new_prog = _modified_noise_model_program_header(noise_model)
for i in prog:
if isinstance(i, Gate) and noise_model.gates:
try:
_, new_name = get_modified_noisy_gate(i.name, tuple(i.params))... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _modified_noise_model_program_header(noise_model: NoiseModel) -> \"Program\":\n from pyquil.quil import Program\n\n p = Program()\n defgates: Set[str] = set()\n for k in noise_model.gates:\n\n # obtain ideal gate matrix and new, noisy name by looking it up in the NOISY_GATES dict\n tr... | [
"0.71081764",
"0.6942209",
"0.67204815",
"0.65276885",
"0.6525033",
"0.6456866",
"0.63153213",
"0.6242626",
"0.6212918",
"0.61854535",
"0.6173296",
"0.61590374",
"0.6148146",
"0.61058336",
"0.60990524",
"0.6093618",
"0.6059789",
"0.6057936",
"0.6054125",
"0.6036168",
"0.60214... | 0.73493963 | 0 |
Add generic damping and dephasing noise to a program. This highlevel function is provided as a convenience to investigate the effects of a generic noise model on a program. For more finegrained control, please investigate the other methods available in the ``pyquil.noise`` module. In an attempt to closely model the QPU... | def add_modified_decoherence_noise(
prog: "Program",
T1: Union[Dict[int, float], float] = 30e-6,
T2: Union[Dict[int, float], float] = 30e-6,
gate_time_1q: float = 50e-9,
gate_time_2q: float = 150e-09,
ro_fidelity: Union[Dict[int, float], float] = 0.95,
) -> "Program":
gates = _get_program_ga... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _modified_decoherence_noise_model(\n gates: Sequence[Gate],\n T1: Union[Dict[int, float], float] = 30e-6,\n T2: Union[Dict[int, float], float] = 30e-6,\n gate_time_1q: float = 50e-9,\n gate_time_2q: float = 150e-09,\n ro_fidelity: Union[Dict[int, float], float] = 0.95,\n) -> NoiseModel:\n ... | [
"0.6818638",
"0.61347294",
"0.6079218",
"0.58847916",
"0.58088034",
"0.57671183",
"0.5764723",
"0.5756611",
"0.5714665",
"0.5685358",
"0.56427485",
"0.561027",
"0.56034786",
"0.5563276",
"0.5559172",
"0.5557005",
"0.5536149",
"0.5534381",
"0.5500958",
"0.5471309",
"0.54573405... | 0.70419616 | 0 |
Give the zerobased index of first occurrence of object in queryset. Return 1 if not found | def index(queryset, obj):
for index, item in enumerate(queryset):
if item == obj:
return index
return -1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_index(self, obj):\n return self.model.indexlist[obj]",
"def _get_first_occurrence_for(iterable, wanted_object):\n for i, value in enumerate(iterable):\n if value is wanted_object:\n return i",
"def _findIndex(self, x):\n if x< self[0][0] or x> self[-1][0]:\n return ... | [
"0.66508794",
"0.66319877",
"0.6196297",
"0.60581875",
"0.60506517",
"0.60432094",
"0.5979738",
"0.5903687",
"0.5892405",
"0.5842994",
"0.58137876",
"0.5810193",
"0.57849294",
"0.5744563",
"0.57441866",
"0.5736628",
"0.57161486",
"0.56848454",
"0.5655904",
"0.56100047",
"0.56... | 0.77490765 | 0 |
Make all city names lowercase with '_' over ' '. | def clean_city_names(metadata, min_count=3):
metadata = metadata.copy()
metadata['city'] = metadata['city'].apply(lambda el: '_'.join(str(el).lower().split()))
counts = metadata['city'].value_counts()
cities = counts[counts >= min_count].index
metadata = metadata.loc[metadata['city'].isin(cities)]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_city_name(name):\r\n if ', WA' or ',WA' in name:\r\n name = name.rstrip (', WA')\r\n return string.capwords(name)",
"def standardize_name_for_look_up(name: Any) -> str:\n if not isinstance(name, str):\n return name\n\n name = name.lower().strip()\n name = \" \".join(name.s... | [
"0.7799803",
"0.7071588",
"0.6999649",
"0.683",
"0.675845",
"0.66921234",
"0.6659343",
"0.6636172",
"0.66248566",
"0.66193634",
"0.6587236",
"0.65828824",
"0.6553963",
"0.65467453",
"0.6536803",
"0.65269345",
"0.6501677",
"0.6496434",
"0.6496434",
"0.6496434",
"0.647725",
"... | 0.0 | -1 |
Return a pandas dataframe with metadata and MetaSUB ontologies. | def add_ontology(metadata):
metadata = add_surface_ontology(metadata)
metadata = add_place_ontology(metadata)
return metadata | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_pandas(self):\n self.meta = pd.DataFrame(self.meta)\n return",
"def get_reactome_hierarchy_df() -> pd.DataFrame:\n return pd.read_csv(REACTOME_HIERARCHICAL_MAPPINGS_PATH, sep='\\t')",
"def metadata(self) -> dict:\n\n meta = {}\n meta['name'] = self.name\n meta['pote... | [
"0.6497855",
"0.60787183",
"0.6017884",
"0.5992482",
"0.5976122",
"0.59745234",
"0.5965062",
"0.596002",
"0.59586555",
"0.59495765",
"0.5940849",
"0.59402424",
"0.5906102",
"0.5879486",
"0.5869907",
"0.5868608",
"0.58679336",
"0.58338434",
"0.58194155",
"0.58183753",
"0.58117... | 0.0 | -1 |
Return a pandas dataframe with metadata and surface ontologies. | def add_surface_ontology(metadata):
metadata, tbl = metadata.copy(), {}
for val in metadata['surface_material'].unique():
if has_keyword(val, 'glass', 'metal', 'steel', 'copper'):
tbl[val] = ('metal', 'impermeable')
elif has_keyword(val, 'stone', 'marble', 'ceramic', 'concrete', 'cem... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_reactome_hierarchy_df() -> pd.DataFrame:\n return pd.read_csv(REACTOME_HIERARCHICAL_MAPPINGS_PATH, sep='\\t')",
"def construct_data_frame(self) -> pd.DataFrame:\n data_frame = self.base_data_frame[\n [self.name_col, self.description_col]\n ].reset_index()\n data_frame.c... | [
"0.60447127",
"0.6039541",
"0.6001335",
"0.5996675",
"0.5960313",
"0.59217834",
"0.59108263",
"0.58964396",
"0.5884625",
"0.585568",
"0.58455336",
"0.5842718",
"0.58412975",
"0.5839708",
"0.58279854",
"0.5820714",
"0.5808",
"0.5792523",
"0.57793206",
"0.5778404",
"0.5764533",... | 0.55766314 | 42 |
Return a pandas dataframe with metadata and place ontologies. | def add_place_ontology(metadata):
metadata = metadata.copy()
metadata['coastal'] = metadata.apply(coastal, reduce=True, axis=1)
return metadata | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_reactome_hierarchy_df() -> pd.DataFrame:\n return pd.read_csv(REACTOME_HIERARCHICAL_MAPPINGS_PATH, sep='\\t')",
"def df(self) -> \"pandas.DataFrame\":\n titles = []\n comments = []\n alternative_codes = []\n for cat in self.values():\n titles.append(cat.title)\n ... | [
"0.61115766",
"0.6036481",
"0.60349274",
"0.6032239",
"0.5998811",
"0.5992482",
"0.58942795",
"0.58796895",
"0.5872876",
"0.5821394",
"0.57974946",
"0.57712907",
"0.574482",
"0.56860524",
"0.56507355",
"0.56507015",
"0.5649417",
"0.56457484",
"0.5640005",
"0.5638351",
"0.5621... | 0.5587395 | 26 |
Test blending colors together. | def test_merge_colors(self):
for case in self.__class__.SCALES:
with self.subTest(case=case):
self.assertEqual(colors.merge_colors(case[0][0], case[0][1]), case[1]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_blending(self, data, blending_first, blending_second):\n layer = Points(data)\n assert layer.blending == \"translucent\"\n\n layer.blending = blending_first\n assert layer.blending == blending_first\n\n layer = Points(data, blending=blending_first)\n assert layer.... | [
"0.77926445",
"0.65757734",
"0.6558904",
"0.6457233",
"0.6376555",
"0.63488525",
"0.6238908",
"0.6215282",
"0.6200828",
"0.62001896",
"0.6191478",
"0.61771214",
"0.61244303",
"0.61071944",
"0.60679585",
"0.606215",
"0.6010298",
"0.5975439",
"0.5948333",
"0.59447193",
"0.59387... | 0.62966686 | 6 |
Test converting color text codes to integer trios. | def test_color_str_to_trio(self):
for case in self.__class__.TEXTS:
with self.subTest(case=case):
self.assertEqual(colors.color_str_to_trio(case[0]), case[1]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_toInt(self):\r\n self.assertEqual(self.black.toInt(), 0)\r\n self.assertEqual(self.red.toInt(), 16711680)\r\n self.assertEqual(self.pink.toInt(), 6553600)",
"def test_color_trio_to_str(self):\n for case in self.__class__.TRIOS:\n with self.subTest(case=case):\n ... | [
"0.68440133",
"0.668924",
"0.63109994",
"0.6197401",
"0.61614543",
"0.61015356",
"0.6036581",
"0.6017181",
"0.6007153",
"0.5982131",
"0.5978146",
"0.5911295",
"0.58729845",
"0.58344436",
"0.5826692",
"0.5734345",
"0.57341844",
"0.5688235",
"0.56828016",
"0.564937",
"0.5624364... | 0.7008089 | 0 |
Test converting integer trios to color text codes. | def test_color_trio_to_str(self):
for case in self.__class__.TRIOS:
with self.subTest(case=case):
self.assertEqual(colors.color_trio_to_str(case[0]), case[1]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_color_str_to_trio(self):\n for case in self.__class__.TEXTS:\n with self.subTest(case=case):\n self.assertEqual(colors.color_str_to_trio(case[0]), case[1])",
"def test_toInt(self):\r\n self.assertEqual(self.black.toInt(), 0)\r\n self.assertEqual(self.red.to... | [
"0.69274575",
"0.6589749",
"0.63529044",
"0.63369346",
"0.62156",
"0.61823004",
"0.6172301",
"0.61215353",
"0.6078759",
"0.6035878",
"0.6024409",
"0.59644485",
"0.5952612",
"0.59047055",
"0.5881229",
"0.58397704",
"0.58161825",
"0.5805346",
"0.5793865",
"0.5763105",
"0.576165... | 0.69545627 | 0 |
Return random coordinate for an object rounded to accuracy of delta (float). | def RandomCoordinate():
return ReturnRounded(np.random.uniform(-10,10)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __randomize_coord((ref_x, ref_y)):\n radius = numpy.random.normal(scale=DataGen.stdev_distance)\n angle = random.uniform(0, 2 * math.pi)\n rand_x = ref_x + radius * math.cos(angle)\n rand_y = ref_y + radius * math.sin(angle)\n return rand_x, rand_y",
"def randomize_position... | [
"0.6204",
"0.60160416",
"0.59795004",
"0.5935111",
"0.5867318",
"0.5796637",
"0.5642895",
"0.5557663",
"0.5556598",
"0.5540177",
"0.55266476",
"0.55259424",
"0.5512448",
"0.5476977",
"0.54743147",
"0.54636455",
"0.5447325",
"0.54414725",
"0.5432466",
"0.5425684",
"0.5400466",... | 0.69313 | 0 |
Return distance between two 2D points | def CalculateDistance(q1, q2):
return np.sqrt((q1[0] - q2[0])**2 + (q1[1] - q2[1])**2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __get_distance(point1: np.ndarray, point2: np.ndarray) -> float:\n return np.sqrt(np.sum(np.square(point1 - point2)))",
"def distance_between_points(p1,p2):\n return math.sqrt((p2.x-p1.x)**2+(p2.y-p1.y)**2)",
"def distance(p1,p2):\n return ((p1.x - p2.x)**2 + (p1.y - p2.y)**2)**0.5",
"def di... | [
"0.8477306",
"0.8340189",
"0.8255356",
"0.82520866",
"0.8246107",
"0.82405436",
"0.82405436",
"0.8232755",
"0.82311654",
"0.8228505",
"0.8207565",
"0.81974113",
"0.8191894",
"0.8168252",
"0.8168167",
"0.8163704",
"0.81575453",
"0.8154237",
"0.81475264",
"0.81466746",
"0.81378... | 0.0 | -1 |
Return F_att for point q, from finish_point q_k | def AttractionForce(q,q_k):
return k_p*CalculateDistance(q,q_k) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sigma_xx_to_a_to_ff(self, Q, f):\n if f == \"e\":\n mf = me\n # gall = self.gaee\n elif f == \"mu\":\n mf = mmu\n # gall = self.gamumu\n mx = self.mx\n if Q >= 2.0 * mf and Q >= 2.0 * mx:\n # gaxx = self.gaxx\n # ma =... | [
"0.5644244",
"0.53550917",
"0.5309267",
"0.5231378",
"0.5200815",
"0.5191348",
"0.5150725",
"0.4982281",
"0.4951254",
"0.4942593",
"0.4912569",
"0.4855299",
"0.48428315",
"0.4836259",
"0.483546",
"0.48336896",
"0.48231852",
"0.48079002",
"0.47921115",
"0.47866088",
"0.4777043... | 0.6347686 | 0 |
Return repulsion force on point q, from obstacle q_oi | def RepulsionForceFromObstacle(q,q_oi):
d_i = CalculateDistance(q,q_oi) # Distance to the obstacle
if (d_i < d_0): # Point within obstacle influence
F_oi = k_o * (1/d_i - 1/d_0) /d_i**2
if (F_oi > F_rep_MaxValue): # F_rep won't exceed set constant
return F_rep_MaxVal... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def RepulsionForcesInAPoint(q,ObstVector):\r\n F_rep = 0\r\n for q_oi in ObstVector: # For each obstacle...\r\n F_rep += RepulsionForceFromObstacle(q,q_oi) #... add its repulsion to net F_rep\r\n return F_rep",
"def ban_Force(q):\n \n x = q[0]\n y = q[1]\n dx =... | [
"0.67056006",
"0.66570973",
"0.6394435",
"0.6346173",
"0.61297435",
"0.6093138",
"0.6078021",
"0.5982097",
"0.5887824",
"0.58862346",
"0.5841583",
"0.5840448",
"0.5832472",
"0.5810463",
"0.5783585",
"0.57715243",
"0.57642233",
"0.5764123",
"0.5747722",
"0.57469237",
"0.570358... | 0.8176501 | 0 |
Return net repulsion force acting on a point q, based on a list of obstacles ObstVector | def RepulsionForcesInAPoint(q,ObstVector):
F_rep = 0
for q_oi in ObstVector: # For each obstacle...
F_rep += RepulsionForceFromObstacle(q,q_oi) #... add its repulsion to net F_rep
return F_rep | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def RepulsionForceFromObstacle(q,q_oi):\r\n d_i = CalculateDistance(q,q_oi) # Distance to the obstacle\r\n if (d_i < d_0): # Point within obstacle influence\r\n F_oi = k_o * (1/d_i - 1/d_0) /d_i**2 \r\n if (F_oi > F_rep_MaxValue): # F_rep won't exceed set constant\r\n retu... | [
"0.61033577",
"0.59260166",
"0.58975464",
"0.5893999",
"0.58747244",
"0.57450384",
"0.5693517",
"0.55875623",
"0.5544491",
"0.5539944",
"0.55349374",
"0.55225456",
"0.5517202",
"0.5507373",
"0.5500563",
"0.54926264",
"0.54701596",
"0.5453624",
"0.5442819",
"0.5395531",
"0.536... | 0.7295841 | 0 |
Calculate net force on a point q | def ForcesInAPoint(WhichForce, q,q_k,ObstVector):
"""WhichForce determines what kind of forces: F_att "A"; F_rep "R", F_net "N"""
return {
'N': AttractionForce(q,q_k) + RepulsionForcesInAPoint(q, ObstVector),
'A': AttractionForce(q,q_k),
'R': RepulsionForcesInAPoint(q, ObstVector)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ban_Force(q):\n \n x = q[0]\n y = q[1]\n dx = 2*(8*x**3-16*x*y+x-1)\n dy = 16 * (2*y-x**2)\n return np.array([-dx,-dy])",
"def AttractionForce(q,q_k):\r\n return k_p*CalculateDistance(q,q_k)",
"def ForwardDynamics(\n self,\n dt,\n q,\n ... | [
"0.64064276",
"0.6406263",
"0.6079351",
"0.6052035",
"0.6042578",
"0.602331",
"0.59386",
"0.5869529",
"0.5850708",
"0.5833285",
"0.5828675",
"0.5808702",
"0.5802026",
"0.57823694",
"0.5769641",
"0.57633626",
"0.5757132",
"0.574005",
"0.5739287",
"0.573875",
"0.5720081",
"0.... | 0.5354164 | 58 |
returns list of all tracks (need also to read the 'next' for getting ALL tracks) | def readSavedTracks(self)->'list':
scope = 'user-library-read'
self.saved_tracks_list = []
self.sp_data = self.sp_client.Connect(scope)
if self.sp_client.isConnected() == True:
print('We are connected to Spotify!!!!')
try:
tracks_in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_tracks(num=1):\n pass",
"def get_all_tracks():\n query_format = f\"track:\"\n\n search_string_letter_ids = [0]\n\n tracks = {}\n\n total = 0\n\n while search_string_letter_ids is not None:\n search_string = construct_search_string(search_string_letter_ids)\n count = tr... | [
"0.77134794",
"0.7594046",
"0.74213517",
"0.7341831",
"0.7068435",
"0.7040398",
"0.7029339",
"0.67667544",
"0.6711516",
"0.66247386",
"0.6592173",
"0.6532199",
"0.64493704",
"0.642554",
"0.6419652",
"0.63989365",
"0.63813907",
"0.63417333",
"0.63248986",
"0.62960994",
"0.6293... | 0.704814 | 5 |
Function collects information from the specified resources and generates a response page for the collect_info endpoint | async def collect_info(request: web.Request, city="Kiev"):
async with ClientSession() as session:
covid_19_data = await (covid_19("https://covid-19-data.p.rapidapi.com/totals", session))
weather_data = await (weather("https://community-open-weather-map.p.rapidapi.com/weather", session, city=city))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_resources():\n return Response(f\"{Resource.get_all_resources()}\", 200, mimetype='text/plain')",
"def process_resource_listing(self, resources, context):\n pass",
"def process_resource_listing_api(self, resources, listing_api, context):\n pass",
"def print_resources(self) -> None:\n... | [
"0.6543069",
"0.6129639",
"0.6126633",
"0.59852785",
"0.5875669",
"0.5855671",
"0.58320254",
"0.57904845",
"0.57737786",
"0.56922066",
"0.5685085",
"0.56788135",
"0.56689215",
"0.5666231",
"0.5656492",
"0.5648536",
"0.56214523",
"0.56104",
"0.5565291",
"0.55504084",
"0.553617... | 0.56006503 | 18 |
Endpoint processes a post request from the form to get the weather for the specified city | async def city_weather(request: web.Request):
data = await request.post()
current_city = data["city"]
return await collect_info(request, city=current_city) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, city: str):\n # Make a call to the OpenWeatherMap API and check the units inserted at the query parameter.\n units = request.args.get('unit', '').casefold()\n weather_data, query_units = self.get_weather(city, units)\n temp = self.check_unit(query_units)\n\n # Get t... | [
"0.72298294",
"0.67077965",
"0.6676318",
"0.6553933",
"0.6520883",
"0.6472788",
"0.64574057",
"0.6442259",
"0.6378601",
"0.62982494",
"0.62931186",
"0.6264356",
"0.6211222",
"0.6193483",
"0.613255",
"0.61181283",
"0.61084616",
"0.60750145",
"0.60643506",
"0.60150003",
"0.5989... | 0.78677696 | 0 |
Function sends a request to obtain information about the incidence statistics of covid and returns a data dictionary or False | async def covid_19(url, session):
params = {"format": "json"}
headers = {
'x-rapidapi-key': API_KEY,
'x-rapidapi-host': "covid-19-data.p.rapidapi.com"
}
response = await session.get(url, params=params, headers=headers)
if response.status == 200:
covid_19_info = await response... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def covid_fetch():\n #Sets the structure of the data retrieved from the API\n cases_and_deaths = {\n \"date\": \"date\",\n \"areaName\": \"areaName\",\n \"areaCode\": \"areaCode\",\n \"newCasesByPublishDate\": \"newCasesByPublishDate\",\n \"cumCasesByPublishDate\": \"cumCasesByPublishDate\",\n... | [
"0.6947889",
"0.6343356",
"0.6228284",
"0.61825156",
"0.6079988",
"0.600137",
"0.5968241",
"0.58464897",
"0.5826876",
"0.57421815",
"0.5700513",
"0.56654406",
"0.56482095",
"0.56417716",
"0.54925734",
"0.5482195",
"0.54576546",
"0.54522425",
"0.5449562",
"0.54344255",
"0.5378... | 0.6200049 | 3 |
Function sends a request to obtain information about the weather in current city and returns a data dictionary or False | async def weather(url, session, city):
params = {"q": city, "lang": "ru", "units": "metric", "mode": "json"}
headers = {
'x-rapidapi-key': API_KEY,
'x-rapidapi-host': "community-open-weather-map.p.rapidapi.com"
}
response = await session.get(url, params=params, headers=headers)
if re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def city_weather(request: web.Request):\n data = await request.post()\n current_city = data[\"city\"]\n return await collect_info(request, city=current_city)",
"def get(self, city: str):\n # Make a call to the OpenWeatherMap API and check the units inserted at the query parameter.\n ... | [
"0.78325963",
"0.75393945",
"0.73343176",
"0.7309696",
"0.7283628",
"0.7208504",
"0.7185058",
"0.7183764",
"0.7180932",
"0.71728384",
"0.70717156",
"0.7044659",
"0.70226324",
"0.7012848",
"0.69257617",
"0.68630844",
"0.6844851",
"0.68423885",
"0.68418497",
"0.67672926",
"0.67... | 0.7699957 | 1 |
This function creates a partial function for sampling random clients. | def randomly_select_clients_for_round(
population: int, num_of_clients: int, replace: bool = False, seed: int = None
) -> functools.partial:
def select(round_number, seed, replace):
return np.random.RandomState().choice(
population, num_of_clients, replace=replace
)
return func... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_client_dataset_fn(\n dataset: tf.data.Dataset,\n number_of_clients_per_round: int,\n seed: int = None,\n) -> Callable[[], tf.data.Dataset]:\n sample_clients = randomly_select_clients_for_round(\n dataset.client_ids,\n num_of_clients=number_of_clients_per_round,\n replace=Fa... | [
"0.6248188",
"0.57352465",
"0.56887686",
"0.5630404",
"0.5566855",
"0.55375606",
"0.5520642",
"0.5461235",
"0.54593724",
"0.5446919",
"0.54420066",
"0.54274714",
"0.5406328",
"0.5400366",
"0.5398023",
"0.5383204",
"0.53441745",
"0.53429705",
"0.5331215",
"0.5330419",
"0.53158... | 0.6496539 | 0 |
This function generates a function for selecting clientdatasets for each round number. | def get_client_dataset_fn(
dataset: tf.data.Dataset,
number_of_clients_per_round: int,
seed: int = None,
) -> Callable[[], tf.data.Dataset]:
sample_clients = randomly_select_clients_for_round(
dataset.client_ids,
num_of_clients=number_of_clients_per_round,
replace=False,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_client_fn(dataset_partitions):\n\n def client_fn(cid: str) -> fl.client.Client:\n \"\"\"Construct a FlowerClient with its own dataset partition.\"\"\"\n\n # Extract partition for client with id = cid\n x_train, y_train = dataset_partitions[int(cid)]\n # Use 10% of the client'... | [
"0.57062846",
"0.5575745",
"0.54757863",
"0.5445093",
"0.5359454",
"0.5346562",
"0.5344329",
"0.5338417",
"0.5323915",
"0.5321573",
"0.5308771",
"0.52902603",
"0.52606547",
"0.5251963",
"0.5250017",
"0.5224285",
"0.51744944",
"0.51469755",
"0.51442826",
"0.51338434",
"0.51288... | 0.71754587 | 0 |
Converts dataset to tupled dataset. | def _convert_fn(dataset: tf.data.Dataset) -> tf.data.Dataset:
spec = dataset.element_spec
if isinstance(spec, collections.abc.Mapping):
return dataset.map(lambda observation: (observation["x"], observation["y"]))
else:
return dataset.map(lambda x, y: (x, y)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def DatasetToTuple(sample):\n \n X_elem = []\n Y_elem = []\n for x,y in sample:\n X_elem.append(x if x.dim() > 0 else x.item())\n Y_elem.append(y if y.dim() > 0 else y.item()) \n return (torch.stack(X_elem),torch.stack(Y_elem))",
"def DatasetToTuple(sample):\n \n X_ele... | [
"0.6248781",
"0.6248781",
"0.61366004",
"0.56621313",
"0.56125337",
"0.56117225",
"0.56018174",
"0.5594659",
"0.5593983",
"0.55647784",
"0.5509093",
"0.5505307",
"0.54940504",
"0.5486532",
"0.5484437",
"0.5482926",
"0.54735357",
"0.5470663",
"0.5461278",
"0.5420747",
"0.53988... | 0.60262614 | 3 |
This function makes a function for evaluating a model while training. | def get_validation_fn(
test_dataset: tf.data.Dataset,
model_fn: Callable[[], tf.keras.models.Model],
loss_fn: Callable[[], tf.keras.losses.Loss],
metrics_fn: Callable[[], tf.keras.metrics.Metric],
) -> Callable[[], tf.data.Dataset]:
def compiled_model() -> tf.keras.Model:
val_model = model_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_eval(self):\n\n if self.model.__dict__['training']:\n self.model.eval()",
"def _evaluate_during_fit(self, test_loader, epoch):",
"def evaluate(model, optimizer, loss_function, loader, device, labels, log_every_n=10):\n\n model.eval()\n\n batch_wise_true_labels = []\n batch_w... | [
"0.7027224",
"0.69508666",
"0.69354415",
"0.6925504",
"0.6851042",
"0.6831912",
"0.6831396",
"0.68186605",
"0.68149203",
"0.678271",
"0.6761923",
"0.67494124",
"0.67410195",
"0.67235774",
"0.67157817",
"0.6713486",
"0.6704787",
"0.6704224",
"0.67013925",
"0.6694381",
"0.66826... | 0.0 | -1 |
Draws the block on the screen | def draw(self, screen, size_block):
pos = self.board.coordinate_to_position(self.coordinate)
screen.blit(pygame.transform.scale(self.image, (size_block, size_block)), (pos[0], pos[1])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw(self):\n\t\tself.screen.fill(pygame.Color('black'))\n\t\tfor column in self.model.blocks:\n\t\t\tfor block in column:\n\t\t\t\tr = pygame.Rect(block.left,\n\t\t\t\t\t\t\t\tblock.top,\n\t\t\t\t\t\t\t\tblock.size,\n\t\t\t\t\t\t\t\tblock.size)\n\t\t\t\tpygame.draw.rect(self.screen, block.color,r)\n\t\tpygame... | [
"0.8203293",
"0.8183783",
"0.8012238",
"0.7881209",
"0.7751677",
"0.77117234",
"0.76349616",
"0.7580952",
"0.7553323",
"0.7543676",
"0.7497097",
"0.7388594",
"0.73665094",
"0.73665094",
"0.73665094",
"0.73665094",
"0.73603535",
"0.73522764",
"0.733408",
"0.73245215",
"0.73075... | 0.73898596 | 11 |
Turns the tetromino if it is possible to turn the tetromino | def turn(self):
new_shape = []
for shape in self.shape:
new_shape.append([-shape[1], shape[0]])
old_shape = self.shape[:]
self.shape = new_shape
if not self.board.is_valid_tetromino(self):
self.shape = old_shape | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def turn(self):\n pass",
"def on_turnover(self):\n return True if self.rotor_setting in self.turnover_characters else False",
"def turn():\n \n robottype = get_type()\n if robottype == RobotType.PAWN:\n pawn_turn()\n else:\n overlord_turn()\n bytecode = get_bytecode()",
... | [
"0.6341206",
"0.6177607",
"0.60730696",
"0.60730696",
"0.60421073",
"0.59296685",
"0.59253603",
"0.57909256",
"0.5623556",
"0.5606334",
"0.5600717",
"0.55685407",
"0.5567788",
"0.5556943",
"0.5554544",
"0.554343",
"0.5536502",
"0.551141",
"0.54977953",
"0.54977953",
"0.546125... | 0.0 | -1 |
Checks whether or not it is possible for the tetromino to move in the given direction | def possible_to_move(self, down=False, left=False, right=False):
old_coordinate = self.coordinate[:]
possible = False
self.move(down, left, right)
if self.board.is_valid_tetromino(self):
possible = True
self.coordinate = old_coordinate
return possible | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def can_move(self,direction):\r\n if direction in self.current_room.return_directions():\r\n print('move into the next room')\r\n # makes next room \r\n self.next_room(direction)\r\n return True\r\n else:\r\n print(\"Can't move that way\")\r\n ... | [
"0.77156323",
"0.7412554",
"0.7255705",
"0.72216725",
"0.72207654",
"0.7070611",
"0.70556986",
"0.7025435",
"0.7002111",
"0.69619906",
"0.69618464",
"0.695139",
"0.6950972",
"0.69369805",
"0.6889356",
"0.6767303",
"0.6745534",
"0.67047703",
"0.66705626",
"0.66464067",
"0.6637... | 0.7346903 | 2 |
Moves the tetromino in the given direction | def move(self, down=False, left=False, right=False):
if down:
self.coordinate[1] += 1
if left:
self.coordinate[0] -= 1
if right:
self.coordinate[0] += 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move(self, direction):\n pass",
"def move(self, direction):\n # replace with your code\n pass",
"def move(self, direction):\n # replace with your code\n pass",
"def move(self, direction):\r\n self.stored_direction = direction",
"def move(self, direction, cycles... | [
"0.75184554",
"0.721334",
"0.721334",
"0.71937394",
"0.69057107",
"0.68894845",
"0.6826645",
"0.6798342",
"0.6787107",
"0.6783627",
"0.67751926",
"0.67722917",
"0.676465",
"0.67043746",
"0.6697022",
"0.66434586",
"0.6640295",
"0.66062504",
"0.6598739",
"0.65892506",
"0.655517... | 0.6284004 | 39 |
Gets all coordinates of every block of the tetromino | def get_all_coordinates(self):
coordinates = []
for relative_coordinate in self.shape:
co = [self.coordinate[0] + relative_coordinate[0], self.coordinate[1] + relative_coordinate[1]]
coordinates.append(co)
return coordinates | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_block_coords(self):\n ## Create list to store coordinates in\n block_coords = []\n\n ## Loop through rel coords of each block element\n for x, y in self.block_elements:\n \n ## Calculate new coordinates based of rotation\n if self.rotate == 1:\n ... | [
"0.70269287",
"0.6747942",
"0.6534447",
"0.6477485",
"0.6469486",
"0.6398605",
"0.6367172",
"0.6330839",
"0.62647754",
"0.6236041",
"0.6225642",
"0.6222044",
"0.6191737",
"0.6187245",
"0.61803955",
"0.61800015",
"0.61642903",
"0.6134628",
"0.61178136",
"0.61087054",
"0.609816... | 0.6641297 | 2 |
Draws the tetromino on screen with the given size of one block | def draw(self, screen, size_block):
for co in self.get_all_coordinates():
pos = self.board.coordinate_to_position(co)
screen.blit(pygame.transform.scale(self.image, (size_block, size_block)), pos) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_block(position, color):\n x = position.col*DX+DX+2\n y = position.row*DY+DY+2\n width = DX-4\n height = DY-4\n pygame.draw.rect(screen, color, (x,y,width,height), 0)",
"def draw_t(self):\r\n pen.forward(20)\r\n pen.left(90)\r\n pen.down()\r\n pen.forward(40)\r\... | [
"0.6730433",
"0.664555",
"0.6513848",
"0.6497331",
"0.6483195",
"0.645657",
"0.6445222",
"0.64065385",
"0.63871247",
"0.6328781",
"0.63229257",
"0.62838465",
"0.6246731",
"0.6245732",
"0.6236885",
"0.6236651",
"0.60426277",
"0.60426277",
"0.6032478",
"0.60321236",
"0.6006253"... | 0.64454854 | 6 |
At this moment `name` bound to the group of "positive events" defined in config (i.e. "settings_yaml.yaml"). But in future implementation the naming principle could be changed. | def train_model(self, name):
if self.data_provider.get_events_count > 10:
logging.debug("Start training model")
events = self.data_provider.get_events()
df = self.data_provider.events_to_dataframe(events)
logging.info('Started parsing configs: {}'.format(df.shape... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def event_name(self, event_name):\n self['event_name'] = event_name",
"def configName(name):\n s.setConfigName(name)",
"def name(self, name):\n pass",
"def name(self):\n return self.config[\"name\"]",
"def _getConfigName(self):\n pass",
"def set_sysmon_events(self, event_na... | [
"0.6007125",
"0.5761646",
"0.5601685",
"0.56003094",
"0.5599171",
"0.5488947",
"0.5475686",
"0.53462094",
"0.53240913",
"0.53206116",
"0.53188646",
"0.5305123",
"0.53017944",
"0.52758616",
"0.5275524",
"0.52629584",
"0.52628016",
"0.5255684",
"0.5232966",
"0.5196814",
"0.5167... | 0.0 | -1 |
Returns the casing of a word | def get_casing(word):
if len(word) == 0:
return "other"
elif word.isdigit(): # Is a digit
return "numeric"
elif word.islower(): # All lower case
return "allLower"
elif word.isupper(): # All upper case
return "allUpper"
# is a tit... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getCasing(word):\n casing = 'other'\n \n numDigits = 0\n for char in word:\n if char.isdigit():\n numDigits += 1\n \n digitFraction = numDigits / float(len(word))\n \n if word.isdigit(): #Is a digit\n casing = 'numeric'\n elif digitFraction > 0.5:\n ... | [
"0.77150095",
"0.7627981",
"0.75995153",
"0.7345379",
"0.70581454",
"0.70581454",
"0.70366627",
"0.70266676",
"0.6998077",
"0.6934372",
"0.68606347",
"0.68557906",
"0.68520325",
"0.6814516",
"0.680668",
"0.67812794",
"0.678011",
"0.67116076",
"0.67093617",
"0.67058736",
"0.66... | 0.8539075 | 0 |
Checks the sanity of the sentence. If the sentence is for example all uppercase, it is rejected | def check_sentence_sanity(self, sentence):
case_dist = nltk.FreqDist()
for token in sentence:
case_dist[self.get_casing(token)] += 1
if case_dist.most_common(1)[0][0] != "allLower":
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_sentence_input(self, sentence):\n if len(sentence.strip()) == 0:\n return False\n # Decode unicode, mainly to normalize fancy quotation marks\n decoded = unidecode(sentence)\n # Sentence shouldn't contain problematic characters\n if self.well_formed and self.r... | [
"0.72757673",
"0.6896224",
"0.66803765",
"0.6666935",
"0.6642678",
"0.65529424",
"0.65316814",
"0.6467364",
"0.64504784",
"0.64176303",
"0.6370217",
"0.63567257",
"0.6353151",
"0.6348308",
"0.6311175",
"0.62783295",
"0.6248707",
"0.6111707",
"0.61105114",
"0.6082513",
"0.6035... | 0.75520724 | 0 |
return a logger that prints to the screen if it's interactive and a file if not | def get_logger(name='some script'):
#timestamp for filename
timestamp = datetime.now().strftime('%Y-%m-%d')
logger = logging.getLogger(name)
logger.setLevel(logging.DEBUG)
#custom formatter
formatter = logging.Formatter(
'%(asctime)s %(name)s %(levelname)s %(filename)s '
'%(f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_main_logger():\n\n # Use verbose debug logging for now.\n console_loglevel = VERBOSITY_LEVELS[2]\n file_loglevel = VERBOSITY_LEVELS[2]\n\n console_fmt = logging.Formatter(\n '%(name)s: %(levelname)s %(message)s')\n file_fmt = logging.Formatter(\n '%(asctime)s - %(name)s: %(leve... | [
"0.60888046",
"0.60173994",
"0.5929699",
"0.58889014",
"0.5855779",
"0.5853313",
"0.5852736",
"0.5819368",
"0.5804063",
"0.5800967",
"0.5776022",
"0.57705855",
"0.57650095",
"0.5753275",
"0.5744197",
"0.5717597",
"0.57117486",
"0.5706986",
"0.5679158",
"0.56692344",
"0.566720... | 0.6818312 | 0 |
Helper method; It converts a python string to Base64 (using utf8) | def _encode_partitial_parameter(data):
return base64.b64encode(data.encode("utf-8")).decode() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_to_base64(str):\n str_bytes = str.encode(\"utf-8\")\n str_bytes_base64 = base64.b64encode(str_bytes)\n str_base64 = str_bytes_base64.decode(\"utf-8\")\n return str_base64",
"def my_base64encode(s):\n return base64.b64encode(s).decode(\"utf-8\")",
"def _encode_base64(data: str) -> str... | [
"0.8389969",
"0.8057397",
"0.78310317",
"0.7827948",
"0.7767125",
"0.7755934",
"0.7712392",
"0.76610965",
"0.76608723",
"0.76020265",
"0.7411061",
"0.740894",
"0.7408367",
"0.74067724",
"0.74067724",
"0.73230964",
"0.7314781",
"0.72995573",
"0.72735476",
"0.71804476",
"0.7170... | 0.0 | -1 |
Embedds a Partitial without initiial loading, or updates | def direct_partitial(context, selector, **kwargs):
data = __("selector at template not defined in view error message", "Sorry unable to get Element to display Data")
if "partitial" not in context:
raise PartitialNotFound("No Partitials defined")
if selector in context["partitial"]:
data ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def embed():",
"def _embed(slug):\n context = get_factcheck_context();\n context['slug'] = slug\n contents = context['contents']\n annotations = [post for post in contents if post['type'] == 'annotation' and post['published'] == 'yes']\n filtered = [post for post in annotations if post['slug'] == ... | [
"0.66283685",
"0.6207319",
"0.618819",
"0.5957484",
"0.5544892",
"0.55282795",
"0.5496768",
"0.53691417",
"0.52928776",
"0.52521026",
"0.52320933",
"0.52225244",
"0.5213902",
"0.51485777",
"0.51114625",
"0.5105177",
"0.5098499",
"0.5066612",
"0.50501794",
"0.5033288",
"0.5021... | 0.51954544 | 13 |
This view should return a list of all the Posting for the currently authenticated user. | def get_queryset(self):
#print("request", self.request)
user = self.request.user
return Experience.objects.filter(person=user) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_posts(self):\n return Post.select().where (Post.user == self)",
"def get_queryset(self):\r\n\r\n user = get_object_or_404(User, username=self.kwargs.get('username'))\r\n return Post.objects.filter(author=user).order_by('-date_posted')",
"def get_queryset(self):\n return Post... | [
"0.76364285",
"0.7276207",
"0.7069362",
"0.69786215",
"0.69439435",
"0.69179547",
"0.6832055",
"0.67505515",
"0.6747695",
"0.6714803",
"0.6682357",
"0.6659434",
"0.6610183",
"0.66069597",
"0.6564537",
"0.65382445",
"0.65202713",
"0.65202713",
"0.650429",
"0.6504121",
"0.64706... | 0.0 | -1 |
Tests the return of `__virtual__` function | def test_virtual(self):
self.assertEqual(containerd.__virtual__(), "containerd") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __virtual__():\n return True",
"def __virtual__():\n return True",
"def is_virtual_method(self):\r\n return conf.lib.clang_CXXMethod_isVirtual(self)",
"def __virtual__():\n if get_configured_provider() is False:\n return False\n\n if get_dependencies() is False:\n return ... | [
"0.743135",
"0.743135",
"0.6307949",
"0.6301381",
"0.6288245",
"0.62270534",
"0.61580956",
"0.6037573",
"0.6030253",
"0.60108423",
"0.599295",
"0.5986602",
"0.5950467",
"0.59479356",
"0.5926023",
"0.5900328",
"0.5807527",
"0.58043253",
"0.57900876",
"0.5771885",
"0.57596844",... | 0.71836746 | 2 |
Tests the return of `load_cri_image` function | def test_load_cri_image(self, path):
cmd = utils.cmd_output(
stderr='time="2020-07-02T08:02:46Z" '
'level=debug msg="unpacking 1 images"',
stdout="unpacking k8s.gcr.io/my-image:3.1 (sha256:3efe4ff64c93123e"
"1217b0ad6d23b4c87a1fc2109afeff55d2f27d70c55d8f73)...done... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_read_image(self):\n pass",
"def test_CreateROI1(self):\r\n\r\n self.delayDisplay(\"Starting the test\")\r\n #\r\n # first, get some data\r\n #\r\n import urllib\r\n downloads = (\r\n ('http://slicer.kitware.com/midas3/download?items=5767', 'FA.nrrd', slicer.util.loadVolum... | [
"0.69967496",
"0.6590686",
"0.65902233",
"0.6497048",
"0.6327282",
"0.6300939",
"0.62152237",
"0.62148",
"0.62034553",
"0.61346054",
"0.6108102",
"0.6102628",
"0.6064511",
"0.60624236",
"0.60367256",
"0.60231346",
"0.60110754",
"0.59880245",
"0.5982799",
"0.59773093",
"0.5951... | 0.8183807 | 0 |
Gives full list of users | def user_list(request):
if request.method == 'GET':
user_info = UserData.objects.all()
serializer = UserProfileSerializer(user_info, many=True)
return JSONResponse(serializer.data)
else:
return JSONResponse('Using wrong api.', status=404) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_users():",
"def user_list(ctx):\n data = ctx.obj.get_all_users()\n output_json_data(data)",
"def list_users(self):\n raise NotImplementedError",
"def list_users():\n check_admin()\n results = User.query.order_by(-User.id)\n return render_template('user_list.html', users=resu... | [
"0.87828565",
"0.857862",
"0.8309675",
"0.8255022",
"0.82229847",
"0.82012045",
"0.8174902",
"0.81455934",
"0.81301534",
"0.812645",
"0.81152916",
"0.8111818",
"0.8095608",
"0.80905443",
"0.80861485",
"0.80800664",
"0.80800664",
"0.80800664",
"0.80800664",
"0.80800664",
"0.80... | 0.0 | -1 |
Retrieve, update or delete a code snippet. | def user_detail(request, pk):
try:
user_ = UserData.objects.get(pk=pk)
print (user_)
except user_.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = UserProfileSerializer(user_)
return JSONResponse(serializer.data)
elif reques... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def snippet_detail(request, pk):\n try:\n snippet = Snippet.objects.get(pk=pk)\n except Snippet.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == 'GET':\n serializer = SnippetSerializer(snippet)\n return Response(serializer.data)\n\n ... | [
"0.6433456",
"0.6433456",
"0.6343488",
"0.62826616",
"0.6222594",
"0.6008561",
"0.5910034",
"0.5902556",
"0.5866052",
"0.58183044",
"0.58100134",
"0.5747753",
"0.57476574",
"0.57111764",
"0.5676638",
"0.5585475",
"0.5561278",
"0.54968476",
"0.54310095",
"0.5384304",
"0.531098... | 0.0 | -1 |
Run main script for running usage examples of oop bank management system. | def simple_banking_management_oop():
bank = Bank('My_bank') # Initiate bank
# Create users, choose between private and company, return user directly if needed
ricky = bank.register_user('private', 'Ricky', 'Wysocki', 222222)
bank.register_user('company', 'E_will_inc', 666666)
bank.register_user('p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_script(self) -> None:\n main()",
"def main():\n run_test_all()",
"def main():\n subcommands = {\n \"train\": train.train,\n \"tune\": train_tune.train,\n \"predict\": predict.cli_predict,\n \"evaluate\": evaluate.cli_evaluate,\n \"version\": version,\n ... | [
"0.7118854",
"0.7015572",
"0.69641906",
"0.694683",
"0.6810904",
"0.68077016",
"0.6798183",
"0.678402",
"0.67734224",
"0.676862",
"0.67376447",
"0.67187804",
"0.6693901",
"0.6651322",
"0.6651248",
"0.6629834",
"0.6620381",
"0.66107005",
"0.6601279",
"0.66009575",
"0.66003424"... | 0.0 | -1 |
Run main script for running usage examples of functional bank management system. | def simple_banking_management_functional():
create_user('private', **USERS['Andreas'])
create_user('company', **USERS['carrot_inc'])
result = search_private_user('Andreas', 'Gustafsson')
result_2 = search_company_user('carrot')
register_account('savings', USERS['Andreas']['id_nr'])
register_ac... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_script(self) -> None:\n main()",
"def main():\n subcommands = {\n \"train\": train.train,\n \"tune\": train_tune.train,\n \"predict\": predict.cli_predict,\n \"evaluate\": evaluate.cli_evaluate,\n \"version\": version,\n }\n\n try:\n import xarra... | [
"0.74007034",
"0.72510475",
"0.72342753",
"0.7057424",
"0.6932121",
"0.68748486",
"0.68650436",
"0.68547904",
"0.68173623",
"0.681692",
"0.6806443",
"0.67829275",
"0.6768481",
"0.6758717",
"0.6732231",
"0.672012",
"0.6716059",
"0.6714295",
"0.6706323",
"0.6684578",
"0.6660309... | 0.0 | -1 |
Evaluate predicted target values for X relative to y_true. | def __call__(self, estimator, X, y_true, sample_weight=None, offsets=None):
return self._score(
partial(_cached_call, None),
estimator,
X,
y_true,
sample_weight=sample_weight,
offsets=offsets
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _evaluate(self, y_true, y_pred):\n pass",
"def eval(y_pred, y_true):\n return torch.mean((torch.argmax(y_pred, dim=1) == y_true).float())",
"def __call__(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:",
"def score(self, y_true, y_pred):\r\n pass",
"def evaluate(self):\n ... | [
"0.79254335",
"0.7540403",
"0.7483366",
"0.7202576",
"0.711361",
"0.7073816",
"0.7023629",
"0.6981823",
"0.68864375",
"0.68682206",
"0.6821785",
"0.6793407",
"0.67515427",
"0.67452955",
"0.67347604",
"0.6717862",
"0.6714996",
"0.6702411",
"0.66589254",
"0.6625839",
"0.6618985... | 0.0 | -1 |
Evaluate predicted target values for X relative to y_true. | def _score(self, method_caller, estimator, X, y_true,
sample_weight=None, offsets=None):
if offsets is not None:
assert check_accepts_offsets(estimator.predict)
y_pred = method_caller(estimator, "predict", X=X, offsets=offsets)
else:
y_pred = method_ca... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _evaluate(self, y_true, y_pred):\n pass",
"def eval(y_pred, y_true):\n return torch.mean((torch.argmax(y_pred, dim=1) == y_true).float())",
"def __call__(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:",
"def score(self, y_true, y_pred):\r\n pass",
"def evaluate(self):\n ... | [
"0.7926719",
"0.7540681",
"0.7483446",
"0.72028357",
"0.71124786",
"0.70752966",
"0.7024636",
"0.69827354",
"0.68863964",
"0.6867903",
"0.6822651",
"0.67943895",
"0.6750956",
"0.6745403",
"0.6733662",
"0.67168826",
"0.6715787",
"0.6702082",
"0.66582286",
"0.6625811",
"0.66188... | 0.0 | -1 |
Evaluate predicted probabilities for X relative to y_true. | def _score(self, method_caller, clf, X, y,
sample_weight=None, offsets=None):
if offsets is not None:
assert check_accepts_offsets(clf.predict_proba)
y_pred = method_caller(clf, "predict_proba", X=X, offsets=offsets)
else:
y_pred = method_caller(clf, "... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _evaluate(self, y_true, y_pred):\n pass",
"def eval(y_pred, y_true):\n return torch.mean((torch.argmax(y_pred, dim=1) == y_true).float())",
"def __call__(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:",
"def precision_score(y_true, y_pred):\n return ((y_true == 1) * (y_pred == 1)).s... | [
"0.7751502",
"0.7422736",
"0.72359395",
"0.719578",
"0.71556616",
"0.7150211",
"0.71005857",
"0.70785266",
"0.69823",
"0.69728625",
"0.6960776",
"0.69178027",
"0.6908371",
"0.69034386",
"0.68494487",
"0.6835456",
"0.6827891",
"0.68223083",
"0.68122584",
"0.67999685",
"0.67967... | 0.0 | -1 |
Evaluate decision function output for X relative to y_true. | def _score(self, method_caller, clf, X, y,
sample_weight=None, offsets=None):
y_type = type_of_target(y)
if y_type not in ("binary", "multilabel-indicator"):
raise ValueError("{0} format is not supported".format(y_type))
if is_regressor(clf):
if offsets ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _evaluate(self, y_true, y_pred):\n pass",
"def __call__(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:",
"def decision_function(self, X):\n y = self.__cls.decision_function(X)\n return y",
"def evaluate(tag, x, y_true):\n y_pred = model(x, is_training=False)\n\n accura... | [
"0.78084064",
"0.7493824",
"0.7323878",
"0.71945673",
"0.7180778",
"0.71042687",
"0.7060395",
"0.69529766",
"0.6877816",
"0.6865516",
"0.6852216",
"0.6846135",
"0.6768673",
"0.6759729",
"0.6759208",
"0.6758773",
"0.67231613",
"0.67215425",
"0.66968197",
"0.667077",
"0.6653818... | 0.0 | -1 |
Get a scorer from string. | def get_scorer(scoring):
if isinstance(scoring, str):
try:
scorer = SCORERS[scoring]
except KeyError:
raise ValueError(
"%r is not a valid scoring value. "
"Use sorted(sklearn.metrics.SCORERS.keys()) "
"to get valid options." % ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_scorer(scoring, compute=True):\n # This is the same as sklearns, only we use our SCORERS dict,\n # and don't have back-compat code\n if isinstance(scoring, six.string_types):\n try:\n scorer = SCORERS[scoring]\n except KeyError:\n raise ValueError('{} is not a v... | [
"0.7410293",
"0.6213774",
"0.6117247",
"0.5969417",
"0.59498906",
"0.5834008",
"0.57948613",
"0.57125705",
"0.5691819",
"0.5677424",
"0.5553856",
"0.5519682",
"0.5454422",
"0.5444198",
"0.53747046",
"0.5372519",
"0.5332151",
"0.53248066",
"0.52808905",
"0.5260689",
"0.5242217... | 0.7338515 | 1 |
Make a scorer from a performance metric or loss function. This factory function wraps scoring functions for use in | def make_scorer(
score_func,
*,
greater_is_better=True,
needs_proba=False,
needs_threshold=False,
**kwargs,
):
sign = 1 if greater_is_better else -1
if needs_proba and needs_threshold:
raise ValueError(
"Set either needs_proba or needs_threshold to True, but not both.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_scorer(scoring, compute=True):\n # This is the same as sklearns, only we use our SCORERS dict,\n # and don't have back-compat code\n if isinstance(scoring, six.string_types):\n try:\n scorer = SCORERS[scoring]\n except KeyError:\n raise ValueError('{} is not a v... | [
"0.68151456",
"0.65854603",
"0.65313846",
"0.6162087",
"0.6153191",
"0.61268836",
"0.6123337",
"0.6015906",
"0.586069",
"0.58467746",
"0.5845448",
"0.5719968",
"0.5628305",
"0.5599996",
"0.5546353",
"0.54967225",
"0.5482464",
"0.54398274",
"0.543661",
"0.5424008",
"0.54104716... | 0.78375727 | 0 |
Event of submit button | def submit_command():
global amount_point_var, amount_relationship_var, data, list_position, canvas, \
list_point, label_frame_matrix_relationship, list_label_distance, list_best_label_distance, label_text_result
"""Delete old data from screen"""
if len(list_elements_matrix) != 0:
"""Delete ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def form_submit(self, request: http.Request):\n self._on_form_submit(request)",
"def _resubmit_button_fired(self):\n self.resubmit()",
"def submit(self):\n self.driver.find_element(*BaseLocators.SUBMIT_BUTTON).click()",
"def set_submit_event(self, onsubmit):\n self._onsubmit = ons... | [
"0.6977783",
"0.69723505",
"0.692153",
"0.6906102",
"0.6870872",
"0.67922825",
"0.6780209",
"0.6702129",
"0.65223724",
"0.6422919",
"0.63936025",
"0.61794597",
"0.61497706",
"0.6100532",
"0.60977656",
"0.6091912",
"0.6091912",
"0.6063564",
"0.5982731",
"0.5947766",
"0.5935841... | 0.0 | -1 |
Event of choose point button Handling to make sure user choose 2 point to find best line After choose 2 points, fine best line and draw it on canvas | def choose_point_command(a):
global canvas, best_line, list_best_label_distance, label_text_result
if choose_point[0] != a and choose_point[1] != a: # if a was not be choose
if choose_point[0] == -1 and choose_point[1] == -1:
choose_point[0] = a
list_point[a].configure(bg=point_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def onClick(self, event):\n if event.inaxes:\n if event.button == 3:\n if len(self.baslin) < 2:\n # Cannot delete if there less than 2 points\n return\n elif event.button != 1:\n return\n else:\n retu... | [
"0.644487",
"0.6414169",
"0.63994014",
"0.6279453",
"0.6074503",
"0.6039465",
"0.5936192",
"0.5895433",
"0.58924294",
"0.5869574",
"0.58490586",
"0.584594",
"0.584594",
"0.58347243",
"0.58235395",
"0.58041525",
"0.5790136",
"0.57632446",
"0.57615465",
"0.5746828",
"0.5745401"... | 0.73080593 | 0 |
Event of off_all_line button Function to show or hide all lines off all points (keep hose best line with 2 point) | def hide_all_line():
global canvas, button_off_all_line, best_line, button_off_best_line
if button_off_all_line['text'] == "Hide all line": # If current status is show and want to hide
canvas.delete("all_line_tag") # Delete all lines from canvas
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hide_all_bestline():\n global canvas, button_off_best_line, best_line\n if best_line is not None:\n if button_off_best_line['text'] == \"Hide best line\": # If current status is show and want to hide\n canvas.delete(\"best_line_tag\") ... | [
"0.7622647",
"0.68477213",
"0.65928304",
"0.658819",
"0.6270692",
"0.62433136",
"0.6175596",
"0.61608386",
"0.5985505",
"0.5888555",
"0.58602905",
"0.58566725",
"0.5833649",
"0.5795332",
"0.5786222",
"0.575878",
"0.57369995",
"0.5720687",
"0.5713423",
"0.57112813",
"0.5651486... | 0.81036454 | 0 |
Event of off_best_line button Function to show or hide best lines of 2 points | def hide_all_bestline():
global canvas, button_off_best_line, best_line
if best_line is not None:
if button_off_best_line['text'] == "Hide best line": # If current status is show and want to hide
canvas.delete("best_line_tag") # Delete best... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hide_best_distance():\n global canvas, list_label_distance, data, list_position, list_best_label_distance\n if len(list_best_label_distance) != 0:\n if button_off_best_label_distance['text'] == \"Hide best distance\": # If current status is show and want to hide\n for i in range(len(li... | [
"0.6818651",
"0.66486394",
"0.60474133",
"0.604604",
"0.59081006",
"0.5839253",
"0.5635505",
"0.56088",
"0.5502675",
"0.54919034",
"0.5474902",
"0.5400621",
"0.5398919",
"0.5303749",
"0.527624",
"0.5274308",
"0.52618957",
"0.52533096",
"0.5252591",
"0.52440584",
"0.5228172",
... | 0.77532905 | 0 |
Event of button_off_all_label_distance button Function to show or hide all distance value | def hide_all_distance():
global canvas, button_off_all_label_distance, list_label_distance, data, list_position, \
list_best_label_distance, button_off_best_label_distance
if button_off_all_label_distance['text'] == "Hide all distance": # If current status is show and want to hide
for i in ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hide_best_distance():\n global canvas, list_label_distance, data, list_position, list_best_label_distance\n if len(list_best_label_distance) != 0:\n if button_off_best_label_distance['text'] == \"Hide best distance\": # If current status is show and want to hide\n for i in range(len(li... | [
"0.75043434",
"0.59171087",
"0.5838485",
"0.5706002",
"0.56357735",
"0.5474313",
"0.545505",
"0.5445648",
"0.5394187",
"0.53430897",
"0.5258339",
"0.5220189",
"0.5196048",
"0.51593065",
"0.51419675",
"0.5132579",
"0.5116383",
"0.5098416",
"0.50940084",
"0.50889766",
"0.507515... | 0.8398894 | 0 |
Event of off_best_distance button Function to show or hide best distance of dijkstra | def hide_best_distance():
global canvas, list_label_distance, data, list_position, list_best_label_distance
if len(list_best_label_distance) != 0:
if button_off_best_label_distance['text'] == "Hide best distance": # If current status is show and want to hide
for i in range(len(list_best_lab... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hide_all_distance():\n global canvas, button_off_all_label_distance, list_label_distance, data, list_position, \\\n list_best_label_distance, button_off_best_label_distance\n if button_off_all_label_distance['text'] == \"Hide all distance\": # If current status is show and want to hide\n ... | [
"0.6756336",
"0.6017361",
"0.5828534",
"0.5650388",
"0.55981857",
"0.55409235",
"0.5525183",
"0.5472911",
"0.5458907",
"0.524283",
"0.5239041",
"0.5234307",
"0.52263236",
"0.51862323",
"0.5134129",
"0.51089394",
"0.51026577",
"0.50943565",
"0.5082267",
"0.5062372",
"0.5059855... | 0.7727631 | 0 |
Use the `msmd` tool to identify the individual SPW ID numbers for a common baseband and spectral window pair, which should always be consistent between the 12m & 7m MSs, as setup by the OT. | def get_spw_from_name(vis, spw=None):
msmd.open(vis)
labels = msmd.namesforspws()
if spw is None:
ot_name = '#BB_4#SW-01'
if type(spw) is str:
ot_name = spw
else:
ot_name = spw.ot_name
ot_name = ot_name + '#FULL_RES'
spws = ','.join([
str(i) for i,s in enumera... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def msid(self):\n return self.msids[0]",
"def get_spw_id(self, spw):\n spw_ids = []\n for vis in self.vis:\n msmd.open(vis)\n labels = msmd.namesforspws()\n obs_spws = msmd.spwsforintent('OBSERVE_TARGET#ON_SOURCE')\n id_str = ','.join([\n ... | [
"0.60724604",
"0.5911711",
"0.5634371",
"0.54764205",
"0.5465989",
"0.54030174",
"0.5358231",
"0.5350375",
"0.5244999",
"0.5191615",
"0.51499647",
"0.5144052",
"0.50523376",
"0.49507278",
"0.49175915",
"0.4904271",
"0.49021316",
"0.48907432",
"0.48903045",
"0.4868042",
"0.485... | 0.5467314 | 4 |
Check for and remove (if they exist) files created by clean such as '.flux', '.image', etc. | def check_delete_image_files(imagename, preserve_mask=False):
print(':: Check for and remove existing files')
exts = [
'.flux', '.pb', '.image', '.weight', '.model', '.pbcor', '.psf',
'.sumwt', '.residual', '.flux.pbcoverage'
]
if not preserve_mask:
exts += ['.mask']
for ext ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean():\n clean_files()",
"def clean_data():\n for clean_file in clean_files:\n file_list = [f for f in os.listdir(\".\") if f.endswith(clean_file)]\n for f in file_list:\n os.remove(f)",
"def _clean_workdir(self):\n\t\ttoremove = [self._get_config_filepath(), self._get_para... | [
"0.80557466",
"0.77625537",
"0.7661359",
"0.76540726",
"0.7619263",
"0.7616365",
"0.76152307",
"0.7600073",
"0.7457803",
"0.7456741",
"0.7451228",
"0.74188185",
"0.74021995",
"0.73550963",
"0.73337966",
"0.72935754",
"0.7285965",
"0.728489",
"0.7283844",
"0.7281332",
"0.72612... | 0.0 | -1 |
Image the continuum using only the single continuum TDM spectral window, or the linefree channels. | def clean_continuum(imc, linefree=False, remove_existing=True, export=False):
if linefree:
vis = imc.vislf
spw = ''
imagename = imc.path_base
else:
vis = imc.vis
spw = imc.get_cont_spw()
imagename = imc.path_base +'_single'
if remove_existing:
check_de... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_continuum(self, refresh=False):\n\n try:\n index = self.current_order_index\n except AttributeError:\n return None\n\n meta = self.parent.session.metadata[\"normalization\"]\n continuum = meta[\"continuum\"][index]\n kwds = meta[\"normalization_kwar... | [
"0.5239789",
"0.52032614",
"0.5161228",
"0.5058049",
"0.5052641",
"0.5048927",
"0.5047654",
"0.5028256",
"0.50035876",
"0.5001316",
"0.500073",
"0.49987286",
"0.49860814",
"0.49765074",
"0.4948414",
"0.49153182",
"0.49145216",
"0.49112833",
"0.4899455",
"0.48870373",
"0.48785... | 0.45338288 | 84 |
Split out the linefree continuum channels from the measurement set and apply channel averaging (for the higher resolution line channels). The flags are backed up, line channels flagged, measurement set split, and the flag state restored. It should be OK to initialize the weight each time, since when found will noop. | def split_linefree(imc):
now = str(datetime.datetime.utcnow())
comment = 'Flags before split for line-free (UTC: {0})'.format(now)
print(':: Saving flag backup : `before_split`')
flagmanager(vis=imc.vis, mode='save', versionname='before_split',
comment=comment)
initweights(vis=imc.vi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lineDetectThread(self):\n \n while True:\n\n tmpList = self.octo.analog_read_all()\n avg = 0\n for x in tmpList:\n avg = avg + x\n\n avg = avg / len(tmpList)\n\n if avg <= self.cutoff:\n if not self.seenLine: # f... | [
"0.48285812",
"0.48112413",
"0.4758139",
"0.47020394",
"0.469053",
"0.46687457",
"0.46044582",
"0.45869437",
"0.45790747",
"0.4564418",
"0.45641688",
"0.45589712",
"0.44781768",
"0.44485095",
"0.44375643",
"0.44301227",
"0.4421234",
"0.44173494",
"0.4417143",
"0.44007793",
"0... | 0.5999584 | 0 |
Self Calibration. Initiate the selfcalibration process with a shallow clean to start. Here clean only the secure detections of emission. | def selfcal_image(imc, trial='0'):
if trial == '0':
mask = ''
else:
mask = imc.path_base + '_p{0}.mask'.format(int(trial)-1)
vis = imc.vislf
imagename = imc.path_base + '_p{0}'.format(trial)
check_delete_image_files(imagename)
tclean(vis=vis,
imagename=imagename,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rm_calibration(self):\n\n self.bin_edges_kev = None",
"def _doCalibration(self):\n self._cmdCalibration(2)",
"def reset(self):\n self.resetPos()\n self.vx, self.vy = 0, 0\n self.accel, self.dangle = 0, 0\n self.crashed = False\n self.timeDriving, self.score... | [
"0.629341",
"0.60715276",
"0.6038059",
"0.5894017",
"0.5803302",
"0.5768634",
"0.5759604",
"0.5733961",
"0.57175505",
"0.57133883",
"0.56535786",
"0.56385595",
"0.55656916",
"0.555237",
"0.5471464",
"0.5434825",
"0.54325277",
"0.54210687",
"0.54147273",
"0.5398735",
"0.538167... | 0.57821494 | 5 |
Self Calibration. Generate a per observation solution first. | def selfcal_pcal(imc, combine='spw,scan', trial='1'):
if trial == '1':
solint = 'inf' # Sum entire scheduling block
elif trial == '2':
solint = '1800s' # Half block
else:
raise ValueError('Invalid pcal trial: {0}'.format(trial))
caltable = imc.path_base + '.pcal' + trial
rm... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _doCalibration(self):\n self._cmdCalibration(2)",
"def fit_once(self,random_restart=True):\n \n if random_restart:\n ## Main mode of operation\n \n # Initializations\n n_iterations = int(np.ceil(np.log2(self.K))) # log_2(K) iterations\n ... | [
"0.61429644",
"0.61369985",
"0.6008194",
"0.58990324",
"0.58952606",
"0.58914626",
"0.58276385",
"0.5809843",
"0.58021075",
"0.5751495",
"0.57445574",
"0.5744396",
"0.5744055",
"0.57362515",
"0.57333183",
"0.56920046",
"0.5677356",
"0.56640816",
"0.5659343",
"0.5646199",
"0.5... | 0.0 | -1 |
Self Calibration. Check the solution | def selfcal_pcal_plot(imc, trial='1'):
plotcal(caltable=imc.path_base+'.pcal'+trial,
xaxis='time', yaxis='phase', timerange='', iteration='',
subplot=111, plotrange=[0,0,-180,180]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calibration(self) -> int:",
"def _doCalibration(self):\n self._cmdCalibration(2)",
"def convergence_check(self):\n air = self.air_alias.val\n flue_gas = self.fuel_alias.val + '_fg'\n fuel = self.fuel_alias.val\n\n for c in self.outl:\n if not c.fluid.val_set[ai... | [
"0.7105522",
"0.6993151",
"0.66071844",
"0.6589474",
"0.6569091",
"0.652657",
"0.64698505",
"0.6425824",
"0.64135945",
"0.63717103",
"0.63714695",
"0.6335183",
"0.6329859",
"0.62983537",
"0.62881285",
"0.62694263",
"0.62132275",
"0.6187541",
"0.6185712",
"0.6161007",
"0.61610... | 0.0 | -1 |
Self Calibration. Apply the calibration from the phase only solution | def selfcal_apcal(imc, trial='1'):
flagmanager(imc.vislf, mode='restore', versionname='startup')
applycal(vis=imc.vislf,
spwmap=np.zeros(54),
interp='linearPDperobs',
gaintable=[imc.path_base+'.pcal'+trial],
calwt=False,
flagbackup=False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _doCalibration(self):\n self._cmdCalibration(2)",
"def photometric_calibration():\n pass",
"def calibration(self) -> int:",
"def calibration_wheel(self):\n self.spectrum = self.spectrum",
"def calibration(self, cal: int, /) -> None:",
"def calibrate(self, master):\n if mas... | [
"0.67444855",
"0.64102155",
"0.62887526",
"0.62739146",
"0.62539726",
"0.61133844",
"0.6096612",
"0.6041767",
"0.5968712",
"0.5952701",
"0.59089845",
"0.58992106",
"0.58605576",
"0.5847041",
"0.5796397",
"0.57910454",
"0.57832146",
"0.5780262",
"0.57560104",
"0.5751728",
"0.5... | 0.5608362 | 27 |
Use `tclean` to CLEAN a spectral cube. Additional keyword arguements are passed to `tclean`. | def clean_line(imc, spw, contsub=False, fullcube=False, interactive=True,
export=False, use_existing_psf=False, automask=False, **kwargs):
vis = imc.viscs if contsub else imc.vis
imagename = '{0}_{1}'.format(imc.path_base, spw.name)
tclean_kwargs = {
'interactive': interactive,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean(args):\n with_dataset(args, Dataset._clean)",
"def test_clean_line_target(cfg, spw, ext=None, iterzero=False, fullcube=False,\n parallel=False):\n imagename = cfg.get_basename(spw, ext=ext)\n spw_id = cfg.get_spw_id(spw)\n log_post(':: Running clean for {0}'.format(imagename))\n n... | [
"0.6328925",
"0.5590112",
"0.55339396",
"0.5511219",
"0.5465729",
"0.5374298",
"0.5327649",
"0.528877",
"0.526185",
"0.5248659",
"0.5220694",
"0.52137625",
"0.5190913",
"0.5170219",
"0.51530504",
"0.5150577",
"0.5133238",
"0.5131207",
"0.51212543",
"0.5066113",
"0.5057564",
... | 0.539494 | 5 |
A utility function that converts an attribute name string into the corresponding attribute tag. | def convert_attribute_name_to_tag(value):
if not isinstance(value, six.string_types):
raise ValueError("The attribute name must be a string.")
for entry in attribute_name_tag_table:
if value == entry[0]:
return entry[1]
raise ValueError("Unrecognized attribute name: '{}'".forma... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_attribute_tag_to_name(value):\n if not isinstance(value, Tags):\n raise ValueError(\"The attribute tag must be a Tags enumeration.\")\n\n for entry in attribute_name_tag_table:\n if value == entry[1]:\n return entry[0]\n\n raise ValueError(\"Unrecognized attribute tag:... | [
"0.74248964",
"0.71455866",
"0.6820382",
"0.6814265",
"0.6467705",
"0.6433419",
"0.63990474",
"0.6338518",
"0.6189894",
"0.60293674",
"0.6026002",
"0.6026002",
"0.6018459",
"0.5988461",
"0.5980702",
"0.59706277",
"0.5942196",
"0.5880535",
"0.58307683",
"0.58123",
"0.58119905"... | 0.80393004 | 0 |
A utility function that converts an attribute tag into the corresponding attribute name string. | def convert_attribute_tag_to_name(value):
if not isinstance(value, Tags):
raise ValueError("The attribute tag must be a Tags enumeration.")
for entry in attribute_name_tag_table:
if value == entry[1]:
return entry[0]
raise ValueError("Unrecognized attribute tag: {}".format(valu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_attribute_name_to_tag(value):\n if not isinstance(value, six.string_types):\n raise ValueError(\"The attribute name must be a string.\")\n\n for entry in attribute_name_tag_table:\n if value == entry[0]:\n return entry[1]\n\n raise ValueError(\"Unrecognized attribute n... | [
"0.73351747",
"0.72900105",
"0.7044817",
"0.700109",
"0.6944922",
"0.6706183",
"0.66464186",
"0.6546524",
"0.6434635",
"0.6434635",
"0.6406859",
"0.63961947",
"0.63639677",
"0.63639677",
"0.6242204",
"0.6229339",
"0.6229339",
"0.62258285",
"0.6216158",
"0.62033",
"0.62025344"... | 0.7753604 | 0 |
A utility function that computes a bit mask from a collection of enumeration values. | def get_bit_mask_from_enumerations(enumerations):
return functools.reduce(
lambda x, y: x | y, [z.value for z in enumerations]
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_enumerations_from_bit_mask(enumeration, mask):\n return [x for x in enumeration if (x.value & mask) == x.value]",
"def parse_mask(value, mask_enum):\n masks = []\n for mask in mask_enum:\n if value & mask:\n masks.append(mask.name)\n value ^= mask\n if value:\n ... | [
"0.7744489",
"0.66913533",
"0.6403534",
"0.61704373",
"0.61267203",
"0.5990406",
"0.58188605",
"0.5776456",
"0.5742034",
"0.57257146",
"0.5702052",
"0.5667115",
"0.5648651",
"0.54798436",
"0.54597044",
"0.54477435",
"0.5405333",
"0.53865755",
"0.53729063",
"0.53284824",
"0.53... | 0.8022848 | 0 |
A utility function that creates a list of enumeration values from a bit mask for a specific mask enumeration class. | def get_enumerations_from_bit_mask(enumeration, mask):
return [x for x in enumeration if (x.value & mask) == x.value] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_mask(value, mask_enum):\n masks = []\n for mask in mask_enum:\n if value & mask:\n masks.append(mask.name)\n value ^= mask\n if value:\n masks.append(hex(value))\n\n return masks",
"def get_bit_mask_from_enumerations(enumerations):\n return functools.r... | [
"0.69542855",
"0.6844899",
"0.6179964",
"0.6085858",
"0.60515696",
"0.58843184",
"0.5866593",
"0.5610187",
"0.5600955",
"0.5540577",
"0.54730654",
"0.5454916",
"0.5427376",
"0.538644",
"0.5377461",
"0.5375424",
"0.5373737",
"0.5363888",
"0.5209238",
"0.5204924",
"0.51944685",... | 0.81864226 | 0 |
A utility function that checks if the provided value is a composite bit mask of enumeration values in the specified enumeration class. | def is_bit_mask(enumeration, potential_mask):
if not isinstance(potential_mask, six.integer_types):
return False
mask_enumerations = (
CryptographicUsageMask,
ProtectionStorageMask,
StorageStatusMask
)
if enumeration not in mask_enumerations:
return False
ma... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_enum_value(enumeration, potential_value):\n try:\n enumeration(potential_value)\n except ValueError:\n return False\n\n return True",
"def get_enumerations_from_bit_mask(enumeration, mask):\n return [x for x in enumeration if (x.value & mask) == x.value]",
"def _is_equal_to_enu... | [
"0.5870301",
"0.58618695",
"0.553218",
"0.5408903",
"0.5404764",
"0.53083646",
"0.5269919",
"0.5266223",
"0.521553",
"0.51871705",
"0.5102369",
"0.50527793",
"0.5026475",
"0.49758133",
"0.4956287",
"0.49388525",
"0.4901828",
"0.48965237",
"0.48832533",
"0.48725867",
"0.480630... | 0.6198896 | 0 |
A utility function that checks if the enumeration class contains the provided value. | def is_enum_value(enumeration, potential_value):
try:
enumeration(potential_value)
except ValueError:
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def contains(cls, value):\n return value in cls.values()",
"def contains(cls, value):\n return any(value == item.value for item in cls)",
"def has_value(cls, value):\n return any(value == item.value for item in cls)",
"def has_value(cls, value):\n return any(value == item.value fo... | [
"0.7130909",
"0.6671945",
"0.66446143",
"0.66446143",
"0.6463414",
"0.64291495",
"0.64076877",
"0.63996106",
"0.61606634",
"0.613417",
"0.61334",
"0.6130707",
"0.6110766",
"0.6105736",
"0.6105704",
"0.60750055",
"0.60390246",
"0.6028632",
"0.602763",
"0.60264736",
"0.60111135... | 0.7098082 | 1 |
A utility function that checks if the tag is a valid attribute tag. | def is_attribute(tag, kmip_version=None):
kmip_1_0_attribute_tags = [
Tags.UNIQUE_IDENTIFIER,
Tags.NAME,
Tags.OBJECT_TYPE,
Tags.CRYPTOGRAPHIC_ALGORITHM,
Tags.CRYPTOGRAPHIC_LENGTH,
Tags.CRYPTOGRAPHIC_PARAMETERS,
Tags.CRYPTOGRAPHIC_DOMAIN_PARAMETERS,
Tag... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_valid_attribute(self, attr):\n try:\n self.validate_attribute(attr)\n return True\n except etal.LabelsSchemaError:\n return False",
"def is_valid_attribute(self, attr):\n try:\n self.validate_attribute(attr)\n return True\n ... | [
"0.71051097",
"0.71051097",
"0.68592334",
"0.67489237",
"0.6746817",
"0.6668083",
"0.6662779",
"0.66370493",
"0.6567249",
"0.6491474",
"0.64705056",
"0.6454897",
"0.64076465",
"0.6375244",
"0.6368247",
"0.62872916",
"0.622392",
"0.61547047",
"0.61213416",
"0.6109168",
"0.6107... | 0.6629096 | 8 |
Creates a graph from saved GraphDef file and returns a saver. | def create_graph():
# Creates graph from saved graph_def.pb.
with tf.gfile.FastGFile(os.path.join(
'/home/ubuntu/hdd/tensorFlowDic/', 'classify_image_graph_def.pb'), 'rb') as f:
graph_def = tf.GraphDef()
graph_def.ParseFromString(f.read())
_ = tf.import_graph_def(graph_def, name='') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_graph():\n # Creates graph from saved graph_def.pb.\n with tf.gfile.FastGFile(modelFullPath, 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n _ = tf.import_graph_def(graph_def, name='')",
"def create_graph():\n # Creates graph from saved graph... | [
"0.7384441",
"0.7379355",
"0.7351019",
"0.7343615",
"0.72198755",
"0.71940976",
"0.6887917",
"0.67413443",
"0.6659918",
"0.65888435",
"0.6583613",
"0.65483147",
"0.65417933",
"0.65368557",
"0.6521374",
"0.644651",
"0.6392589",
"0.6357744",
"0.63401663",
"0.6299159",
"0.628872... | 0.64245 | 16 |
fonction pour instancier notre classe Chat | def __init__(self, name="", life_point=100, attack_point=25,
voice="Cat-myaw", nb_of_legs=4):
super().__init__(name=name, life_point=life_point,
attack_point=attack_point, voice=voice,
nb_of_legs=nb_of_legs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, chat: WebElement):\n super().__init__(chat.parent, chat.id)\n if not chat.get_attribute(\"class\") == \"_2aBzC\":\n raise TypeError(\"Element is not a chat\")\n self.chat = chat",
"def chat(self) -> \"api.Chat\":\n raise NotImplementedError",
"def creat... | [
"0.6862843",
"0.67190725",
"0.6709747",
"0.6695545",
"0.6543384",
"0.6491909",
"0.64774585",
"0.64774585",
"0.64774585",
"0.64774585",
"0.64774585",
"0.64774585",
"0.64774585",
"0.64774585",
"0.64774585",
"0.64774585",
"0.64774585",
"0.64774585",
"0.64605165",
"0.63651735",
"... | 0.0 | -1 |
Display notification to the desktop | def notification(message: str):
# initialize the notification
notify2.init("notifywhenLOAD")
notifyObj = notify2.Notification("Emergency Alert!", message)
notifyObj.set_timeout(12000)
return notifyObj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_notifications(self):\n self.android_device_driver.adb.exec_adb_cmd(\n \"shell cmd statusbar expand-notifications\").wait()",
"def show_notification(self, message: str, also_cmd: bool = False):\n if platform_string == \"Linux\":\n try:\n notification = notify2.N... | [
"0.6929462",
"0.66672254",
"0.66309613",
"0.65788645",
"0.64223236",
"0.6387376",
"0.6368331",
"0.63421816",
"0.6315346",
"0.6290845",
"0.6279278",
"0.6196264",
"0.6121753",
"0.6016449",
"0.6004377",
"0.5964229",
"0.5962187",
"0.5953753",
"0.5938636",
"0.5907336",
"0.5901497"... | 0.56673187 | 43 |
BuilderConfig for RuBQ 2.0. | def __init__(self,
data_url,
data_dir,
**kwargs):
super(RuBQ2Config, self).__init__(**kwargs)
self.data_url = data_url
self.data_dir = data_dir | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getBuilder():",
"def buildersConf() :\n return dict(_buildersConf)",
"def getBuilder(name):",
"def getBuilder(name):",
"def build_configs():",
"def build(config):",
"def configure_bot(self, builders_dict, additional_configs=None):\n additional_configs = additional_configs or []\n\n # TODO:... | [
"0.71267474",
"0.70139384",
"0.6695297",
"0.6695297",
"0.6452325",
"0.61890537",
"0.58279073",
"0.5709033",
"0.5683073",
"0.5581039",
"0.5581039",
"0.55700415",
"0.5538782",
"0.5537797",
"0.55327755",
"0.5504798",
"0.5504798",
"0.549545",
"0.5481937",
"0.5481937",
"0.54747856... | 0.0 | -1 |
Get the specified JSON input file's contents as a dict | def get_inputs_from_file(filename=""):
import json
with open(filename) as input_text:
json_obj = json.load(input_text)
return json_obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_json(cls, input_file):\n with open(input_file, 'rb') as f:\n return json.load(f)",
"def _read_json(cls, input_file):\n with open(input_file, 'rb') as f:\n return json.load(f)",
"def _read_json(cls, input_file):\n with open(input_file) as f:\n return json.... | [
"0.7587827",
"0.7587827",
"0.7569293",
"0.7569293",
"0.75602573",
"0.753806",
"0.7389315",
"0.7381221",
"0.73781174",
"0.7354496",
"0.7349716",
"0.73322374",
"0.73126495",
"0.7310526",
"0.7288044",
"0.728155",
"0.7277607",
"0.7270094",
"0.7233338",
"0.7233158",
"0.72300816",
... | 0.7359419 | 9 |
Convention for saving the elev arrays to file. | def save_lists_to_file(filename, elev_list, dist_list):
import numpy as np
np.save(file=filename,arr=np.array([elev_list, dist_list])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_enu(self, filename):\n x, y, z = self.get_coords_enu()\n coords = np.vstack([x, y, z]).T\n np.savetxt(filename, coords, fmt=b'%.12e')",
"def save_iantconfig(self, filename_root):\n x, y, z = self.get_coords_enu()\n d = np.ones_like(x) # set to 1 to avoid shadowing in ... | [
"0.7392277",
"0.6695063",
"0.6674351",
"0.644882",
"0.63625616",
"0.6278154",
"0.6215802",
"0.62093705",
"0.6171282",
"0.61635345",
"0.610858",
"0.61081475",
"0.601042",
"0.60060334",
"0.6003838",
"0.59577906",
"0.59309465",
"0.59160286",
"0.59078306",
"0.5905936",
"0.5888497... | 0.7149724 | 1 |
Convention for loading according to saving function above. | def get_lists_from_file(filename):
import numpy as np
elev_arrays = np.load(file=filename)
return list(elev_arrays[0]), list(elev_arrays[1]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(self):\n pass",
"def load(self):\n pass",
"def load(self):\n pass",
"def load(self):\n pass",
"def load(self):",
"def _load(self):\n raise NotImplementedError()",
"async def load(cls, save_file, *args, **kwargs):\n raise NotImplementedError()",
"def ... | [
"0.6482302",
"0.6482302",
"0.6482302",
"0.6482302",
"0.63209206",
"0.62857485",
"0.62781924",
"0.6270234",
"0.62581646",
"0.62424845",
"0.6232893",
"0.61957574",
"0.6152661",
"0.6152661",
"0.6097419",
"0.60608494",
"0.60358715",
"0.602136",
"0.602136",
"0.60017306",
"0.599765... | 0.0 | -1 |
Writing a csv file of the keywordspecified lists. | def write_output_csv(filename, **kwargs):
import csv
import time
intermediate = kwargs.pop("intermediate", False)
keys = sorted(kwargs.keys())
num_vars = len(keys)
if intermediate:
full_filename = filename + "_interm"
else:
dot_index = filename.rfind('.')
if dot_in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_csv(self, key_list, word_list):\n # Write out data\n out_data = []\n # Match filtered indexes to words\n for i in key_list.index:\n subset = word_list[word_list['key'] == i]\n # Add to aggregate list\n out_data.append(subset['word'].tolist())\n... | [
"0.7690983",
"0.7156317",
"0.70057595",
"0.699873",
"0.69436884",
"0.6937405",
"0.68834347",
"0.6880354",
"0.6851179",
"0.6808864",
"0.6744166",
"0.6703595",
"0.6695695",
"0.6665467",
"0.66601634",
"0.66530514",
"0.6650442",
"0.66289073",
"0.66165644",
"0.6579203",
"0.6561281... | 0.6339406 | 44 |
Generate a bunch of input JSON files from a template and a bunch of elevation files | def generate_input_files(elevation_folder_path, template_input_file_path):
import pathlib
json_dict = get_inputs_from_file(template_input_file_path)
path_to_match = pathlib.Path(elevation_folder_path)
for heightfile in path_to_match.glob("*.npy"):
dot_index = str(heightfile).rfind('.')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_main():\n for template in templates:\n main([\"-g\", template])\n\n # One at a time\n for xyz_file in example_xyz_files:\n main([template, xyz_file])\n\n # All at once\n main([template] + list(example_xyz_files))\n\n # Allow use of template in the parent... | [
"0.6439445",
"0.6329011",
"0.6317232",
"0.6279043",
"0.62260956",
"0.60334027",
"0.60176724",
"0.60137415",
"0.60113746",
"0.59920955",
"0.59756476",
"0.5974208",
"0.59657097",
"0.5964929",
"0.596335",
"0.59502697",
"0.5911967",
"0.58968824",
"0.5894371",
"0.5880914",
"0.5866... | 0.80537117 | 0 |
Renames .json files for height files that have too steep gradients for driving. Due to tunnels in mountatin roads, sometimes the surface elevation at a road does not correspond to the actual road elevation. Therefore, the heightmap may be that of a road trying to climb an _actual_ mountain. This is undesired behaviour ... | def seed_out_too_steep(config_folder_path, max_gradient):
import pathlib
import os
path_to_match = pathlib.Path(config_folder_path)
for config_file in path_to_match.glob("*.json"):
config_filename = str(config_file)
json_config = get_inputs_from_file(config_filename)
try:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def renamefile(filename):\n new_data_list = []\n with open(filename, 'r') as f:\n data_list = f.read().split('\\n')\n\n print('Generating new data list..')\n for data in tqdm(data_list):\n if len(data) == 0:\n continue\n data_info = data.split(' ')\n\... | [
"0.55360186",
"0.5124106",
"0.5096552",
"0.5074441",
"0.5036425",
"0.49875963",
"0.49749434",
"0.4938649",
"0.4931775",
"0.49261597",
"0.48441556",
"0.4823751",
"0.47443646",
"0.46914992",
"0.46750745",
"0.46672103",
"0.46231896",
"0.46168032",
"0.45954028",
"0.4571667",
"0.4... | 0.5183655 | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.