= 0 and ystart >= 0:\\n self.xstart = xstart\\n self.ystart = ystart\\n elif (self.width, self.height) == (240, 240):\\n self.xstart = 0\\n self.ystart = 0\\n elif (self.width, self.height) == (135, 240):\\n self.xstart = 52\\n self.ystart = 40\\n else:\\n raise ValueError(\\n \\\"Unsupported display. Only 240x240 and 135x240 are supported \\\"\\n \\\"without xstart and ystart provided\\\"\\n )\\n\\n self.init_pins()\\n if self.rst is not None:\\n self.reset()\\n else:\\n self.soft_reset()\\n self.init()\",\n \"def __init__(self, config):\\n spi = SPI(-1, baudrate=config.baudrate,\\n sck=config.sck, mosi=config.mosi, miso=config.miso)\\n self._epd = epaper2in9.EPD(spi, config.cs, config.dc,\\n config.rst1, config.busy)\\n self._epd.init()\\n self._buffer = Buffer(epaper2in9.EPD_WIDTH, epaper2in9.EPD_HEIGHT)\",\n \"def _init_config(self, width, height, spi=None, spiMosi= None, spiDC=None, spiCS=None, spiReset=None, spiClk=None):\\n self._spi = spi\\n self._spi_mosi = spiMosi\\n self._spi_dc = spiDC\\n self._spi_cs = spiCS\\n self._spi_reset = spiReset\\n self._spi_clk = spiClk\\n\\n self.width = width\\n self.height = height\",\n \"def init_buffer(self):\\n \\n self.shape.buf = [pi3d.Buffer(self.shape, self.verts, self.texcoords, self.inds, self.norms)]\\n self.shape.set_draw_details(self.shader, [self.spritesheet.img])\",\n \"def init_point_buffer(self, configurations={}):\\n\\n # initialize buffer configuration to indicate that the\\n # buffers are not setup in case this function got a problem\\n self.buffer_configuration = None\\n\\n # create new buffer configuration\\n buffer_configurations = {}\\n for name, configuration in configurations.items():\\n buffer_configurations[name] = self._init_plot_buffer(configuration)\\n\\n self.buffer_configuration = buffer_configurations\",\n \"def __init__(self, commands: dict):\\n self.__commands = commands\\n\\n # Wait times (s).\\n self.WT_PIN_TOGGLE = 0.2\\n self.WT_STATE_LOOKUP = 0.1\\n\\n # GPIO pins.\\n self.RST_PIN = 17\\n self.DC_PIN = 25\\n self.CS_PIN = 8\\n self.BUSY_PIN = 24\\n\\n # Set GPIO pins.\\n RPi.GPIO.setmode(RPi.GPIO.BCM)\\n RPi.GPIO.setwarnings(False)\\n RPi.GPIO.setup(self.RST_PIN, RPi.GPIO.OUT)\\n RPi.GPIO.setup(self.DC_PIN, RPi.GPIO.OUT)\\n RPi.GPIO.setup(self.CS_PIN, RPi.GPIO.OUT)\\n RPi.GPIO.setup(self.BUSY_PIN, RPi.GPIO.IN)\\n\\n # SPI device.\\n self.__spi = spidev.SpiDev(0, 0)\\n\\n # Set SPI device.\\n self.__spi.max_speed_hz = 2000000\\n self.__spi.mode = 0b00\",\n \"def initiate():\\n\\n log = \\\"Initiate the SPI communication of the OPC-N3\\\"\\n logger.debug(log)\\n\\n time.sleep(1)\\n log = \\\"Sending bytes to the sensor...\\\"\\n logger.debug(log)\\n spi.writebytes([0x5A, 0x01])\\n reading = spi.readbytes(3)\\n log = \\\"Data read after sending bytes are: \\\" + str(reading)\\n logger.debug(log)\\n time.sleep(wait_between_bytes)\\n\\n log = \\\"Sending bytes to the sensor...\\\"\\n logger.debug(log)\\n spi.writebytes([0x5A, 0x03])\\n reading = spi.readbytes(9)\\n log = \\\"Bytes read after sending bytes are: \\\" + str(reading)\\n logger.debug(log)\\n time.sleep(wait_between_bytes)\\n\\n # SPI conncetion\\n log = \\\"Sending bytes to the sensor...\\\"\\n logger.debug(log)\\n spi.writebytes([0x5A, 0x02, 0x92, 0x07])\\n reading = spi.readbytes(2)\\n log = \\\"Bytes read after sending bytes are: \\\" + str(reading)\\n logger.debug(log)\\n time.sleep(wait_between_bytes)\\n\\n return\",\n \"def __init__(self, stencil_coefs, loffset, roffset):\\n self.stencil_coefs = stencil_coefs\\n self.loffset = loffset\\n self.roffset = roffset\",\n \"def spi_controller(\\n # ---[ Module Ports]---\\n glbl, # global interface, clock, reset, etc.\\n spibus, # external SPI bus\\n # optional ports\\n fifobus=None, # streaming interface, FIFO bus\\n mmbus=None, # memory-mapped bus, contro status access\\n cso=None, # control-status object\\n \\n # ---[ Module Parameters ]---\\n include_fifo=True, # include aan 8 byte deep FIFO\\n):\\n clock, reset = glbl.clock, glbl.reset\\n if cso is None:\\n cso = spi_controller.cso()\\n\\n # -- local signals --\\n ena = Signal(False)\\n clkcnt = Signal(modbv(0, min=0, max=2**12))\\n bcnt = Signal(intbv(0, min=0, max=8))\\n\\n # separate tx and rx shift-registers (could be one in the same)\\n treg = Signal(intbv(0)[8:]) # tx shift register\\n rreg = Signal(intbv(0)[8:]) # rx shift register\\n\\n x_sck, x_ss, x_mosi, x_miso = Signals(bool(0), 4)\\n\\n # internal FIFO bus interfaces\\n # external FIFO side (FIFO to external SPI bus)\\n itx = FIFOBus(size=fifobus.size, width=fifobus.width)\\n # internal FIFO side (FIFO to internal bus)\\n irx = FIFOBus(size=fifobus.size, width=fifobus.width)\\n \\n states = enum('idle', 'wait_hclk', 'data_in', 'data_change',\\n 'write_fifo', 'end')\\n state = Signal(states.idle)\\n\\n # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n # memory- mapped registers\\n # add the peripheral's regfile to the bus (informational only)\\n # @todo: the automatic building of the register files is incomplete\\n if mmbus is not None:\\n # the register-file (rf) will drive all the cso signals\\n rf = cso.get_register_file()\\n mmbus.add(rf, 'spi')\\n\\n # FIFO for the wishbone data transfer\\n if include_fifo:\\n fifo_fast.debug = spi_controller.debug\\n fifo_tx_inst = fifo_fast(reset, clock, itx)\\n fifo_rx_inst = fifo_fast(reset, clock, irx)\\n\\n @always_comb\\n def rtl_assign():\\n cso.tx_fifo_count.next = itx.count\\n cso.rx_fifo_count.next = irx.count\\n\\n if clkcnt > 0:\\n ena.next = False\\n else:\\n ena.next = True\\n\\n clock_counts = tuple([(2**ii)-1 for ii in range(13)])\\n\\n @always(clock.posedge)\\n def rtl_clk_div():\\n if cso.enable and clkcnt != 0 and state != states.idle:\\n clkcnt.next = (clkcnt - 1)\\n else:\\n clkcnt.next = clock_counts[cso.clock_divisor]\\n\\n @always_seq(clock.posedge, reset=reset)\\n def rtl_state_and_more():\\n \\\"\\\"\\\"\\n Designed to the following timing diagram\\n\\n SCK CPOL=0 ______/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\ \\n CPOL=1 ------\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/ \\n SS ---\\\\_______________________________________________________________________ \\n CPHA=0 MOSI ...|.0....|.1.....|.2.....|.3.....|.4.....|.5.....|.6.....|.7.....|.0.....| \\n MISO ...|.0....|.1.....|.2.....|.3.....|.4.....|.5.....|.6.....|.7.....|.0.....| \\n CPHA=1 MOSI ...|....0.....|.1.....|.2.....|.3.....|.4.....|.5.....|.6.....|.7.....|.0...\\n MISO ......|.0.....|.1.....|.2.....|.3.....|.4.....|.5.....|.6.....|.7.....|.0...\\n \\\"\\\"\\\"\\n if not cso.enable:\\n state.next = states.idle\\n bcnt.next = 0\\n treg.next = 0\\n \\n itx.read.next = False\\n irx.write.next = False\\n\\n x_sck.next = False\\n x_ss.next = False\\n else:\\n if not cso.freeze:\\n # ~~~~ Idle state ~~~~\\n if state == states.idle:\\n bcnt.next = 7\\n treg.next = itx.read_data\\n x_sck.next = cso.clock_polarity\\n irx.write.next = False\\n \\n if not itx.empty and not irx.full:\\n itx.read.next = True\\n x_ss.next = False\\n if cso.clock_phase: # Clock in on second phase\\n state.next = states.wait_hclk\\n else: # Clock in on first phase\\n state.next = states.data_in\\n else:\\n itx.read.next = False\\n x_ss.next = True\\n\\n # ~~~~ Wait half clock period for cpha=1 ~~~~\\n elif state == states.wait_hclk:\\n itx.read.next = False\\n irx.write.next = False\\n if ena:\\n x_sck.next = not x_sck\\n state.next = states.data_in\\n\\n # ~~~~ Clock data in (and out) ~~~~\\n elif state == states.data_in:\\n itx.read.next = False\\n irx.write.next = False\\n if ena: # clk div\\n x_sck.next = not x_sck\\n rreg.next = concat(rreg[7:0], x_miso)\\n \\n if cso.clock_phase and bcnt == 0:\\n irx.write.next = True\\n if itx.empty or irx.full:\\n state.next = states.end\\n else:\\n state.next = states.data_change\\n else:\\n state.next = states.data_change\\n\\n # ~~~~ Get ready for next byte out/in ~~~~\\n elif state == states.data_change:\\n itx.read.next = False\\n irx.write.next = False\\n if ena:\\n x_sck.next = not x_sck\\n if bcnt == 0: \\n if not cso.clock_phase:\\n irx.write.next = True\\n \\n if itx.empty or irx.full:\\n state.next = states.end\\n else: # more data to transfer\\n bcnt.next = 7\\n state.next = states.data_in\\n itx.read.next = True\\n treg.next = itx.read_data\\n else:\\n treg.next = concat(treg[7:0], intbv(0)[1:])\\n bcnt.next = bcnt - 1 \\n state.next = states.data_in\\n\\n # ~~~~ End state ~~~~\\n elif state == states.end:\\n itx.read.next = False\\n irx.write.next = False\\n if ena: # Wait half clock cycle go idle\\n state.next = states.idle\\n\\n # Shouldn't happen, error in logic\\n else:\\n state.next = states.idle\\n assert False, \\\"SPI Invalid State\\\"\\n\\n @always_comb\\n def rtl_fifo_sel():\\n \\\"\\\"\\\"\\n The `itx` and `irx` FIFO interfaces are driven by different\\n logic depending on the configuration. This modules accesses\\n the `itx` read side and drives the `irx` write side. The\\n `itx` write side is driven by the `cso` or the `fifobus` port.\\n The `irx` read side is accessed by the `cso` or the `fifobus`\\n port.\\n \\\"\\\"\\\"\\n if cso.bypass_fifo:\\n # data comes from the register file\\n cso.tx_empty.next = itx.empty\\n cso.tx_full.next = itx.full\\n itx.write_data.next = cso.tx_byte\\n\\n cso.rx_empty.next = irx.empty\\n cso.rx_full.next = irx.full\\n cso.rx_byte.next = irx.read_data\\n cso.rx_byte_valid.next = irx.read_valid\\n\\n # @todo: if cso.tx_byte write signal (written by bus) drive the\\n # @todo: FIFO write signals, same if the cso.rx_byte is accessed\\n itx.write.next = cso.tx_write\\n irx.read.next = cso.rx_read\\n\\n else:\\n # data comes from external FIFO bus interface\\n fifobus.full.next = itx.full\\n itx.write_data.next = fifobus.write_data\\n itx.write.next = fifobus.write\\n\\n fifobus.empty.next = irx.empty\\n fifobus.read_data.next = irx.read_data\\n fifobus.read_valid.next = irx.read_valid\\n irx.read.next = fifobus.read\\n\\n # same for all modes\\n irx.write_data.next = rreg\\n\\n @always_comb\\n def rtl_x_mosi():\\n # @todo lsb control signal\\n x_mosi.next = treg[7]\\n\\n @always_comb\\n def rtl_gate_mosi():\\n if cso.loopback:\\n spibus.mosi.next = False\\n else:\\n spibus.mosi.next = x_mosi\\n\\n @always_comb #(clock.posedge)\\n def rtl_spi_sigs():\\n spibus.sck.next = x_sck\\n if cso.loopback:\\n x_miso.next = x_mosi\\n else:\\n x_miso.next = spibus.miso\\n\\n @always_comb\\n def rtl_slave_select():\\n if cso.manual_slave_select:\\n spibus.ss.next = ~cso.slave_select\\n elif x_ss:\\n spibus.ss.next = 0xFF\\n else:\\n spibus.ss.next = ~cso.slave_select\\n\\n # myhdl generators in the __debug__ conditionals are not converted.\\n if spi_controller.debug:\\n @instance\\n def mon_state():\\n print(\\\" :{:<8d}: initial state {}\\\".format(\\n now(), str(state)))\\n \\n while True:\\n yield state\\n print(\\\" :{:<8d}: state transition --> {}\\\".format(\\n now(), str(state)))\\n \\n fbidle = intbv('0000')[4:]\\n\\n @instance\\n def mon_trace():\\n while True:\\n yield clock.posedge\\n ccfb = concat(itx.write, itx.read, irx.write, irx.read)\\n if ccfb != fbidle:\\n fstr = \\\" :{:<8d}: tx: w{} r{}, f{} e{}, rx: w{} r{} f{} e{}\\\"\\n print(fstr.format(now(),\\n int(itx.write), int(itx.read), int(itx.full), int(itx.empty),\\n int(irx.write), int(irx.read), int(irx.full), int(irx.empty),)\\n )\\n \\n @always(clock.posedge)\\n def mon_tx_fifo_write():\\n if itx.write:\\n print(\\\" WRITE tx fifo {:02X}\\\".format(int(itx.write_data)))\\n if itx.read:\\n print(\\\" READ tx fifo {:02X}\\\".format(int(itx.read_data)))\\n \\n @always(clock.posedge)\\n def mon_rx_fifo_write():\\n if irx.write:\\n print(\\\" WRITE rx fifo {:02X}\\\".format(int(irx.write_data)))\\n \\n if irx.read:\\n print(\\\" READ rx fifo {:02X}\\\".format(int(irx.read_data)))\\n\\n # return the myhdl generators\\n gens = myhdl.instances()\\n return gens\",\n \"def __init__(self, font=None):\\n self._xPosition = 0\\n self._yPosition = 0\\n self._positionDegree = 0\\n self._velocityMag = 0\\n self._velocityDegree = 0\\n self._accelerationMag = 0\\n self._accelerationDegree = 0\\n self._thrusters = None\\n self._SASmodules = None\\n\\n if font is None:\\n self._font = pg.font.SysFont(\\\"Futura\\\", 20)\\n else:\\n self._font = font\",\n \"def __init__(self):\\r\\n # Check device ID.\\r\\n chip_id = self._read_byte(_BME280_REGISTER_CHIPID)\\r\\n if _BME280_CHIPID != chip_id:\\r\\n raise RuntimeError('Failed to find BME280! Chip ID 0x%x' % chip_id)\\r\\n self._write_register_byte(_BME280_REGISTER_SOFTRESET, 0xB6)\\r\\n time.sleep(0.5)\\r\\n self._read_coefficients()\\r\\n self.sea_level_pressure = 1013.25\\r\\n \\\"\\\"\\\"Pressure in hectoPascals at sea level. Used to calibrate `altitude`.\\\"\\\"\\\"\\r\\n # turn on humidity oversample 16x\\r\\n self._write_register_byte(_BME280_REGISTER_CTRL_HUM, 0x03)\\r\\n self._t_fine = None\",\n \"def __init__(self, spi_rack, module, max_current=50e-3, reset_currents=True):\\n self.spi_rack = spi_rack\\n self.module = module\\n self.span = [np.NaN]*4\\n self.currents = [np.NaN]*4\\n self.max_current = max_current\\n\\n for i in range(4):\\n self.get_settings(i)\\n\\n if reset_currents:\\n for i in range(4):\\n self.change_span(i, S4g_module.range_max_bi)\\n self.set_current(i, 0.0)\",\n \"def __init__(self, verbose=False):\\n self._verbose = verbose\\n self._nSrv = 2\\n toLog(\\\"Initializing ...\\\", True)\\n\\n # Create servo manager and servos ...\\n self.SM = ServoManager(self._nSrv, verbose=verbose)\\n self._Servos = []\\n self._SPos = array.array('i', [0] *self._nSrv)\\n self._SIDs = array.array('b', [SRV_PAN, SRV_TLT])\\n self._Servos.append(Servo(board.SERVO_PAN, verbose=verbose))\\n self._Servos[SRV_PAN].change_range(board.PAN_RANGE_US, board.PAN_RANGE_DEG)\\n self.SM.add_servo(SRV_PAN, self._Servos[SRV_PAN])\\n self._Servos.append(Servo(board.SERVO_TLT, verbose=verbose))\\n self._Servos[SRV_TLT].change_range(board.TLT_RANGE_US, board.TLT_RANGE_DEG)\\n self.SM.add_servo(SRV_TLT, self._Servos[SRV_TLT])\\n toLog(\\\"Servo manager ready\\\", True)\\n\\n # Create spectrometer instance\\n self.SP = C12880MA(trg=board.TRG, st=board.STA, clk=board.CLK, video=board.VID)\\n self.SP.begin()\\n self.SP.setIntegrationTime_s(0.01)\\n time.sleep_ms(200)\\n toLog(\\\"Spectrometer ready\\\", True)\",\n \"def setup(self):\\n if not self._gpio_setup:\\n if self._gpio is None:\\n try:\\n import RPi.GPIO as GPIO\\n self._gpio = GPIO\\n except ImportError:\\n raise ImportError('This library requires the RPi.GPIO module\\\\nInstall with: sudo apt install python-rpi.gpio')\\n self._gpio.setmode(self._gpio.BCM)\\n self._gpio.setwarnings(False)\\n self._gpio.setup(self.cs_pin, self._gpio.OUT)\\n self._gpio.setup(self.dc_pin, self._gpio.OUT, initial=self._gpio.LOW, pull_up_down=self._gpio.PUD_OFF)\\n self._gpio.setup(self.reset_pin, self._gpio.OUT, initial=self._gpio.HIGH, pull_up_down=self._gpio.PUD_OFF)\\n self._gpio.setup(self.busy_pin, self._gpio.IN, pull_up_down=self._gpio.PUD_OFF)\\n\\n if self._spi_bus is None:\\n import spidev\\n self._spi_bus = spidev.SpiDev()\\n\\n self._spi_bus.open(0, self.cs_channel)\\n self._spi_bus.no_cs = True\\n self._spi_bus.max_speed_hz = 5000000\\n\\n self._gpio_setup = True\\n\\n self._gpio.output(self.reset_pin, self._gpio.LOW)\\n time.sleep(0.1)\\n self._gpio.output(self.reset_pin, self._gpio.HIGH)\\n time.sleep(0.1)\\n\\n self._gpio.output(self.reset_pin, self._gpio.LOW)\\n time.sleep(0.1)\\n self._gpio.output(self.reset_pin, self._gpio.HIGH)\\n\\n self._busy_wait(1.0)\\n\\n # Sending init commands to display\\n self._send_command(AC073TC1_CMDH, [0x49, 0x55, 0x20, 0x08, 0x09, 0x18])\\n\\n self._send_command(AC073TC1_PWR, [0x3F, 0x00, 0x32, 0x2A, 0x0E, 0x2A])\\n\\n self._send_command(AC073TC1_PSR, [0x5F, 0x69])\\n\\n self._send_command(AC073TC1_POFS, [0x00, 0x54, 0x00, 0x44])\\n\\n self._send_command(AC073TC1_BTST1, [0x40, 0x1F, 0x1F, 0x2C])\\n\\n self._send_command(AC073TC1_BTST2, [0x6F, 0x1F, 0x16, 0x25])\\n\\n self._send_command(AC073TC1_BTST3, [0x6F, 0x1F, 0x1F, 0x22])\\n\\n self._send_command(AC073TC1_IPC, [0x00, 0x04])\\n\\n self._send_command(AC073TC1_PLL, [0x02])\\n\\n self._send_command(AC073TC1_TSE, [0x00])\\n\\n self._send_command(AC073TC1_CDI, [0x3F])\\n\\n self._send_command(AC073TC1_TCON, [0x02, 0x00])\\n\\n self._send_command(AC073TC1_TRES, [0x03, 0x20, 0x01, 0xE0])\\n\\n self._send_command(AC073TC1_VDCS, [0x1E])\\n\\n self._send_command(AC073TC1_T_VDCS, [0x00])\\n\\n self._send_command(AC073TC1_AGID, [0x00])\\n\\n self._send_command(AC073TC1_PWS, [0x2F])\\n\\n self._send_command(AC073TC1_CCSET, [0x00])\\n\\n self._send_command(AC073TC1_TSSET, [0x00])\",\n \"def __init__(self, esp_mgr):\\n self.esp_mgr = esp_mgr\\n adafruit_esp32spi_socket.set_interface(self.esp_mgr.esp)\\n self.inbuffer = ''\\n self.cmds = []\\n self.next_fn = self.state_text\\n self.telnet_cmd = []\\n self.client_socket = None\\n self.server_socket = None\\n self.termious = None # termious hack\\n self.current_state = ''\",\n \"def init_serial():\\n\\tglobal D\\n\\t# start serial connection\\n\\tbaud = 9600\\n\\ttry:\\n\\t\\tD.gps_serial = serial.Serial(\\\"/dev/ttyAMA0\\\",baud,timeout=1)\\n\\t\\tD.gps_serial.open()\\n\\t\\tD.gps_serial.write(\\\"$PMTK220,200*2C\\\")\\n\\t\\tD.gps_serial.write(\\\"$PMTK300,200,0,0,0,0*2F\\\")\\n\\texcept:\\n\\t\\tprint \\\"Failed to open serial\\\"\\n\\t\\trospy.shutdown(\\\"Failed to open gps serial\\\")\",\n \"def __init__(self, pitch=30, pitch_type='duo', Z=4, Alt = 100):\\n \\n self.pitch_type = pitch_type\\n self.pitch = pitch\\n self.Z = Z\\n self.Alt = Alt\\n \\n \\n # set the Ce value (exposure coeff NA 2.16)\\n self.Ce = 1\\n \\n # set the Ct value (thermal coeff NA 2.17)\\n self.Ct = 1\\n \\n # snow load shjape coefficients\\n if self.pitch_type == 'mono':\\n if self.pitch <= 30:\\n self.mu = 0.80\\n elif 30 < self.pitch <= 60:\\n self.mu = 0.80 * (60 - self.pitch) / 30\\n else:\\n self.mu = 0.0\\n elif self.pitch_type == 'duo':\\n if self.pitch <= 15:\\n self.mu = 0.80\\n elif 15 < self.pitch <= 30:\\n self.mu = 0.80 + 0.40*(self.pitch - 15) / 15\\n elif 30 < self.pitch <= 60:\\n self.mu = 1.2*(60 - self.pitch) / 30\\n else:\\n self.mu = 0.0\\n else:\\n self.mu = 0.80 # end conservative number\\n \\n # calculate the value of the snow load on the ground \\n self.sk = (0.15 + (0.1 * self.Z + 0.05) + ((self.Alt - 100) / 525))\\n \\n # calculate the roof snow load\\n self.s = self.mu * self.Ce * self.Ct * self.sk\",\n \"def __init__(self):\\n self._read_calibration_data()\\n self.configure_sensor(\\n TemperatureOversamplings.x08,\\n PressureOversamplings.x16,\\n HumidityOversamplings.x08,\\n IIRFilterCoefficients.FC_003,\\n 250,\\n 250)\",\n \"def __init__(self, device = '/dev/spidev0.0', delay = 40, speed = 200000, bits = 8,Port=None,Server=None):\\n self.Port = Port\\n self.Server=Server\\n if self.Server != None:\\n self.Transaction=self._NetTransaction\\n else:\\n if self.Port != None: # Init Server Thread\\n self.ServerThread = threading.Thread(target=self.ListenerTread)\\n self.ServerThread.start()\\n self.Bits = c_uint8(bits)\\n self.Speed = self.WriteSpeed\\n self.Delay = c_uint16(delay)\\n self.Device = device\\n self.File = posix.open(self.Device, posix.O_RDWR)\\n self.SetBits()\\n self.SetSpeed()\",\n \"def use_spi():\\n _LIB.oled_click_use_spi()\",\n \"def qspi_init(self, retain_ram=False, init_params=None):\\n class _CtypesQSPIInitParams(ctypes.Structure):\\n _fields_ = [(\\\"read_mode\\\", ctypes.c_int), (\\\"write_mode\\\", ctypes.c_int), (\\\"address_mode\\\", ctypes.c_int), (\\\"frequency\\\", ctypes.c_int), (\\\"spi_mode\\\", ctypes.c_int), (\\\"sck_delay\\\", ctypes.c_uint32), (\\\"custom_instruction_io2_level\\\", ctypes.c_int), (\\\"custom_instruction_io3_level\\\", ctypes.c_int), (\\\"CSN_pin\\\", ctypes.c_uint32), (\\\"CSN_port\\\", ctypes.c_uint32), (\\\"SCK_pin\\\", ctypes.c_uint32), (\\\"SCK_port\\\", ctypes.c_uint32), (\\\"DIO0_pin\\\", ctypes.c_uint32), (\\\"DIO0_port\\\", ctypes.c_uint32), (\\\"DIO1_pin\\\", ctypes.c_uint32), (\\\"DIO1_port\\\", ctypes.c_uint32), (\\\"DIO2_pin\\\", ctypes.c_uint32), (\\\"DIO2_port\\\", ctypes.c_uint32), (\\\"DIO3_pin\\\", ctypes.c_uint32), (\\\"DIO3_port\\\", ctypes.c_uint32), (\\\"WIP_index\\\", ctypes.c_uint32), (\\\"pp_size\\\", ctypes.c_int)]\\n \\n if not self._is_bool(retain_ram):\\n raise ValueError('The retain_ram parameter must be a boolean value.')\\n \\n if not self._is_right_class(init_params, QSPIInitParams) and init_params is not None:\\n raise ValueError('The init_params parameter must be an instance of class QSPIInitParams.')\\n \\n if init_params is None:\\n init_params = QSPIInitParams()\\n\\n retain_ram = ctypes.c_bool(retain_ram)\\n qspi_init_params = _CtypesQSPIInitParams(init_params.read_mode, init_params.write_mode, init_params.address_mode, init_params.frequency, init_params.spi_mode, init_params.sck_delay, init_params.custom_instruction_io2_level, init_params.custom_instruction_io3_level, init_params.CSN_pin, init_params.CSN_port, init_params.SCK_pin, init_params.SCK_port, init_params.DIO0_pin, init_params.DIO0_port, init_params.DIO1_pin, init_params.DIO1_port, init_params.DIO2_pin, init_params.DIO2_port, init_params.DIO3_pin, init_params.DIO3_port, init_params.WIP_index, init_params.pp_size)\\n \\n result = self._lib.NRFJPROG_qspi_init(retain_ram, ctypes.byref(qspi_init_params))\\n if result != NrfjprogdllErr.SUCCESS:\\n raise APIError(result)\",\n \"def __init__(self):\\r\\n super().__init__()\\r\\n self._name = \\\"PICOSCOPE2408b\\\"\\r\\n self._lib = None\\r\\n self._handle = None\\r\\n self._run_lock = Lock()\\r\\n self._driver_lock = Lock()\\r\\n\\r\\n self._sampling_time = 4E-9\\r\\n self._sampling_duration = 50E-6\\r\\n self._pulse_time = 100E-9\\r\\n self._samples = int(self._sampling_duration / self._sampling_time)\\r\\n self._idx = 0\\r\\n\\r\\n w_len = self._samples\\r\\n location = 0.1\\r\\n idx1 = int(w_len*(location - self._pulse_time/(2*self._sampling_duration)))\\r\\n idx2 = int(w_len*(location + self._pulse_time/(2*self._sampling_duration))) - 1\\r\\n self._waveform = np.array([-1*MAX_EXT if (i < idx1 or i >= idx2) else MAX_EXT for i in range(w_len)],dtype=c_int16)\\r\\n\\r\\n self._A_data = np.ones(self._samples)*2\\r\\n self._B_data = np.ones(self._samples)*-2\\r\\n self._C_data = np.ones(self._samples)*0\\r\\n self._window_est = np.ones(self._samples)*0\\r\\n self._t = np.linspace(0,self._sampling_duration,self._samples)\\r\\n self._range_A = None\\r\\n self._range_B = None\\r\\n self._depol_ratio = None\\r\\n\\r\\n self._process_queue = Queue()\\r\\n self._save_queue = Queue()\",\n \"def __init__(self):\\n self.ram = bytearray(256)\\n self.register = [0] * 8\\n self.pc = 0\\n self.sp = 7\",\n \"def __init__(sp, line) :\\n ## frameNumber, eventName, photonEnergyEv, wavelengthA, GMD, peak_index, peak_x_raw, peak_y_raw, peak_r_assembled, peak_q, peak_resA, nPixels, totalIntensity, maxIntensity, sigmaBG, SNR\\n #5, LCLS_2015_Feb22_r0169_022047_197ee, 6004.910515, 2.064714, 4.262349, 29997, 508.884796, 19.449471, 441.314606, 1.741234, 5.743053, 5, 361.105774, 112.819145, 19.236982, 18.771435\\n\\n sp.line = line[:-1] #.rstrip('\\\\n') # .replace(',',' ')\\n sp.fields = sp.line.split()\\n\\n s_frameNumber, s_eventName, s_photonEnergyEv, s_wavelengthA, s_GMD, s_peak_index, s_peak_x_raw, s_peak_y_raw,\\\\\\n s_peak_r_assembled, s_peak_q, s_peak_resA, s_nPixels, s_totalIntensity, s_maxIntensity, s_sigmaBG, s_SNR =\\\\\\n sp.fields[0:16]\\n\\n sp.frameNumber, sp.photonEnergyEv, sp.wavelengthA = int(s_frameNumber), float(s_photonEnergyEv), float(s_wavelengthA)\\n sp.GMD, sp.peak_index, sp.peak_x_raw, sp.peak_y_raw = float(s_GMD), int(s_peak_index), float(s_peak_x_raw), float(s_peak_y_raw)\\n sp.peak_r_assembled, sp.peak_q, sp.peak_resA, sp.nPixels = float(s_peak_r_assembled), float(s_peak_q), float(s_peak_resA), int(s_nPixels)\\n sp.totalIntensity, sp.maxIntensity, sp.sigmaBG, sp.SNR = float(s_totalIntensity), float(s_maxIntensity), float(s_sigmaBG), float(s_SNR)\\n\\n sp.runnum, sp.tstamp, sp.tsec, sp.s_fid = convertCheetahEventName(s_eventName)\\n sp.fid = int(sp.s_fid, 16)\\n\\n #sp.seg, sp.row, sp.col = src_from_rc8x8(sp.peak_y_raw, sp.peak_x_raw)\\n\\n sp.line = line\\n sp.empty = sp.empty_line()\",\n \"def teleopInit(self):\\n self.Drive.resetEncoder()\\n\\n self.Drive.disableAutoForward()\\n self.Drive.disableAutoTurn()\\n self.Drive.disableVision()\\n\\n self.DS.setWhichVariable(True)\\n self.Drive.updateSetpoint(\\\"teleop\\\")\\n self.DS.setFirstTimeVariable(True)\\n self.timer.reset()\\n\\n self.matchTime.startMode(isAuto=False)\",\n \"def __init__(self, gameCanvas, specs):\\n\\t\\n\\t\\t# Initialization of the Dot\\n\\t\\tsuper(Dot, self).__init__(gameCanvas, specs, specs['points'])\\n\\t\\t\\n\\t\\t# Draw the Dot\\n\\t\\tself.draw()\",\n \"def setup(self, gl_buffers, color_vbo, pos_vbo, partNumber):\\n self.gl_objects = gl_buffers\\n self.color_vbo, self.pos_vbo = color_vbo, pos_vbo\\n self.partNumber = partNumber\",\n \"def __init__(self):\\n self.tape_tag = None\\n self.independentVariableShapeList = []\\n self.dependentVariableShapeList = []\",\n \"def init(self):\\n self.reset()\\n\\n self.__interface.send_command('POWER_SETTING')\\n self.__interface.send_data(0x37)\\n self.__interface.send_data(0x00)\\n\\n self.__interface.send_command('PANEL_SETTING')\\n self.__interface.send_data(0xCF)\\n self.__interface.send_data(0x08)\\n\\n self.__interface.send_command('BOOSTER_SOFT_START')\\n self.__interface.send_data(0xc7)\\n self.__interface.send_data(0xcc)\\n self.__interface.send_data(0x28)\\n\\n self.__interface.send_command('POWER_ON')\\n self.wait_until_idle()\\n\\n self.__interface.send_command('PLL_CONTROL')\\n self.__interface.send_data(0x3c)\\n\\n self.__interface.send_command('TEMPERATURE_CALIBRATION')\\n self.__interface.send_data(0x00)\\n\\n self.__interface.send_command('VCOM_AND_DATA_INTERVAL_SETTING')\\n self.__interface.send_data(0x77)\\n\\n self.__interface.send_command('TCON_SETTING')\\n self.__interface.send_data(0x22)\\n\\n self.__interface.send_command('TCON_RESOLUTION')\\n self.__interface.send_data(0x02) #source 640\\n self.__interface.send_data(0x80)\\n self.__interface.send_data(0x01) #gate 384\\n self.__interface.send_data(0x80)\\n\\n self.__interface.send_command('VCM_DC_SETTING')\\n self.__interface.send_data(0x1E) #decide by LUT file\\n\\n self.__interface.send_command(0xe5, False) #FLASH MODE\\n self.__interface.send_data(0x03)\",\n \"def __init__(self):\\r\\n try:\\r\\n print(f\\\"Connecting to Arduino on '{self._SERIAL_PORT}'...\\\", end='')\\r\\n self.ser = serial.Serial(self._SERIAL_PORT, self._BAUD, timeout=self._TIMEOUT)\\r\\n # Reset buffers to start with a clean slate\\r\\n self.ser.reset_input_buffer()\\r\\n self.ser.reset_output_buffer()\\r\\n print(\\\"Ok\\\")\\r\\n except serial.SerialException as e:\\r\\n print(\\\"Failed:\\\", e)\",\n \"def __init__(self):\\n this = _libsbml.new_SBO()\\n try: self.this.append(this)\\n except: self.this = this\",\n \"def __init__(self, **stn_dict):\\n self._last_rain = None\\n\\n global DEBUG_READ\\n DEBUG_READ = int(stn_dict.get('debug_read', 0))\\n global DEBUG_DECODE\\n DEBUG_DECODE = int(stn_dict.get('debug_decode', 0))\\n global DEBUG_PRESSURE\\n DEBUG_PRESSURE = int(stn_dict.get('debug_pressure', 0))\\n\\n self.model = stn_dict.get('model', 'TE923')\\n self.max_tries = int(stn_dict.get('max_tries', 5))\\n self.retry_wait = int(stn_dict.get('retry_wait', 30))\\n self.polling_interval = int(stn_dict.get('polling_interval', 10))\\n self.sensor_map = stn_dict.get('sensor_map', DEFAULT_SENSOR_MAP)\\n self.battery_map = stn_dict.get('battery_map', DEFAULT_BATTERY_MAP)\\n self.memory_size = stn_dict.get('memory_size', 'small')\\n\\n vendor_id = int(stn_dict.get('vendor_id', '0x1130'), 0)\\n product_id = int(stn_dict.get('product_id', '0x6801'), 0)\\n device_id = stn_dict.get('device_id', None)\\n\\n loginf('driver version is %s' % DRIVER_VERSION)\\n loginf('polling interval is %s' % str(self.polling_interval))\\n loginf('sensor map is %s' % self.sensor_map)\\n loginf('battery map is %s' % self.battery_map)\\n\\n self.station = TE923(vendor_id, product_id, device_id,\\n memory_size=self.memory_size)\\n self.station.open()\",\n \"def __init__(self):\\n self.ram = [0] * 256\\n self.reg = [0] * 8\\n self.pc = 0\\n self.SP = 7\\n self.reg[self.SP] = 0xf4\\n self.E = 0\\n self.L = 0\\n self.G = 0\",\n \"def setUp(self):\\n self.ser = Serial()\\n self.device_obj = ZBSensor(self.ser)\",\n \"def __init__ (self, nTel=0, centroid=(-0.5, 0.5), length=(0.005, 0.09), width=(0.0005, 0.003), psi=(0, 360), nsb=(10, 60)) :\\n super().__init__ (nTel)\\n self.centroid = [centroid, centroid]\\n self.length, self.width = length, width\\n self.psi = psi\\n self.nsb = nsb\\n self.tab_inj, self.mat_event, self.geom = None, None, None\\n self.load_telescope()\",\n \"def _init_io(self):\\n GPIO.setwarnings(False)\\n GPIO.setmode( GPIO.BCM )\\n pins = [ self._spi_dc ]\\n for pin in pins:\\n GPIO.setup( pin, GPIO.OUT )\",\n \"def initialize(self):\\n self.log.info(\\\"Initialize raspPinball hardware.\\\")\\n\\n self.config = self.machine.config['rasppinball']\\n self.machine.config_validator.validate_config(\\\"rasppinball\\\", self.config)\\n print(\\\"***************************\\\")\\n print(self.config)\\n #self.machine_type = (\\n # self.machine.config['hardware']['driverboards'].lower())\\n\\n self._connect_to_hardware()\\n\\n\\n # keypad\\n self._kp = Keypad()\\n self.old_key = \\\"\\\"\\n self.key = \\\"\\\"\\n # leds\\n self.init_strips()\",\n \"def __init__(self, device):\\n self.device = device\\n self.io = serial.Serial(device, 57600, timeout=1)\\n self.keys = ['time', 'centroid_x', 'centroid_y', 'centroid_r',\\n 'level_1', 'level_2', 'level_3',\\n 'width_1', 'width_2', 'width_3',\\n 'height_1', 'height_2', 'height_3',\\n 'power']\",\n \"def __init__(self, pitch, color, our_side, video_port=0, comm_port='/dev/ttyACM0', penalty=False, comms=1):\\n assert pitch in [0, 1]\\n assert color in ['yellow', 'blue']\\n assert our_side in ['left', 'right']\\n\\n self.pitch = pitch\\n\\n # Set up the Arduino communications\\n self.arduino = Arduino(comm_port, 115200, 1, comms)\\n\\n # Set up camera for frames\\n self.camera = Camera(port=video_port, pitch=self.pitch)\\n frame = self.camera.get_frame()\\n center_point = self.camera.get_adjusted_center(frame)\\n\\n # Set up vision\\n self.calibration = tools.get_colors(pitch)\\n self.vision = Vision(\\n pitch=pitch, color=color, our_side=our_side,\\n frame_shape=frame.shape, frame_center=center_point,\\n calibration=self.calibration)\\n\\n # Set up postprocessing for vision\\n self.postprocessing = Postprocessing(our_side)\\n\\n # Set up main planner\\n self.planner = Planner(our_side=our_side, pitch_num=self.pitch, isPenalty=penalty)\\n\\n # Set up GUI\\n self.GUI = GUI(calibration=self.calibration, arduino=self.arduino, pitch=self.pitch)\\n\\n self.color = color\\n self.side = our_side\\n\\n self.preprocessing = Preprocessing()\\n\\n self.robot = Robot_Controller()\",\n \"def __init__(self, seat: Seat) -> None:\\n self._ptr = ffi.new(\\\"struct wlr_seat_keyboard_grab *\\\")\\n self._seat = seat\",\n \"def __init__(self):\\n self.__deviceselected__ = \\\"SR-DMS4AP{LOCALBUMP}DEV:Sel-SP\\\"\\n self.__source__ = \\\"SR-DMS4AP{LOCALBUMP}S-SP\\\"\\n self.__plane__ = \\\"SR-DMS4AP{LOCALBUMP}PLANE-SP\\\"\\n #self.__xshift__ = \\\"SR-DMS4AP{LOCALBUMP}SHIFT:X-SP\\\"\\n #self.__yshift__ = \\\"SR-DMS4AP{LOCALBUMP}SHIFT:Y-SP\\\"\\n #self.__xangle__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE:X-SP\\\"\\n #self.__yangle__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE:Y-SP\\\"\\n self.__shift__ = \\\"SR-DMS4AP{LOCALBUMP}SHIFT-SP\\\"\\n self.__angle__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE-SP\\\"\\n # with all offsets\\n self.__anglerb__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE-I\\\"\\n self.__positionrb__ = \\\"SR-DMS4AP{LOCALBUMP}POS-I\\\"\\n # with BBA offset only\\n self.__anglerb0__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE:BBA-I\\\"\\n self.__positionrb0__ = \\\"SR-DMS4AP{LOCALBUMP}POS:BBA-I\\\"\\n\\n self.__bpmposition__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}Pos-I\\\"\\n self.__bpmorbitx__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:X-I\\\"\\n self.__bpmorbity__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:Y-I\\\"\\n self.__bpmorbitx0__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:X0-I\\\"\\n self.__bpmorbity0__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:Y0-I\\\"\\n\\n self.__correctorposition__ = \\\"SR-DMS4AP{LOCALBUMP:COR}Pos-I\\\"\\n self.__hcorrectorcurrent__ = \\\"SR-DMS4AP{LOCALBUMP:HCOR}PS-SP\\\"\\n self.__hcorrectordiff__ = \\\"SR-DMS4AP{LOCALBUMP:HCOR}PS:Delta-SP\\\"\\n self.__vcorrectorcurrent__ = \\\"SR-DMS4AP{LOCALBUMP:VCOR}PS-SP\\\"\\n self.__vcorrectordiff__ = \\\"SR-DMS4AP{LOCALBUMP:VCOR}PS:Delta-SP\\\"\\n\\n self.__undo__ = \\\"SR-DMS4AP{LOCALBUMP}Enbl:Undo-Cmd\\\"\\n self.__apply__ = \\\"SR-DMS4AP{LOCALBUMP}Enbl-Cmd\\\"\\n self.__status__ = \\\"SR-DMS4AP{LOCALBUMP}TS-I\\\"\\n self.__idposinfo__ = \\\"SR-DMS4AP{LOCALBUMP}S-I\\\"\\n self.__srcposition__ = \\\"SR-DMS4AP{LOCALBUMP}SRC-SP\\\"\",\n \"def write(self, buffer):\\n utils.print_for_unimplemented_functions(SPI.write.__name__)\\n telemetry_py.send_telemetry(TelemetryEvent.MICROBIT_API_SPI)\",\n \"def _initialize_buffers(self) -> None:\",\n \"def __init__(self) -> None:\\n self.sensor = serial.Serial(config.DEVICE)\\n super().__init__()\",\n \"def __init__(self,address,InUseBy=None,Bus = None,Ident=''):\\n self.Ident = Ident\\n self.InUseBy = InUseBy\\n VersionStrip =Ident.split(' ')[0].lower()\\n if Ident !='' and VersionStrip in SPI.DeviceList:\\n self.InUseBy = SPI.DeviceList[VersionStrip](Bus,address)\\n else:\\n self.Type=None\\n if self.InUseBy!=None:\\n self.Ident=VersionStrip\",\n \"def __init__(self, pockets):\\n self._is_on = False\\n self._pockets = pockets\",\n \"def __init__(self):\\n # FIXME: IS this needed?\\n super(ArduinoStation, self).__init__()\\n\\n self.serial_port_pattern = '/dev/ttyACM{port_num}'\\n self.serial_port_num = None\\n self.baudrate = 9600\\n self.ser = self._setup_serial_connection()\\n\\n\\n # Sensor 1 (DHT11) has 2 readings, Sensor 2 has 1\\n ## FIXME: Should look for key pairs in list and submit when no more unique readings are coming through\\n if config.SCB_CONFIGURATION == 'standard':\\n self.lines_per_observation = 3\\n else:\\n self.lines_per_observation = 7 # Allows for up to 5 DS18B20 along w/ DHT-11.\",\n \"def __init__(self, address=0x76):\\n self.address = address\\n self.bus = self._initialize_bus()\\n\\n self.chip_id, self.chip_version = self._get_info_about_sensor()\",\n \"def __init__(self, segments, display_res=\\\"1920x1080\\\", stream_id=None):\\n self.segments = segments\\n self.display_res = display_res\\n self.stream_id = stream_id\\n self.o22 = []\\n self.mode = None\",\n \"def __init__(self, envirophat, use_leds):\\n self.envirophat = envirophat\\n self.use_leds = use_leds\\n # sensors readings\\n self.light = None\\n self.light_red = None\\n self.light_green = None\\n self.light_blue = None\\n self.accelerometer_x = None\\n self.accelerometer_y = None\\n self.accelerometer_z = None\\n self.magnetometer_x = None\\n self.magnetometer_y = None\\n self.magnetometer_z = None\\n self.temperature = None\\n self.pressure = None\\n self.voltage_0 = None\\n self.voltage_1 = None\\n self.voltage_2 = None\\n self.voltage_3 = None\",\n \"def __init__(self, name: str, address: str,\\n channel_map: dict, reset_currents: bool=False):\\n t0 = time.time()\\n super().__init__(name)\\n self.channel_map = channel_map\\n self.spi_rack = SPI_rack(address, 9600, timeout=1)\\n self.spi_rack.unlock()\\n\\n self.add_parameter(\\n 'cfg_ramp_rate', unit='A/s',\\n initial_value=0.1e-3, # 0.1 mA/s\\n docstring='Limits the rate at which currents can be changed.',\\n vals=validators.Numbers(min_value=0, max_value=np.infty),\\n parameter_class=ManualParameter)\\n self.add_parameter(\\n 'cfg_verbose',\\n initial_value=True,\\n vals=validators.Bool(),\\n docstring='If True, prints progress while ramping values.',\\n parameter_class=ManualParameter)\\n\\n # Determine the set of modules required from the channel map\\n module_ids = set([ch_map[0] for ch_map in channel_map.values()])\\n # instantiate the controllers for the individual modules\\n self.current_sources = {}\\n for mod_id in module_ids:\\n # N.B. reset currents has a slow ramp build in.\\n self.current_sources[mod_id] = S4g_module(\\n self.spi_rack,\\n module=mod_id,\\n max_current=50e-3,\\n reset_currents=reset_currents)\\n\\n for parname, (mod_id, dac) in self.channel_map.items():\\n self.add_parameter(\\n parname,\\n get_cmd=partial(self._get_current, parname),\\n set_cmd=partial(self._set_current, parname),\\n unit=\\\"A\\\",\\n vals=validators.Numbers(min_value=-25e-3, max_value=25e-3))\\n\\n self.connect_message(begin_time=t0)\",\n \"def __init__(self):\\n self.ram = [0]*256\\n self.reg = [0] * 8\\n self.fl = 0b00000000\\n self.pc = 0\\n self.sp = 0xF3\\n self.is_run = False\\n self.call_flag = False\\n pass\",\n \"def __init__(self, serialNumber, idProduct, idVendor, model):\\n Spectrometer.__init__(self, serialNumber, idProduct, idVendor)\\n\\n self.device = None\\n self.configuration = None\\n self.interface = None\\n self.inputEndpoints = []\\n self.outputEndpoints = []\\n\\n self.epParametersIdx = 2\\n self.epStatusIdx = 2\\n self.epCommandOutIdx = 0\\n self.epMainInIdx = 2\\n self.epSecondaryInIdx = 1\\n\\n self.epCommandOut = None\\n self.epMainIn = None\\n self.epSecondaryIn = None\\n self.epParameters = None\\n self.epStatus = None\\n\\n self.model = model\\n self.wavelength = None\\n self.discardLeadingSamples = 0 # In some models, the leading data is meaningless\\n self.discardTrailingSamples = 0 # In some models, the trailing data is meaningless\\n self.lastStatus = None\",\n \"def __init__(self,devId, varsToStream, printingRate = 10,labels = None,updateFreq = 100, shouldLog = False, shouldAuto = 1):\\n\\t\\t#init printer settings\\n\\t\\tself.counter = 0\\n\\t\\tself.prev_data = None\\n\\t\\tself.labels = labels\\n\\t\\tself.data = None\\n\\t\\tself.rate = printingRate\\n\\n\\t\\t# load stream data\\n\\t\\tself.varsToStream = varsToStream\\n\\t\\tself.devId = devId\\n\\t\\tself.shouldAuto = shouldAuto\\n\\t\\tself.updateFreq = updateFreq\\n\\t\\tself.shouldLog = shouldLog\\n\\t\\tself.prevReadTime = time.time()\\n\\n\\t\\t# Start stream\\n\\t\\tfxSetStreamVariables(self.devId,self.varsToStream)\\n\\t\\tif not fxStartStreaming(self.devId,self.updateFreq,self.shouldLog,self.shouldAuto):\\n\\t\\t\\tprint(\\\"Streaming failed...\\\")\\n\\t\\t\\tsys.exit(-1)\\n\\t\\telse:\\n\\t\\t\\tsleep(0.4)\",\n \"def __init__(self):\\n super().__init__()\\n\\n # Robot state\\n self.ask_mode = False\\n\\n # Connect two large motors on output ports B and C\\n self.sound = Sound()\\n self.leds = Leds()\\n self.p1 = TouchSensor(INPUT_1)\\n self.p2 = TouchSensor(INPUT_2)\\n self.p3 = TouchSensor(INPUT_3)\\n self.p4 = TouchSensor(INPUT_4)\",\n \"def initialize_spike_pos_fig(self):\\n self._pos_fig = plt.figure()\\n self._spk_pos_ax = plt.axes()\\n self._spk_pos_ax.set_xlabel(\\\"x (bin)\\\")\\n self._spk_pos_ax.set_ylabel(\\\"y (bin)\\\")\\n self._spk_pos_ax.set_xlim((-0.5, 0.5+PositionAnalysis.N_POSITION_BINS[0]))\\n self._spk_pos_ax.set_ylim((-0.5, 0.5+PositionAnalysis.N_POSITION_BINS[1]))\\n self._spk_pos_ax.grid(True)\\n\\n # Create graphics entries for the actual position and also each of the spike clusters\\n pos_frame, = plt.plot([], [], animated=True)\\n spk_frame, = plt.plot([], [], linestyle='None', marker='o', alpha=0.4, animated=True)\\n # vel_frame = plt.text(30.0, 10.0, 'speed = 0 cm/s', transform=self._spk_pos_ax.transAxes)\\n vel_frame = plt.text(40.0, 2.0, 'speed = 0cm/s')\\n self._spk_pos_frame.append(spk_frame)\\n self._spk_pos_frame.append(pos_frame)\\n self._spk_pos_frame.append(vel_frame)\\n\\n anim_obj = animation.FuncAnimation(self._pos_fig, self.update_position_and_spike_frame, frames=self.__N_ANIMATION_FRAMES, interval=5, blit=True)\\n self._anim_objs.append(anim_obj)\",\n \"def __init__(self):\\n \\n self.load_PSF_data()\",\n \"def init(self, x0=None, control=None):\\n if x0 is not None:\\n self._x = base.getvector(x0, 3)\\n else:\\n self._x = self._x0.copy()\\n\\n self._x_hist = []\\n\\n if self._seed is not None:\\n self._random = np.random.default_rng(self._seed)\\n\\n if control is not None:\\n # override control\\n self._control = control\\n \\n if self._control is not None:\\n self._control.init()\\n\\n self._t = 0\\n\\n # initialize the graphics\\n if self._animation is not None:\\n\\n # setup the plot\\n self._ax = base.plotvol2(self.workspace)\\n \\n self._ax.set_xlabel('x')\\n self._ax.set_ylabel('y')\\n self._ax.set_aspect('equal')\\n self._ax.figure.canvas.manager.set_window_title(\\n f\\\"Robotics Toolbox for Python (Figure {self._ax.figure.number})\\\")\\n\\n self._animation.add(ax=self._ax) # add vehicle animation to axis\\n self._timer = plt.figtext(0.85, 0.95, '') # display time counter\\n\\n # initialize the driver\\n if isinstance(self._control, VehicleDriver):\\n self._control.init(ax=self._ax)\",\n \"def __init__(self, params=None):\\n if isinstance(params, SSDParams):\\n self.params = params\\n else:\\n self.params = SSDNet.default_params\",\n \"def __init__(self, por=\\\"/dev/ttyS\\\", par=['1','115200','8','N','1'], ope=True, deb=False):\\r\\n\\t\\t# referenzio il flag di Debug\\r\\n\\t\\tself.deb = deb\\r\\n\\t\\tself.ope = ope\\r\\n\\t\\tself.par = par\\r\\n\\t\\tself.por = por+par[0]\\r\\n\\t\\t# Gestione apertura collegamento\\r\\n\\t\\tif self.ope:\\r\\n\\t\\t\\ttry:\\r\\n\\t\\t\\t\\t# provo ad aprire la connessione\\r\\n\\t\\t\\t\\tself.ser = serial.Serial(self.por)\\r\\n\\t\\t\\t\\t# configuro i parametri e provo apertura\\r\\n\\t\\t\\t\\ttry:\\r\\n\\t\\t\\t\\t\\tself.ser.close()\\r\\n\\t\\t\\t\\t\\tself.ser.open()\\r\\n\\t\\t\\t\\t\\t# set parameters\\r\\n\\t\\t\\t\\t\\tself.chaSetting()\\r\\n\\t\\t\\t\\t\\t# debug\\r\\n\\t\\t\\t\\t\\tif self.deb:\\r\\n\\t\\t\\t\\t\\t\\t# ok\\r\\n\\t\\t\\t\\t\\t\\tprint \\\"%s now is open.\\\" %self.por\\r\\n\\t\\t\\t\\texcept:\\r\\n\\t\\t\\t\\t\\tself.ser = None\\r\\n\\t\\t\\t\\t\\t# seriale gia' aperta\\r\\n\\t\\t\\t\\t\\tprint \\\"%s port not opened!\\\" %self.por\\r\\n\\t\\t\\texcept:\\r\\n\\t\\t\\t\\t# nessuna seriale presente\\r\\n\\t\\t\\t\\tself.ser = None\\r\\n\\t\\t\\t\\t# debug\\r\\n\\t\\t\\t\\tif self.deb:\\r\\n\\t\\t\\t\\t\\tprint \\\"%s not present!\\\" %self.por\\r\\n\\t\\t\\t\\t\\t#sys.exit()\\r\\n\\t\\t# nessuna verifica di presenza device!\\r\\n\\t\\telse:\\r\\n\\t\\t\\tself.ser = serial.Serial()\\r\\n\\t\\t# ritardo tra un invio e il successivo\\r\\n\\t\\tself.dlTx = 0.002\",\n \"def __init__(self):\\n self.ctrl = src.robot_controller.RobotController()\\n self.recorder = robot_recorder.RobotRecorder(save_dir=\\\"/home/guser/sawyer_data/test_recording\\\", start_loop=False)\\n\\n # drive to neutral position:\\n self.ctrl.set_neutral()\\n # import pdb; pdb.set_trace()\\n\\n self.num_traj = 10\\n\\n\\n limb = 'right'\\n self.name_of_service = \\\"ExternalTools/\\\" + limb + \\\"/PositionKinematicsNode/FKService\\\"\\n self.fksvc = rospy.ServiceProxy(self.name_of_service, SolvePositionFK)\\n\\n self.run_data_collection()\",\n \"def init():\\n\\t# init the node\\n\\trospy.init_node(\\\"gps_node\\\")\\n\\t\\n\\t# init the publishers\\n\\tD.gpsPub = rospy.Publisher(\\\"gps_data\\\",RosGPS)\\n\\n\\t# init gps connection\\n\\t#init_gpsd()\\n\\tinit_serial()\\n\\t\\n\\t# gps data\\n\\tD.NSatellites = 0\\t# the number of satellites in view\\n\\n\\t# time conversion info\\n\\tD.tzOffset = -8 \\t# offset in hours due to timezones\\n\\tD.dst = 1\\t\\t# daylight savings. 1 = yes, 0 = no\",\n \"def __init__(self, address=0x68, config=0):\\r\\n\\t\\tself.i2c = FT232H.I2CDevice(ft232h, address)\\r\\n\\t\\tif config == 0:\\r\\n\\t\\t\\tself.setWake()\\r\\n\\t\\t\\tself.setScale(mode='ACC',scale=0)\\r\\n\\t\\t\\tself.setScale(mode='GYR',scale=0)\\r\\n\\t\\telif config == 1:\\r\\n\\t\\t\\tself.setWake()\\r\\n\\t\\t\\tself.setScale(mode='ACC',scale=1)\\r\\n\\t\\t\\tself.setScale(mode='GYR',scale=1)\\t\\t\\t\\t\\r\\n\\t\\telif config == 2:\\r\\n\\t\\t\\tself.setWake()\\r\\n\\t\\t\\tself.setScale(mode='ACC',scale=2)\\r\\n\\t\\t\\tself.setScale(mode='GYR',scale=2)\\t\\r\\n\\t\\telif config == 3:\\r\\n\\t\\t\\tself.setWake()\\r\\n\\t\\t\\tself.setScale(mode='ACC',scale=3)\\r\\n\\t\\t\\tself.setScale(mode='GYR',scale=3)\\t\\t\\t\\t\\r\\n\\t\\telif config == 4:\\r\\n\\t\\t\\tself.setWake()\\r\\n\\t\\t\\tself.setScale(mode='ACC',scale=1)\\t\\r\\n\\t\\t\\tself.setTempDisable()\\r\\n\\t\\t\\tself.setGYRStandby(axis='X')\\r\\n\\t\\t\\tself.setGYRStandby(axis='Y')\\r\\n\\t\\t\\tself.setGYRStandby(axis='Z')\",\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 __init__(self, starting_point=-1):\\n self.i_read = starting_point\\n self.data = [['fake_chip_id', 'fake_version'],\\n [96, 110, 203, 104, 50, 0, 29, 145, 59, 215, 208, 11,\\n 232, 38, 42, 255, 249, 255, 172, 38, 10, 216, 189, 16],\\n [75],\\n [129, 1, 0, 16, 44, 3, 30],\\n [76, 60, 128, 129, 49, 128, 94, 120]]\",\n \"def _initialize(self):\\r\\n print(\\\"Set the CP mode to EVSE\\\")\\r\\n self.whitebeet.controlPilotSetMode(1)\\r\\n print(\\\"Set the CP duty cycle to 100%\\\")\\r\\n self.whitebeet.controlPilotSetDutyCycle(100)\\r\\n print(\\\"Start the CP service\\\")\\r\\n self.whitebeet.controlPilotStart()\\r\\n print(\\\"Start SLAC in EVSE mode\\\")\\r\\n self.whitebeet.slacStart(1)\\r\\n time.sleep(2)\",\n \"def init(self):\\n\\n pygame.init()\\n pygame.display.set_mode((640, 480))\\n pygame.display.set_caption(\\\"Gears 4 Geeks\\\")\\n pygame.joystick.init()\\n self.controller = pygame.joystick.Joystick(0)\\n self.controller.init()\\n self.ser = serial.Serial('COM4', 9600)\\n\\n #ADAFRUIT_IO_KEY = 'd1a1bd3737714fa488e0364c775a4b4d' ##This will only be good until the end of the competition\\n #self.aio = Client(ADAFRUIT_IO_KEY)\",\n \"def __init__(self):\\n self._read_calibration_data()\\n self.set_oversamplings_and_mode(\\n HumidityOversampling.x08,\\n TemperatureOversampling.x08,\\n PressureOversampling.x16,\\n SensorMode.Normal)\\n self.set_config(\\n InactiveDuration.ms1000,\\n FilterCoefficient.fc04)\",\n \"def startup(self):\\n self.prev_gray = None\\n self.frame_idx = 1\\n self.tracks = []\\n self.fps = []\\n self.vid_info = None\\n self.track_new_points_count = 0\",\n \"def __init__(self, dev='/dev/ttyUSB0', dbhost='localhost' ,db=DEFAULTDB):\\n self.circles = {}\\n self.dev = Stick(dev)\\n self.connectdb(dbhost,db)\",\n \"def __init__(self, robot):\\n\\n #initialise the stick and the smart dashboard (in case we need stuff for auton):\\n self.stick = wpilib.Joystick(0)\\n self.smart_dashboard = NetworkTable.getTable(\\\"SmartDashboard\\\")\\n\\n #Main stick buttons.\\n #-----------------------------------------------------------------------\\n trigger = JoystickButton(self.stick, 1)\\n thumb = JoystickButton(self.stick, 2)\\n three = JoystickButton(self.stick, 3)\\n four = JoystickButton(self.stick, 4)\\n five = JoystickButton(self.stick, 5)\\n six = JoystickButton(self.stick, 6)\\n seven = JoystickButton(self.stick, 7)\\n eight = JoystickButton(self.stick, 8)\\n nine = JoystickButton(self.stick, 9)\\n ten = JoystickButton(self.stick, 10)\\n eleven = JoystickButton(self.stick, 11)\\n twelve = JoystickButton(self.stick, 12)\\n\\n #Hat switch POV stuff.\\n #-----------------------------------------------------------------------\\n pov_north = POVButton(self.stick, 0)\\n pov_northeast = POVButton(self.stick, 45)\\n pov_east = POVButton(self.stick, 90)\\n pov_southeast = POVButton(self.stick, 135)\\n pov_south = POVButton(self.stick, 180)\\n pov_southwest = POVButton(self.stick, 225)\\n pov_west = POVButton(self.stick, 270)\\n pov_northwest = POVButton(self.stick, 315)\\n\\n pov_south.whenPressed(SuperStrafeEntertainmentSystem(robot, SuperStrafeEntertainmentSystem.kBack))\\n pov_north.whenPressed(SuperStrafeEntertainmentSystem(robot, SuperStrafeEntertainmentSystem.kForward))\\n pov_east.whenPressed(SuperStrafeEntertainmentSystem(robot, SuperStrafeEntertainmentSystem.kRight))\\n pov_west.whenPressed(SuperStrafeEntertainmentSystem(robot, SuperStrafeEntertainmentSystem.kLeft))\",\n \"def __init__(self):\\n self.pc = 0\\n self.reg = [0] * 8\\n self.ram = [0] * 256\\n\\n self.running = False\",\n \"def __init__(__self__, *,\\n driver: 'outputs.CSIVXFlexOSSpecDriver'):\\n pulumi.set(__self__, \\\"driver\\\", driver)\",\n \"def __init__(self):\\n super().__init__()\\n\\n # Gadget state\\n \\n self.isDoorOpen = False\\n self.verified = True\\n\\n # Ev3dev initialization\\n self.leds = Leds()\\n self.sound = Sound()\\n self.drive = MoveTank(OUTPUT_B, OUTPUT_C)\\n \\n self.ir_sensor = InfraredSensor()\\n self.ir_sensor.mode = self.ir_sensor.MODE_IR_REMOTE\\n self.color_sensor = ColorSensor()\\n self.color_sensor.mode = 'COL-COLOR' # WHITE\\n\\n # Start threads\\n threading.Thread(target=self._patrol_thread, daemon=True).start()\",\n \"def setup(self):\\n\\n warnings.simplefilter(\\\"always\\\", DeprecationWarning)\\n\\n orbit_info = {'index': 'slt', 'kind': 'lt'}\\n self.tinst = pysat.Instrument('pysat', 'testing', orbit_info=orbit_info)\\n self.tinst.bounds = (dt.datetime(2008, 1, 1), dt.datetime(2008, 1, 2))\\n\\n self.warn_msgs = []\\n self.war = \\\"\\\"\\n return\",\n \"def __init__(self):\\n self.bytes = bytearray(3)\\n MCP4725.__init__(self)\",\n \"def init():\\n\\n global leftDriverStick\\n global rightDriverStick\\n global goGamePad\\n\\n try:\\n leftDriverStick = T16000M(0)\\n except:\\n print('OI: Error - Could not instantiate Left Driver Stick on USB port 0!!!')\\n\\n try:\\n rightDriverStick = T16000M(1)\\n except:\\n print('OI: Error - Could not instantiate Right Driver Stick on USB port 0!!!')\\n\\n try:\\n goGamePad = Joystick(2)\\n except:\\n print('OI: Error - Could not instantiate Right Driver Stick on USB port 2!!!')\\n\\n\\n # ----------------------------------------------------------\\n # Driver Controls\\n # ----------------------------------------------------------\\n #global resetYawBtn\\n #resetYawBtn = JoystickButton(rightDriverStick, config.btnResetYawAngleIndex)\\n #resetYawBtn.whenPressed(NavxResetYawAngle())\\n\\n global btnDriveSlow\\n btnDriveSlow = JoystickButton(leftDriverStick, config.btnDriveSlow)\\n \\n global btnEnableLightSensor\\n btnEnableLightSensor = JoystickButton(leftDriverStick, config.btnEnableLightSensorIndex)\\n\\n global btnExtendAll\\n btnExtendAll = JoystickButton(rightDriverStick, config.btnExtendAllIndex)\\n btnExtendAll.whenPressed(ExtendAll())\\n\\n global btnRetract\\n btnRetract = JoystickButton(rightDriverStick, config.btnRetractAllIndex)\\n btnRetract.whenPressed(RetractAll())\\n\\n global btnExtendFront\\n btnExtendFront = JoystickButton(rightDriverStick, config.btnExtendFrontIndex)\\n btnExtendFront.whenPressed(ExtendFront())\\n\\n global btnExtendBack\\n btnExtendBack = JoystickButton(rightDriverStick, config.btnExtendBackIndex)\\n btnExtendBack.whenPressed(ExtendBack())\\n\\n global btnRetractFront\\n btnRetractFront = JoystickButton(rightDriverStick, config.btnRetractFrontIndex)\\n btnRetractFront.whenPressed(RetractFront())\\n\\n global btnCargoGrabTog\\n btnCargoGrabTog = JoystickButton(goGamePad, config.btnHatchGrabTogIndex)\\n btnCargoGrabTog.whenPressed(ExtendBack())\\n \\n \\\"\\\"\\\"\\n global btnResetEncoders\\n btnResetEncoders = JoystickButton(leftDriverStick, config.btnResetEncodersIndex)\\n btnResetEncoders.whenPressed(TankDriveResetEncoders())\\n \\\"\\\"\\\"\\n\\n \\\"\\\"\\\"\\n global axisElevator\\n axisElevator = JoystickAxis(goGamePad, config.axisElevatorIndex)\\n axisElevator. #??? idk how to configure joystick axis\\n \\\"\\\"\\\"\\n\\n \\\"\\\"\\\"\\n global btnRampTog\\n btnRampTog = JoystickButton(goGamePad, config.btnRampTogIndex)\\n btnRampTog.whenPressed(ExtendFront())\\n \\\"\\\"\\\"\\n #global btnResetEncoders\\n #btnResetEncoders = JoystickButton(leftDriverStick, config.btnResetEncodersIndex)\\n #btnResetEncoders.whenPressed(TankDriveResetEncoders())\\n\\n # These variable names are inconsistent, need to be fixed!!!!\\n #global btnRampExtendTog\\n #btnRampExtendTog = JoystickButton(goGamePad, config.btnRampExtendTogIndex)\\n #btnRampExtendTog.whenPressed(RampExtend())\\n\\n #global btnRampRetractTog\\n #btnRampRetractTog = JoystickButton(goGamePad, config.btnRampRetractTogIndex)\\n #btnRampRetractTog.whenPressed(RampRetract())\",\n \"def __init__(self, oscPort = \\\"COM1\\\", zaberStagePort = 2):\\n\\t\\t# Serial() input depends on where stage is connected\\n\\t\\tself.stage = serial.Serial(zaberStagePort)\\n\\t\\t# 9600 = baudrate\\n\\t\\tself.osc = TDS3k(serial.Serial(oscPort, 9600, timeout=1))\",\n \"def __init__(self, port='/dev/ttyUSB0', baudrate=1200,\\n calib=[-0.49125, 1.0613], Tident='LSCI,MODEL321', mode=0):\\n # for the baratron reading and updating display\\n self.dmm = gpib.find('3478a')\\n self.__bytes__ = 32\\n # so that DMM knows to put something in the output buffer\\n gpib.read(self.dmm, self.__bytes__)\\n \\n # for the temperature reading, many values hardcoded for\\n # Lakeshore 321 cryogenic temperature sensor\\n self.Tsensor = serial.Serial(port=port, baudrate=baudrate,\\n bytesize = 7, parity = 'O')\\n self.Tsensor.setTimeout(1)\\n self.Tsensor.flushInput()\\n self.Tsensor.write('*IDN?\\\\n')\\n answer = self.Tsensor.readline()\\n\\n if (re.match(Tident, answer) == None):\\n raise Exception, \\\"LS321 ident string not matched\\\"\\n \\n # calibration factors consist of two numbers: voltage reading\\n # at vacuum, and voltage reading at 1 atm.\\n self.calib = calib\\n self.mode = mode\\n \\n # some constants; declared here so that improved versions\\n # of front-ends could modify them.\\n self.atm = 760.0\\n self.unit='TORR'\\n self.pascalPerTorr = 133.322\\n self.boltzmann = 1.38065e-23\\n self.BGUnit='HE'\",\n \"def _setup_sensor ( self ):\\n self.spectral = Spectral ( np.array([450, 520, 630, 770., 1550, 2090.] ),\\n np.array([ 520, 600, 690, 900., 1750., 2350.] ) )\",\n \"def __init__(self, buff):\\n fmt = 'hiSi'\\n response = struct_helpers.unpack_from(fmt, buff, 0)\\n\\n error_code = response[0]\\n if error_code != 0:\\n self.raise_error(error_code, response)\\n self.coordinator_id = response[1]\\n self.coordinator_host = response[2]\\n self.coordinator_port = response[3]\",\n \"def __init__(self):\\n self.position = Vector2()\\n self.velocity = Vector2()\\n self.update_parameters()\\n self.mass = 0.18 # Mass of Sphero robot in kilograms\",\n \"def __init__(self):\\n self.x_coord = default_init\\n self.y_coord = default_init\\n self._init_random_coord() # generating random coordinates\\n self.x_speed = default_init\\n self.y_speed = default_init\\n self.degrees = default_init\\n self.radius = ship_def_radius\",\n \"def __init__(self):\\n \\n self.packetType = DATA\\n self.types = [BYTE, # Packet type\\n FLOAT, # Battery voltage\\n FLOAT, FLOAT, FLOAT, FLOAT, # Temperature readings\\n FLOAT, FLOAT, # Pressure and humidity readings\\n BYTE, BYTE, BYTE, # GPS Year, month, date (sensor computer)\\n BYTE, BYTE, BYTE, # GPS Hour, minute, second (sensor computer)\\n LONG, LONG, LONG, # GPS latitude, longitude, altitude (sensor computer)\\n ULONG, UINT, BYTE, # GPS speed, heading, num satellites (sensor computer)\\n FLOAT, FLOAT, FLOAT, # IMU data (accelerometer)\\n FLOAT, FLOAT, FLOAT, # IMU data (gyroscope)\\n FLOAT, FLOAT, FLOAT, # IMU data (magnetometer)\\n FLOAT, FLOAT, FLOAT, # Attitude data\\n ULONG, # Time since reset\\n BOOL, UINT, # Data logging\\n ULONG, # Time since last data arrival\\n ULONG, # Relay states\\n BYTE, BYTE, BYTE, # GPS Year, month, date (comm computer)\\n BYTE, BYTE, BYTE, # GPS Hour, minute, second (comm computer)\\n LONG, LONG, LONG # GPS latitude, longitude, altitude (comm computer)\\n ] \\n\\n self.values = [0]*len(self.types)\\n self.values[0] = DATA\",\n \"def initialize_relays(self):\\n #create list of bytes to clear out relays\\n zeroed_bytes = []\\n for i in range(self.num_registers):\\n zeroed_bytes.append(0x00)\\n\\n #clear out any data in the shift registers\\n ret = self.e.write_SPI_bytes_to_portA(zeroed_bytes)\\n self.strobe_relays()\\n print \\\"read from SPI: \\\",\\n print ret\\n\\n #enable the relays\\n self.enable_relays()\",\n \"def __init__(self, portname, devicetype):\\n if devicetype == DEVICE_DEBUG_BOARD:\\n self.device = debugbox.DebugBox(portname)\\n elif devicetype == DEVICE_SFP_BREAKOUT:\\n self.device = sfpbreakout.SFP(portname)\\n elif devicetype == DEVICE_DUMMY_BOARD:\\n self.device = dummybox.DummyBox(portname)\\n else:\\n raise IOError(\\\"Invalid Device Type\\\")\\n \\n # Set up laser sections\\n self.mirror1 = Testrig.LaserSection(self, 814, 10, 90, 728, 844, 860, 864)\\n self.laser_phase = Testrig.LaserSection(self, 810, 11, 20, 726, 846, 858, 866)\\n self.gain = Testrig.LaserSection(self, 818, 12, 180, 730, 848, None, None)\\n# self.gain1.validator.setTop(150)\\n self.mirror2 = Testrig.LaserSection(self, 826, 14, 90, 734, 850, 862, 864)\\n# self.front.validator.setTop(60)\\n self.soa1 = Testrig.LaserSection(self, 822, 15, 300, 736, 852, None, None)\\n# self.soa1.validator.setTop(150)\\n self.soa2 = Testrig.LaserSection(self, 830, 16, 100, 738, 854, None, None, self.to_display_current_section2, self.to_internal_current_section2)\\n self.phase1 = Testrig.LaserSection(self, 834, 13, 100, 732, 856, None, None, self.to_display_current_section2, self.to_internal_current_section2)\\n \\n self.voltage_max = 2.5 # This is now a constant\\n \\n self.full_rig = True\",\n \"def __init__(self, resolution=None, colour='multi', cs_pin=CS0_PIN, dc_pin=DC_PIN, reset_pin=RESET_PIN, busy_pin=BUSY_PIN, h_flip=False, v_flip=False, spi_bus=None, i2c_bus=None, gpio=None): # noqa: E501\\n self._spi_bus = spi_bus\\n self._i2c_bus = i2c_bus\\n self.eeprom = eeprom.read_eeprom(i2c_bus=i2c_bus)\\n\\n # Check for supported display variant and select the correct resolution\\n # Eg: 600x480 and 640x400\\n if resolution is None:\\n if self.eeprom is not None and self.eeprom.display_variant in (14, 15, 16):\\n resolution = [_RESOLUTION_7_3_INCH, None, _RESOLUTION_7_3_INCH][self.eeprom.display_variant - 14]\\n else:\\n resolution = _RESOLUTION_7_3_INCH\\n\\n if resolution not in _RESOLUTION.keys():\\n raise ValueError('Resolution {}x{} not supported!'.format(*resolution))\\n\\n self.resolution = resolution\\n self.width, self.height = resolution\\n self.border_colour = WHITE\\n self.cols, self.rows, self.rotation, self.offset_x, self.offset_y, self.resolution_setting = _RESOLUTION[resolution]\\n\\n if colour not in ('multi'):\\n raise ValueError('Colour {} is not supported!'.format(colour))\\n\\n self.colour = colour\\n self.lut = colour\\n\\n self.buf = numpy.zeros((self.rows, self.cols), dtype=numpy.uint8)\\n\\n self.dc_pin = dc_pin\\n self.reset_pin = reset_pin\\n self.busy_pin = busy_pin\\n self.cs_pin = cs_pin\\n try:\\n self.cs_channel = [8, 7].index(cs_pin)\\n except ValueError:\\n self.cs_channel = 0\\n self.h_flip = h_flip\\n self.v_flip = v_flip\\n\\n self._gpio = gpio\\n self._gpio_setup = False\\n\\n self._luts = None\",\n \"def _setup_sensor ( self ):\\n self.spectral = Spectral ( np.array([500, 610, 780, 1580.] ),\\n np.array([590, 680, 890, 1750.] ) )\",\n \"def init_gps(configuration: Configuration):\\n gps_serial_port = configuration.get_device_configuration(\\\"gps\\\", \\\"serial_device\\\")\\n if not gps_serial_port:\\n return None\\n ser = serial.Serial(gps_serial_port, 9600, timeout=5.0)\\n sio = io.TextIOWrapper(io.BufferedRWPair(ser, ser))\\n return sio\",\n \"def __init__(self, shape):\\n self.eyes = [(), ()]\\n self.shape = shape\\n self.state = 0\\n self.new_frame()\",\n \"def __init__(\\n self,\\n poly_modulus_degree=8192,\\n coeff_mod_bit_sizes=[60, 40, 40],\\n scale_bits=40,\\n scheme=\\\"CKKS\\\",\\n ):\\n self._context = None\\n self.scheme_type_mapping = {\\n \\\"CKKS\\\": ts.SCHEME_TYPE.CKKS,\\n \\\"BFV\\\": ts.SCHEME_TYPE.BFV,\\n }\\n self.poly_modulus_degree = poly_modulus_degree\\n self.coeff_mod_bit_sizes = coeff_mod_bit_sizes\\n self.scale_bits = scale_bits\\n _scheme = scheme\\n # Setup TenSEAL context\\n self.scheme_type = self.scheme_type_mapping[_scheme]\\n self.serialized = None\",\n \"def __init__(self):\\n GPIO.setmode(GPIO.BCM)\\n pipes = [[0xC2, 0xC2, 0xC2, 0xC2, 0x01],\\n [0xC2, 0xC2, 0xC2, 0xC2, 0x02],\\n [0xC2, 0xC2, 0xC2, 0xC2, 0x03],\\n [0xC2, 0xC2, 0xC2, 0xC2, 0x04],\\n [0xC2, 0xC2, 0xC2, 0xC2, 0x05],\\n [0xC2, 0xC2, 0xC2, 0xC2, 0x06],\\n ]\\n self.radio = NRF24(GPIO, spidev.SpiDev())\\n self.radio.begin(0, 17)\\n\\n self.radio.setPayloadSize(32)\\n self.radio.setChannel(0x76)\\n self.radio.setDataRate(NRF24.BR_1MBPS)\\n self.radio.setPALevel(NRF24.PA_MAX)\\n\\n self.radio.enableDynamicPayloads()\\n self.radio.enableAckPayload()\\n self.radio.setAutoAck(True)\\n\\n # Initialize pipes\\n for i in xrange(6):\\n self.radio.openReadingPipe(i, pipes[i])\\n # Premptively set intial autoacknowledge command\\n #for i in xrange(2):\\n # self.radio.writeAckPayload(i, ackPayload, 4)\\n # time.sleep(.1)\\n\\n self.radio.startListening()\\n self.radio.printDetails()\\n\\n # holds [bot id]\\n self.botList = []\\n self.targetFound = False\\n\\n \\\"\\\"\\\"\\n exploregrid logic\\n \\\"\\\"\\\"\",\n \"def __init__(self):\\n self.cad = pifacecad.PiFaceCAD()\\n self.listener = pifacecad.SwitchEventListener(chip=self.cad)\\n for i in range(8):\\n self.listener.register(i, pifacecad.IODIR_FALLING_EDGE, self.press_key)\\n self.listener.activate()\\n atexit.register(self.atexit)\",\n \"def __init__(self,x_pos, y_pos, velocity, kind, fillcolor = 'red'):\\n self._velocity = velocity\\n self._kind = kind\\n super().__init__(x = x_pos, y=y_pos, width = BOLT_WIDTH, \\\\\\n height = BOLT_HEIGHT, fillcolor=fillcolor)\",\n \"def __init__(self, pts=[]):\\n self.set_points(pts)\",\n \"def __init__(self, id: int, baudrate: int=9600, bits: int=8, parity: int=None, stop: int=1, tx: Pin=None, rx: Pin=None):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6566145","0.6351516","0.63373953","0.6181888","0.61446565","0.6111663","0.59349567","0.57059205","0.55544007","0.554452","0.5522998","0.5509588","0.5503774","0.5380477","0.53760433","0.5336554","0.5321746","0.5299691","0.52520025","0.5248618","0.5240898","0.5219589","0.5202608","0.5198033","0.5195962","0.5170883","0.5133692","0.5128285","0.51246643","0.5120659","0.5117634","0.5113094","0.51020736","0.5077908","0.5074333","0.5062656","0.5059081","0.5058802","0.50555795","0.5026696","0.5025937","0.49972227","0.49859428","0.49851456","0.49847975","0.4967207","0.4958621","0.4951006","0.49445385","0.49432147","0.49320188","0.4927584","0.49252674","0.49164078","0.4914648","0.49066213","0.49043554","0.48915204","0.4883599","0.488174","0.4878899","0.4877542","0.48754916","0.48703107","0.48657566","0.48631698","0.48606008","0.48559728","0.48506984","0.48501936","0.48487642","0.48418346","0.48322824","0.48320255","0.48254734","0.48132473","0.4813096","0.48130068","0.4809703","0.47955266","0.4789465","0.47859904","0.47847673","0.47825488","0.4781668","0.47763354","0.4774383","0.4773635","0.47724608","0.47708207","0.47706902","0.4769254","0.47657144","0.47628587","0.47612777","0.47547013","0.47518408","0.47478813","0.4743045","0.47426757"],"string":"[\n \"0.6566145\",\n \"0.6351516\",\n \"0.63373953\",\n \"0.6181888\",\n \"0.61446565\",\n \"0.6111663\",\n \"0.59349567\",\n \"0.57059205\",\n \"0.55544007\",\n \"0.554452\",\n \"0.5522998\",\n \"0.5509588\",\n \"0.5503774\",\n \"0.5380477\",\n \"0.53760433\",\n \"0.5336554\",\n \"0.5321746\",\n \"0.5299691\",\n \"0.52520025\",\n \"0.5248618\",\n \"0.5240898\",\n \"0.5219589\",\n \"0.5202608\",\n \"0.5198033\",\n \"0.5195962\",\n \"0.5170883\",\n \"0.5133692\",\n \"0.5128285\",\n \"0.51246643\",\n \"0.5120659\",\n \"0.5117634\",\n \"0.5113094\",\n \"0.51020736\",\n \"0.5077908\",\n \"0.5074333\",\n \"0.5062656\",\n \"0.5059081\",\n \"0.5058802\",\n \"0.50555795\",\n \"0.5026696\",\n \"0.5025937\",\n \"0.49972227\",\n \"0.49859428\",\n \"0.49851456\",\n \"0.49847975\",\n \"0.4967207\",\n \"0.4958621\",\n \"0.4951006\",\n \"0.49445385\",\n \"0.49432147\",\n \"0.49320188\",\n \"0.4927584\",\n \"0.49252674\",\n \"0.49164078\",\n \"0.4914648\",\n \"0.49066213\",\n \"0.49043554\",\n \"0.48915204\",\n \"0.4883599\",\n \"0.488174\",\n \"0.4878899\",\n \"0.4877542\",\n \"0.48754916\",\n \"0.48703107\",\n \"0.48657566\",\n \"0.48631698\",\n \"0.48606008\",\n \"0.48559728\",\n \"0.48506984\",\n \"0.48501936\",\n \"0.48487642\",\n \"0.48418346\",\n \"0.48322824\",\n \"0.48320255\",\n \"0.48254734\",\n \"0.48132473\",\n \"0.4813096\",\n \"0.48130068\",\n \"0.4809703\",\n \"0.47955266\",\n \"0.4789465\",\n \"0.47859904\",\n \"0.47847673\",\n \"0.47825488\",\n \"0.4781668\",\n \"0.47763354\",\n \"0.4774383\",\n \"0.4773635\",\n \"0.47724608\",\n \"0.47708207\",\n \"0.47706902\",\n \"0.4769254\",\n \"0.47657144\",\n \"0.47628587\",\n \"0.47612777\",\n \"0.47547013\",\n \"0.47518408\",\n \"0.47478813\",\n \"0.4743045\",\n \"0.47426757\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74753237"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9089,"cells":{"query":{"kind":"string","value":"This method clears all the LEDs in the DotStar object"},"document":{"kind":"string","value":"def clearleds(self):\n self.buffer = self.emptybuffer[:]"},"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 reset(self):\n for tlight in self.trafficLights:\n self.trafficLights[tlight].reset()","def clear(tft, oled):\n oled.fill(tft.BLACK)","def clear(self):\n self._delayvalue = _CFG[\"delay\"]\n self._colormode = _CFG[\"colormode\"]\n self._delete(\"all\")\n self._bgpic = self._createimage(\"\")\n self._bgpicname = \"nopic\"\n self._tracing = 1\n self._updatecounter = 0\n self._turtles = []\n self.bgcolor(\"white\")\n for btn in 1, 2, 3:\n self.onclick(None, btn)\n self.onkeypress(None)\n for key in self._keys[:]:\n self.onkey(None, key)\n self.onkeypress(None, key)\n Myturtle._pen = None","def off(self):\n for light in self.all:\n GPIO.output(light, 0)","def all_off():\n Leds.red_left.brightness = 0\n Leds.red_right.brightness = 0\n Leds.green_left.brightness = 0\n Leds.green_right.brightness = 0\n Leds.blue_left.brightness = 0\n Leds.blue_right.brightness = 0","def turn_all_off(self):\n for led_type in LED:\n self.led_off(led_type)\n logging.info('LED: ALL - Status: 0')","def clear_all(self):\n self._set_all(0x00, 0x00, 0x00)","def clear(self):\n self.np.fill(OFF)\n self.np.show()\n return True","def clear(self):\n black = neo.Color(0,0,0)\n self.set_all(black)\n self.draw()","def reset(self):\n for i in range(self.shapeRow):\n for j in range(self.shapeColumn):\n self.buttons[i][j].setText(\" \")","def clear_strip(self):\r\n wlogger.log_info(\"Clear Strip\")\r\n for led in range(self.num_led):\r\n self.set_pixel(led, 0, 0, 0)\r\n self.show()","def clear(self):\n self._frame.clear()\n self._turtles = []\n self._gpens = []","def clear_all(cls):\n del cls.buttons[:]","def clear(self):\n self.initialize()\n self.device_disconnect()","def clear(self):\n for i in range(len(self.canvas)):\n self.canvas[i] = 0","def all_off(self):\n self.fill_off()\n self.update()\n self.fill_off()\n self.update()","def remove_all_lights(self):\n self.RemoveAllLights()\n self._lights.clear()","def stop_all():\r\n motors.stop_all_motors()\r\n led.set_colour_solid(0)\r\n display.clear()","def reset(self):\n self.obstacles = []\n self._tick = 0","def remove_all(self):\n self.initial = None\n self.contour = None\n self.control_points = []","def clear(self):\n self.state = [[None, None, None],\n [None, None, None],\n [None, None, None]]","def reset(self):\n for gate in self.gates:\n gate.reset()","def off_all(self):\n self._set_status(\"off\", \"11111111\")","def clear(self):\n if self.flag == 0:\n for coord in INDICES:\n self.kill(coord)\n self.chart[coord] = DEAD","def deleteAll(self):\n for tlight in self.trafficLights:\n del tlight\n del self.trafficLights","def reset(self):\n for lane in self.lanes.values():\n lane.puck_area.clear_widgets()\n lane.patrons = list()\n lane.disabled = False\n lane.beers = list()\n\n self.message_holder.remove_widget(self.you_lose_label)\n self.message_holder.remove_widget(self.you_win_label)","def clear(self):\n self.raster_path_line.clear()\n self.labels_path.clear()\n self.shapefile_path.clear()\n self.costumelabels.clear()\n self.layer_name.clear()\n self.class_name.clear()\n self.idfield.clear()","def __clear(self):\n for i in range(len(self.buttons_list)):\n self.labels_strvar[i].set(\"\")\n if self.buttons_list[i][\"state\"] == DISABLED:\n self.buttons_list[i][\"state\"] = NORMAL\n self.entered_list = []\n return","def clearHotspots( self ):\n self._hotspots = []","def eraseAll(self): # remove all robots\n\t\tself.__robotList = []","def Clear(self) -> None:","def _clear_drawing(self) -> None:\n self.vertices.clear()\n self.edges.clear()\n self.subplot.clear()\n self.selected_element = None\n self.pressed_elements.clear()","def clear(self):\n self.recorders = set([])\n self.reset()\n\n # Stop any currently running SpiNNaker application\n self.stop()","def clear_all(self):\n for octet in self.master.children['!registerframe']._octets:\n for button in octet._bits_val:\n button.set(0)\n octet._update_value()\n self.master.children[\"!registerframe\"].update_reg_value()\n return None","def resetDeviceStates(self):","def reset(self):\r\n\r\n self.make_board()\r\n\r\n # configure each buttons text option to an empty string\r\n for row in range(3):\r\n for column in range(3):\r\n self.board[row][column][0]['text'] = ''","def reset(self):\n for layer in self.network:\n layer.clean()","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def clear(self) -> None:","def clear(self):\n self._turtle.clear()","def clear(self):\n self._turtle.clear()","def clear_all(cls):\n del cls.text_labels[:]","def __clearBonuses(self, hp=1):\n if hp:\n self.hpBonuses = [{}, {}, {}, {}]\n else:\n self.kbBonuses = [{}, {}, {}, {}]","def reset(self, board):","def clearAnim():\n for node in nuke.selectedNodes():\n # rotopaint\n if node.Class() == \"RotoPaint\":\n rotoCurves = node['curves']\n for knob in node.knobs():\n if nuke.Knob.isAnimated(node[knob]):\n nuke.Knob.clearAnimated(node[knob]) \n print \"clearing animation of: \"+node.name()+\" \"+node[knob].name()\n # other nodes\n if not node.Class() == \"RotoPaint\":\n for knob in node.knobs():\n if nuke.Knob.isAnimated(node[knob]):\n nuke.Knob.clearAnimated(node[knob]) \n print \"clearing animation of: \"+node.name()+\" \"+node[knob].name()","def _stop_all(self):\n # LEDs\n self.cam_led.off\n self.analysis_led[0].off\n self.analysis_led[1].off\n self.error.off\n \n # motors\n self.motor.stop()\n self.wash.stop()","def clear():","def reset ( self ):\n self.hex = ''\n self.r = 0.0\n self.g = 0.0\n self.b = 0.0\n self.h = 0.0\n self.s = 0.0\n self.l = 0.0\n self.a = 1.0\n self.rgb = []\n self.hsl = []\n self.rgba = []\n self.hsla = []\n return self","def glclear(self):\n self.pixels = [\n [color(self.r, self.g, self.b) for x in range(self.width)]\n for y in range(self.height)\n ]","def clickClearReferences(self, event):\n self.whiteReference = None\n self.lightBtn.color = '0.85'\n self.darkReference = None\n self.darkBtn.color = '0.85'\n plt.pause(0.3)\n self.axes.autoscale_view()","def clear(self):\n for row in range(self.rows):\n for col in range(self.cols):\n self.data[row][col] = '.'","def clear(self):\n for row in range(self.rows):\n for col in range(self.cols):\n self.data[row][col] = '.'","def clear(self):\n \n self.node_set.clear()\n self.prefix.clear()\n self.suffix.clear()\n self.num_node = 0\n self.edges = 0","async def clear_all(self) -> None:","def clear_all(self):\n raise NotImplementedError","def reset(self, balls=None):\r\n if balls is None:\r\n balls = self.balls\r\n for ball in balls:\r\n ball.reset()","def clear(self):\n for ob in self.obs:\n ob.clear()\n return","def clear(self):\n self._nodes = { }\n self._arcs = set()","def reset():\n Vessel.reset_instances()","def clear_elements(self):\n\n pass","def clear(self):\n self.blocks.clear()","def reset(self):\n for Myturtle in self._turtles:\n Myturtle._setmode(self._mode)\n Myturtle.reset()","def clear(self):\n ...","def clear(self):\n for i in range(0, len(self.weights)):\n self.weights[i] = 0","def clear(self):\n self.fill(None)","def clear(self):\n pass","def clear(self):\n pass","def clear(self):\n pass","def destroy(self):\n\t\tfor team in range(len(self.dots)): #will cycle through each team\n\t\t\tfor i in range(len(self.dots[team])): #will cycle through each member of the team\n\t\t\t\tdot = self.dots[team][i]\n\t\t\t\tdot.removeNode()\n\t\tself.mousePosition.removeNode()\n\t\tself.mapimage.removeNode()\n\t\tself.map.removeNode()","def clear(self):\n self.clear_actors()\n if self.__charts is not None:\n self._charts.deep_clean()\n self.remove_all_lights()\n self.RemoveAllViewProps()\n self.Modified()\n\n self._scalar_bar_slots = set(range(MAX_N_COLOR_BARS))\n self._scalar_bar_slot_lookup = {}","def ClearTools(self):\r\n\r\n self.Clear()","def kill_all(self):\n self.settings['lights_on'] = 12\n self.settings['lights_off'] = 12\n self.settings['overhead_level'] = 0\n self.settings['soil_1'] = 0\n self.settings['soil_2'] = 0\n self.settings['soil_3'] = 0\n self.settings['soil_4'] = 0\n self.scale_overhead_level.set(self.settings['overhead_level'])\n self.scale_smc1.set(self.settings['soil_1'])\n self.scale_smc2.set(self.settings['soil_2'])\n self.scale_smc3.set(self.settings['soil_3'])\n self.scale_smc4.set(self.settings['soil_4'])\n self.active_changes = True # (flag) Once changes are retrieved, we assume that they will be sent to the controller","def free(self):\n self._cords.free()\n self._colors.free()","def reset_all(self):\n for i, stop in enumerate(self):\n stop._map = self\n stop.reset()","def reset_all(self) -> None:\n for metric in self:\n metric.reset()","def clear(self) -> None:\n for y in range(self.width):\n for x in range(self.height):\n self.set_value(Point(y, x), FieldState.EMPTY)","def reset(self):\n\n self.ids.score.text = '0'\n self.ids.end_button.text = 'submit'\n self.ids.end_button.disabled = True\n self.ids.end_button.opacity = 0\n self.time = None\n\n board = self.ids.board\n\n for item in board.children:\n if isinstance(item, Space) is True:\n space = game.spacelist[int(item.number)]\n item.text = ''\n item.atom = space.atom\n item.guess = False\n item.correct = False\n item.disabled = False\n\n elif isinstance(item, Marker) is True:\n item.text = ''\n item.disabled = False\n\n for i in range(1, 6):\n self.ids['tracker' + str(i)].color = scheme.white","def clear(self) -> None:\n ...","def clr(self):\n self.a = 0.0","def clearAll(self):\r\n self.metricListWidget.clearSelection()\r\n self.metricListWidget.repaint()","def reset(self):\n for c in self.children:\n c.reset()\n self.marked = False","def button_reset(self): \n self.button_1 = arcade.Sprite(settings.button, .7, 0, 0, 0, 0, 50,\n 570)\n self.button_2 = arcade.Sprite(settings.button, .7, 0, 0, 0, 0, 50,\n 75)\n self.button_3 = arcade.Sprite(settings.button, .7, 0, 0, 0, 0, 750,\n 570)\n self.button_4 = arcade.Sprite(settings.button, .7, 0, 0, 0, 0, 750,\n 75)\n a = [1, 2, 3, 4]\n for i in a:\n self.puzzle.remove_value(i)","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","def full_clear(self):\n self.clear()\n self.class_hooks.clear()","def Clear(self):\n it = self.ctx.Iterator5(\n self.addr,\n ScType.EdgeDCommonConst,\n ScType.Unknown,\n ScType.EdgeAccessConstPosPerm,\n self.relAddr)\n \n while it.Next():\n self.ctx.DeleteElement(it.Get(1))","def reset(self):\n self.state.fill(EMPTY)","def reset(self):\n\n # the 'cached' data to be displayed by the hex view\n self.data = None\n self.mask = None\n self.data_size = 0\n self.delta = None\n\n self.address = 0\n self.fade_address = 0\n\n # pinned memory / breakpoint selections\n self._pinned_selections = []","def Reset(self):\n pass","def clear_strip(self):\n self.spi.write(bytearray([0] * 4 +\n [255, 0, 0, 0] * self.bmp2led.num_pixels +\n [255] * ((self.bmp2led.num_pixels + 15) //\n 16)))","def clear(self):\n self.xi[:] = 0\n self.meanlogr[:] = 0\n self.weight[:] = 0\n self.npairs[:] = 0","def clear(self):\n board.change_grid(self.x, self.y, 0)","def Clear(self):\n self.output = []\n self.out_byte = 0\n self.out_boff = 0\n self.idx_byte = 0\n self.idx_boff = 0","def reset(self):\n \n pass","def clear(self):\n self.nodes = list()\n self.inputs = list()\n self.nodes += [self]"],"string":"[\n \"def reset(self):\\n for tlight in self.trafficLights:\\n self.trafficLights[tlight].reset()\",\n \"def clear(tft, oled):\\n oled.fill(tft.BLACK)\",\n \"def clear(self):\\n self._delayvalue = _CFG[\\\"delay\\\"]\\n self._colormode = _CFG[\\\"colormode\\\"]\\n self._delete(\\\"all\\\")\\n self._bgpic = self._createimage(\\\"\\\")\\n self._bgpicname = \\\"nopic\\\"\\n self._tracing = 1\\n self._updatecounter = 0\\n self._turtles = []\\n self.bgcolor(\\\"white\\\")\\n for btn in 1, 2, 3:\\n self.onclick(None, btn)\\n self.onkeypress(None)\\n for key in self._keys[:]:\\n self.onkey(None, key)\\n self.onkeypress(None, key)\\n Myturtle._pen = None\",\n \"def off(self):\\n for light in self.all:\\n GPIO.output(light, 0)\",\n \"def all_off():\\n Leds.red_left.brightness = 0\\n Leds.red_right.brightness = 0\\n Leds.green_left.brightness = 0\\n Leds.green_right.brightness = 0\\n Leds.blue_left.brightness = 0\\n Leds.blue_right.brightness = 0\",\n \"def turn_all_off(self):\\n for led_type in LED:\\n self.led_off(led_type)\\n logging.info('LED: ALL - Status: 0')\",\n \"def clear_all(self):\\n self._set_all(0x00, 0x00, 0x00)\",\n \"def clear(self):\\n self.np.fill(OFF)\\n self.np.show()\\n return True\",\n \"def clear(self):\\n black = neo.Color(0,0,0)\\n self.set_all(black)\\n self.draw()\",\n \"def reset(self):\\n for i in range(self.shapeRow):\\n for j in range(self.shapeColumn):\\n self.buttons[i][j].setText(\\\" \\\")\",\n \"def clear_strip(self):\\r\\n wlogger.log_info(\\\"Clear Strip\\\")\\r\\n for led in range(self.num_led):\\r\\n self.set_pixel(led, 0, 0, 0)\\r\\n self.show()\",\n \"def clear(self):\\n self._frame.clear()\\n self._turtles = []\\n self._gpens = []\",\n \"def clear_all(cls):\\n del cls.buttons[:]\",\n \"def clear(self):\\n self.initialize()\\n self.device_disconnect()\",\n \"def clear(self):\\n for i in range(len(self.canvas)):\\n self.canvas[i] = 0\",\n \"def all_off(self):\\n self.fill_off()\\n self.update()\\n self.fill_off()\\n self.update()\",\n \"def remove_all_lights(self):\\n self.RemoveAllLights()\\n self._lights.clear()\",\n \"def stop_all():\\r\\n motors.stop_all_motors()\\r\\n led.set_colour_solid(0)\\r\\n display.clear()\",\n \"def reset(self):\\n self.obstacles = []\\n self._tick = 0\",\n \"def remove_all(self):\\n self.initial = None\\n self.contour = None\\n self.control_points = []\",\n \"def clear(self):\\n self.state = [[None, None, None],\\n [None, None, None],\\n [None, None, None]]\",\n \"def reset(self):\\n for gate in self.gates:\\n gate.reset()\",\n \"def off_all(self):\\n self._set_status(\\\"off\\\", \\\"11111111\\\")\",\n \"def clear(self):\\n if self.flag == 0:\\n for coord in INDICES:\\n self.kill(coord)\\n self.chart[coord] = DEAD\",\n \"def deleteAll(self):\\n for tlight in self.trafficLights:\\n del tlight\\n del self.trafficLights\",\n \"def reset(self):\\n for lane in self.lanes.values():\\n lane.puck_area.clear_widgets()\\n lane.patrons = list()\\n lane.disabled = False\\n lane.beers = list()\\n\\n self.message_holder.remove_widget(self.you_lose_label)\\n self.message_holder.remove_widget(self.you_win_label)\",\n \"def clear(self):\\n self.raster_path_line.clear()\\n self.labels_path.clear()\\n self.shapefile_path.clear()\\n self.costumelabels.clear()\\n self.layer_name.clear()\\n self.class_name.clear()\\n self.idfield.clear()\",\n \"def __clear(self):\\n for i in range(len(self.buttons_list)):\\n self.labels_strvar[i].set(\\\"\\\")\\n if self.buttons_list[i][\\\"state\\\"] == DISABLED:\\n self.buttons_list[i][\\\"state\\\"] = NORMAL\\n self.entered_list = []\\n return\",\n \"def clearHotspots( self ):\\n self._hotspots = []\",\n \"def eraseAll(self): # remove all robots\\n\\t\\tself.__robotList = []\",\n \"def Clear(self) -> None:\",\n \"def _clear_drawing(self) -> None:\\n self.vertices.clear()\\n self.edges.clear()\\n self.subplot.clear()\\n self.selected_element = None\\n self.pressed_elements.clear()\",\n \"def clear(self):\\n self.recorders = set([])\\n self.reset()\\n\\n # Stop any currently running SpiNNaker application\\n self.stop()\",\n \"def clear_all(self):\\n for octet in self.master.children['!registerframe']._octets:\\n for button in octet._bits_val:\\n button.set(0)\\n octet._update_value()\\n self.master.children[\\\"!registerframe\\\"].update_reg_value()\\n return None\",\n \"def resetDeviceStates(self):\",\n \"def reset(self):\\r\\n\\r\\n self.make_board()\\r\\n\\r\\n # configure each buttons text option to an empty string\\r\\n for row in range(3):\\r\\n for column in range(3):\\r\\n self.board[row][column][0]['text'] = ''\",\n \"def reset(self):\\n for layer in self.network:\\n layer.clean()\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self) -> None:\",\n \"def clear(self):\\n self._turtle.clear()\",\n \"def clear(self):\\n self._turtle.clear()\",\n \"def clear_all(cls):\\n del cls.text_labels[:]\",\n \"def __clearBonuses(self, hp=1):\\n if hp:\\n self.hpBonuses = [{}, {}, {}, {}]\\n else:\\n self.kbBonuses = [{}, {}, {}, {}]\",\n \"def reset(self, board):\",\n \"def clearAnim():\\n for node in nuke.selectedNodes():\\n # rotopaint\\n if node.Class() == \\\"RotoPaint\\\":\\n rotoCurves = node['curves']\\n for knob in node.knobs():\\n if nuke.Knob.isAnimated(node[knob]):\\n nuke.Knob.clearAnimated(node[knob]) \\n print \\\"clearing animation of: \\\"+node.name()+\\\" \\\"+node[knob].name()\\n # other nodes\\n if not node.Class() == \\\"RotoPaint\\\":\\n for knob in node.knobs():\\n if nuke.Knob.isAnimated(node[knob]):\\n nuke.Knob.clearAnimated(node[knob]) \\n print \\\"clearing animation of: \\\"+node.name()+\\\" \\\"+node[knob].name()\",\n \"def _stop_all(self):\\n # LEDs\\n self.cam_led.off\\n self.analysis_led[0].off\\n self.analysis_led[1].off\\n self.error.off\\n \\n # motors\\n self.motor.stop()\\n self.wash.stop()\",\n \"def clear():\",\n \"def reset ( self ):\\n self.hex = ''\\n self.r = 0.0\\n self.g = 0.0\\n self.b = 0.0\\n self.h = 0.0\\n self.s = 0.0\\n self.l = 0.0\\n self.a = 1.0\\n self.rgb = []\\n self.hsl = []\\n self.rgba = []\\n self.hsla = []\\n return self\",\n \"def glclear(self):\\n self.pixels = [\\n [color(self.r, self.g, self.b) for x in range(self.width)]\\n for y in range(self.height)\\n ]\",\n \"def clickClearReferences(self, event):\\n self.whiteReference = None\\n self.lightBtn.color = '0.85'\\n self.darkReference = None\\n self.darkBtn.color = '0.85'\\n plt.pause(0.3)\\n self.axes.autoscale_view()\",\n \"def clear(self):\\n for row in range(self.rows):\\n for col in range(self.cols):\\n self.data[row][col] = '.'\",\n \"def clear(self):\\n for row in range(self.rows):\\n for col in range(self.cols):\\n self.data[row][col] = '.'\",\n \"def clear(self):\\n \\n self.node_set.clear()\\n self.prefix.clear()\\n self.suffix.clear()\\n self.num_node = 0\\n self.edges = 0\",\n \"async def clear_all(self) -> None:\",\n \"def clear_all(self):\\n raise NotImplementedError\",\n \"def reset(self, balls=None):\\r\\n if balls is None:\\r\\n balls = self.balls\\r\\n for ball in balls:\\r\\n ball.reset()\",\n \"def clear(self):\\n for ob in self.obs:\\n ob.clear()\\n return\",\n \"def clear(self):\\n self._nodes = { }\\n self._arcs = set()\",\n \"def reset():\\n Vessel.reset_instances()\",\n \"def clear_elements(self):\\n\\n pass\",\n \"def clear(self):\\n self.blocks.clear()\",\n \"def reset(self):\\n for Myturtle in self._turtles:\\n Myturtle._setmode(self._mode)\\n Myturtle.reset()\",\n \"def clear(self):\\n ...\",\n \"def clear(self):\\n for i in range(0, len(self.weights)):\\n self.weights[i] = 0\",\n \"def clear(self):\\n self.fill(None)\",\n \"def clear(self):\\n pass\",\n \"def clear(self):\\n pass\",\n \"def clear(self):\\n pass\",\n \"def destroy(self):\\n\\t\\tfor team in range(len(self.dots)): #will cycle through each team\\n\\t\\t\\tfor i in range(len(self.dots[team])): #will cycle through each member of the team\\n\\t\\t\\t\\tdot = self.dots[team][i]\\n\\t\\t\\t\\tdot.removeNode()\\n\\t\\tself.mousePosition.removeNode()\\n\\t\\tself.mapimage.removeNode()\\n\\t\\tself.map.removeNode()\",\n \"def clear(self):\\n self.clear_actors()\\n if self.__charts is not None:\\n self._charts.deep_clean()\\n self.remove_all_lights()\\n self.RemoveAllViewProps()\\n self.Modified()\\n\\n self._scalar_bar_slots = set(range(MAX_N_COLOR_BARS))\\n self._scalar_bar_slot_lookup = {}\",\n \"def ClearTools(self):\\r\\n\\r\\n self.Clear()\",\n \"def kill_all(self):\\n self.settings['lights_on'] = 12\\n self.settings['lights_off'] = 12\\n self.settings['overhead_level'] = 0\\n self.settings['soil_1'] = 0\\n self.settings['soil_2'] = 0\\n self.settings['soil_3'] = 0\\n self.settings['soil_4'] = 0\\n self.scale_overhead_level.set(self.settings['overhead_level'])\\n self.scale_smc1.set(self.settings['soil_1'])\\n self.scale_smc2.set(self.settings['soil_2'])\\n self.scale_smc3.set(self.settings['soil_3'])\\n self.scale_smc4.set(self.settings['soil_4'])\\n self.active_changes = True # (flag) Once changes are retrieved, we assume that they will be sent to the controller\",\n \"def free(self):\\n self._cords.free()\\n self._colors.free()\",\n \"def reset_all(self):\\n for i, stop in enumerate(self):\\n stop._map = self\\n stop.reset()\",\n \"def reset_all(self) -> None:\\n for metric in self:\\n metric.reset()\",\n \"def clear(self) -> None:\\n for y in range(self.width):\\n for x in range(self.height):\\n self.set_value(Point(y, x), FieldState.EMPTY)\",\n \"def reset(self):\\n\\n self.ids.score.text = '0'\\n self.ids.end_button.text = 'submit'\\n self.ids.end_button.disabled = True\\n self.ids.end_button.opacity = 0\\n self.time = None\\n\\n board = self.ids.board\\n\\n for item in board.children:\\n if isinstance(item, Space) is True:\\n space = game.spacelist[int(item.number)]\\n item.text = ''\\n item.atom = space.atom\\n item.guess = False\\n item.correct = False\\n item.disabled = False\\n\\n elif isinstance(item, Marker) is True:\\n item.text = ''\\n item.disabled = False\\n\\n for i in range(1, 6):\\n self.ids['tracker' + str(i)].color = scheme.white\",\n \"def clear(self) -> None:\\n ...\",\n \"def clr(self):\\n self.a = 0.0\",\n \"def clearAll(self):\\r\\n self.metricListWidget.clearSelection()\\r\\n self.metricListWidget.repaint()\",\n \"def reset(self):\\n for c in self.children:\\n c.reset()\\n self.marked = False\",\n \"def button_reset(self): \\n self.button_1 = arcade.Sprite(settings.button, .7, 0, 0, 0, 0, 50,\\n 570)\\n self.button_2 = arcade.Sprite(settings.button, .7, 0, 0, 0, 0, 50,\\n 75)\\n self.button_3 = arcade.Sprite(settings.button, .7, 0, 0, 0, 0, 750,\\n 570)\\n self.button_4 = arcade.Sprite(settings.button, .7, 0, 0, 0, 0, 750,\\n 75)\\n a = [1, 2, 3, 4]\\n for i in a:\\n self.puzzle.remove_value(i)\",\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 full_clear(self):\\n self.clear()\\n self.class_hooks.clear()\",\n \"def Clear(self):\\n it = self.ctx.Iterator5(\\n self.addr,\\n ScType.EdgeDCommonConst,\\n ScType.Unknown,\\n ScType.EdgeAccessConstPosPerm,\\n self.relAddr)\\n \\n while it.Next():\\n self.ctx.DeleteElement(it.Get(1))\",\n \"def reset(self):\\n self.state.fill(EMPTY)\",\n \"def reset(self):\\n\\n # the 'cached' data to be displayed by the hex view\\n self.data = None\\n self.mask = None\\n self.data_size = 0\\n self.delta = None\\n\\n self.address = 0\\n self.fade_address = 0\\n\\n # pinned memory / breakpoint selections\\n self._pinned_selections = []\",\n \"def Reset(self):\\n pass\",\n \"def clear_strip(self):\\n self.spi.write(bytearray([0] * 4 +\\n [255, 0, 0, 0] * self.bmp2led.num_pixels +\\n [255] * ((self.bmp2led.num_pixels + 15) //\\n 16)))\",\n \"def clear(self):\\n self.xi[:] = 0\\n self.meanlogr[:] = 0\\n self.weight[:] = 0\\n self.npairs[:] = 0\",\n \"def clear(self):\\n board.change_grid(self.x, self.y, 0)\",\n \"def Clear(self):\\n self.output = []\\n self.out_byte = 0\\n self.out_boff = 0\\n self.idx_byte = 0\\n self.idx_boff = 0\",\n \"def reset(self):\\n \\n pass\",\n \"def clear(self):\\n self.nodes = list()\\n self.inputs = list()\\n self.nodes += [self]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7280109","0.71445733","0.70629704","0.7045428","0.7045238","0.6974367","0.6902242","0.6812371","0.679938","0.6789614","0.6783468","0.6701193","0.6695715","0.66421294","0.6637276","0.6621712","0.6612257","0.6599522","0.6587036","0.6560823","0.65587413","0.6557263","0.6530591","0.6514564","0.6512429","0.6502498","0.64983493","0.6476238","0.6462477","0.64595515","0.64412266","0.6437849","0.64189225","0.63954943","0.6393635","0.6348698","0.6306452","0.62826705","0.62826705","0.62826705","0.62826705","0.62826705","0.62826705","0.62826705","0.62791294","0.6277002","0.6277002","0.62725645","0.62681794","0.6242505","0.62352467","0.622942","0.6224886","0.6223442","0.62229514","0.6216571","0.62074566","0.62074566","0.6201602","0.6199695","0.6197135","0.6196919","0.61945814","0.6194384","0.6193694","0.618523","0.61833733","0.6181445","0.6181167","0.617389","0.61687446","0.616773","0.616773","0.616773","0.6166","0.6158737","0.61482364","0.61473215","0.61391616","0.6129238","0.6125768","0.6123486","0.6119795","0.6117107","0.61153907","0.61082864","0.61052114","0.6092857","0.6086981","0.6085673","0.6075046","0.60723597","0.607082","0.6070809","0.6069781","0.60671765","0.60667855","0.6060278","0.6058809","0.6058181"],"string":"[\n \"0.7280109\",\n \"0.71445733\",\n \"0.70629704\",\n \"0.7045428\",\n \"0.7045238\",\n \"0.6974367\",\n \"0.6902242\",\n \"0.6812371\",\n \"0.679938\",\n \"0.6789614\",\n \"0.6783468\",\n \"0.6701193\",\n \"0.6695715\",\n \"0.66421294\",\n \"0.6637276\",\n \"0.6621712\",\n \"0.6612257\",\n \"0.6599522\",\n \"0.6587036\",\n \"0.6560823\",\n \"0.65587413\",\n \"0.6557263\",\n \"0.6530591\",\n \"0.6514564\",\n \"0.6512429\",\n \"0.6502498\",\n \"0.64983493\",\n \"0.6476238\",\n \"0.6462477\",\n \"0.64595515\",\n \"0.64412266\",\n \"0.6437849\",\n \"0.64189225\",\n \"0.63954943\",\n \"0.6393635\",\n \"0.6348698\",\n \"0.6306452\",\n \"0.62826705\",\n \"0.62826705\",\n \"0.62826705\",\n \"0.62826705\",\n \"0.62826705\",\n \"0.62826705\",\n \"0.62826705\",\n \"0.62791294\",\n \"0.6277002\",\n \"0.6277002\",\n \"0.62725645\",\n \"0.62681794\",\n \"0.6242505\",\n \"0.62352467\",\n \"0.622942\",\n \"0.6224886\",\n \"0.6223442\",\n \"0.62229514\",\n \"0.6216571\",\n \"0.62074566\",\n \"0.62074566\",\n \"0.6201602\",\n \"0.6199695\",\n \"0.6197135\",\n \"0.6196919\",\n \"0.61945814\",\n \"0.6194384\",\n \"0.6193694\",\n \"0.618523\",\n \"0.61833733\",\n \"0.6181445\",\n \"0.6181167\",\n \"0.617389\",\n \"0.61687446\",\n \"0.616773\",\n \"0.616773\",\n \"0.616773\",\n \"0.6166\",\n \"0.6158737\",\n \"0.61482364\",\n \"0.61473215\",\n \"0.61391616\",\n \"0.6129238\",\n \"0.6125768\",\n \"0.6123486\",\n \"0.6119795\",\n \"0.6117107\",\n \"0.61153907\",\n \"0.61082864\",\n \"0.61052114\",\n \"0.6092857\",\n \"0.6086981\",\n \"0.6085673\",\n \"0.6075046\",\n \"0.60723597\",\n \"0.607082\",\n \"0.6070809\",\n \"0.6069781\",\n \"0.60671765\",\n \"0.60667855\",\n \"0.6060278\",\n \"0.6058809\",\n \"0.6058181\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7821158"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9090,"cells":{"query":{"kind":"string","value":"This sets the led to the specified color"},"document":{"kind":"string","value":"def setled(self, led, red=0, green=0, blue=0):\n\n # Set the offset for the bytes to be sent over SPI\n offset = led * 4\n self.buffer[offset] = 255 # equals a 1 or 0\n self.buffer[offset + 1] = blue\n self.buffer[offset + 2] = green\n self.buffer[offset + 3] = red"},"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 set_color(self, color):\n pass","def led(color: int, /) -> None:","def set_color(self, color):\n\t\tpass","def set_status_led(self, color):\n raise NotImplementedError","def set_led_color(color):\n requests.post('http://192.168.4.1/pixel', data=json.dumps(color))","def set_color(self, color):\n self.color = color","def change_color(self, color):\n self.color = color","def set_color(self, new_color):\n self.color = new_color","def set_color(color):\r\n global _current_color\r\n _current_color = color","def set_color(self, color):\n self._color = color","def set_color(self, color: str):\n self.color = color","def set_light_rgb(self, light, color):\n light_kwargs = { \"rgb_color\": color }\n if not self.use_current_brightness:\n light_kwargs[\"brightness\"] = 255\n self.turn_on(light, **light_kwargs)","def led(color: Tuple[int, int, int], /) -> None:","def set_color(self, color):\n self.light_color = color\n for f in self.color_change_cb:\n f(self)","def lamp_set_color(color):\n addresses = lamp_addresses\n\n r = hex(color[0])[2:].zfill(2)\n g = hex(color[1])[2:].zfill(2)\n b = hex(color[2])[2:].zfill(2)\n\n # the 01 here at the beginning of the message means that\n # the lamp will hold the color even when the connection is lost\n value = \"01\" + r + g + b\n\n for address in addresses:\n command = \"gatttool -b {} -t random --char-write --handle=0x0011 --value={}\".format(address, value)\n logging.debug(\"Sending command to RFduino: \" + command)\n os.system(command)","def set_led_color():\n webserver_node = webserver_publisher_node.get_webserver_node()\n try:\n data = request.json\n if int(data[\"red\"]) < 0 or int(data[\"red\"]) > 255 \\\n or int(data[\"green\"]) < 0 or int(data[\"green\"]) > 255 \\\n or int(data[\"blue\"]) < 0 or int(data[\"blue\"]) > 255:\n return jsonify(success=False, reason=\"Input is not valid\")\n # Convert to PWM\n red = int(data[\"red\"]) * LED_SCALING_FACTOR\n green = int(data[\"green\"]) * LED_SCALING_FACTOR\n blue = int(data[\"blue\"]) * LED_SCALING_FACTOR\n webserver_node.get_logger().info(\"Set LED Color: \"\n f\"Red: {red} \"\n f\"Green: {green} \"\n f\"Blue: {blue}\")\n\n set_led_color_req = SetLedCtrlSrv.Request()\n set_led_color_req.red = red\n set_led_color_req.green = green\n set_led_color_req.blue = blue\n set_led_color_res = call_service_sync(webserver_node.set_led_color_cli,\n set_led_color_req)\n if set_led_color_res and set_led_color_res.error == 0:\n data = {\"success\": True}\n else:\n webserver_node.get_logger().error(\"Set led color service call failed\")\n data = {\n \"reason\": \"Error\",\n \"success\": False\n }\n return jsonify(data)\n\n except Exception as ex:\n webserver_node.get_logger().error(f\"Unable to reach set led color server: {ex}\")\n return jsonify(success=False, reason=\"Error\")","def setColor(self, color, group=None):\n group = group is None and self.group or group\n r = self.controller.send(self.light.color(milight.color_from_rgb(*color), group))\n logger.debug('Set color to %s (group: %s): %s' % (color, self.group, r))","def set_color(self, color: str):\n self.color = bytes.fromhex(color.replace('#', ''))","def setColor(self, color):\n self.__color = color","def set_color(self, color):\n # type: (Color) -> None\n\n self.color = color","def setColor(color):\n turtleTmp.color = color\n turtleTmp.penColor(color)","def _update_color(self, color):\n self.color = color","def led(red: int, green: int, blue: int, /) -> None:","def color(self, color):\n #self._color = color\n new_color = \"{0}{1}{2}\".format(hex(int(color[0]))[2:].zfill(2),\n hex(int(color[1]))[2:].zfill(2),\n hex(int(color[2]))[2:].zfill(2))\n #self.log.info(\"RASPLes.color(%s : %s -> %s)\" % (self.number, color, new_color))\n #print(\"color(%s -> %s)\" % (self.number, new_color))\n try:\n self.current_color = new_color\n #self.strip.setPixelColor(int(self.number), self.current_color)\n self.strip.setPixelColorRGB(int(self.number), color[0], color[1], color[2])\n\n self.strip.updated = True\n except Exception as e:\n self.log.error(\"led update error\" + str(e))","def setPixelColor(self, n, color):\n\t\t#print \"pxl %s = %s\" % (n, color)\n\t\tif isinstance(n, slice):\n\t\t\tself.leds[n] = [color]*len(self.leds[n])\n\t\telse:\n\t\t\tif n >= 0 or n <= self.size:\n\t\t\t\tself.leds[n] = color\n\t\t#pprint(self.leds)","def fill(self, color: int) -> None:\n red = (color >> 16) & 0xFF\n green = (color >> 8) & 0xFF\n blue = color & 0xFF\n for x in range(24):\n offset = unpack_from(\">HHH\", self.ledmap_bytes, x * 6)\n self._is31[offset[self.r_offset]] = red\n self._is31[offset[self.g_offset]] = green\n self._is31[offset[self.b_offset]] = blue","def fill(self, color: int) -> None:\n red = (color >> 16) & 0xFF\n green = (color >> 8) & 0xFF\n blue = color & 0xFF\n for x in range(24):\n offset = unpack_from(\">HHH\", self.ledmap_bytes, x * 6)\n self._is31[offset[self.r_offset]] = red\n self._is31[offset[self.g_offset]] = green\n self._is31[offset[self.b_offset]] = blue","def color(self, color):\n\n self.container['color'] = color","def _set_color(color):\r\n\r\n return FontColor.get_color(color, add_reset=False)","def set_light_color(self, light_color):\n\n self.light_color = light_color","def setColor(clr):\n if type(clr) == types.StringType:\n setColorString(clr)\n return \n if type(clr) == types.IntType:\n setColorIndex(clr)\n return\n if type(clr) == types.TupleType:\n setColorRGB(*clr)","def set_color(self, red, green, blue, white):\n color_specs = [self._red_spec, self._green_spec, \n self._blue_spec, self._white_spec]\n\n for spec, color in zip(color_specs, [red, green, blue, white]):\n driver = DRIVERS[spec.addr]\n driver.set_time_off(spec.pin, color)","def brighter_switch(turtle, color):\n turtle.fillcolor(color + \"1\")","async def set_rgb_led(self,\n red=0,\n green=0,\n blue=0,\n save_as_user_led_color=False,\n wait_for_response=True,\n reset_inactivity_timeout=True,\n response_timeout_in_seconds=None):\n command = _create_set_rgb_led_command(red,\n green,\n blue,\n save_as_user_led_color,\n sequence_number=self._get_and_increment_command_sequence_number(),\n wait_for_response=wait_for_response,\n reset_inactivity_timeout=reset_inactivity_timeout)\n\n await self._send_command(command,\n response_timeout_in_seconds=response_timeout_in_seconds)","def set_color(color='black', index=-1): # (8)\n if index == -1:\n global color_buffer\n color_buffer = deque([color]*NUM_LEDS, maxlen=NUM_LEDS)\n else:\n color_buffer[index] = color","def _set_color(self, r):\n c = COLORS[self.color]\n r.setLineColor(c[0], c[1], c[2])\n r.setColor(c[0], c[1], c[2])","def set_led(self, *args, **kw):\n return self.execute_command('set_led', *args, **kw)","def _set_color(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"color\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"color must be of a type compatible with uint32\"\"\",\n 'defined-type': \"uint32\",\n 'generated-type': \"\"\"YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"color\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\"\"\",\n })\n\n self.__color = t\n if hasattr(self, '_set'):\n self._set()","def _set_color(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"color\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"color must be of a type compatible with uint32\"\"\",\n 'defined-type': \"uint32\",\n 'generated-type': \"\"\"YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"color\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\"\"\",\n })\n\n self.__color = t\n if hasattr(self, '_set'):\n self._set()","def _set_color(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"color\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"color must be of a type compatible with uint32\"\"\",\n 'defined-type': \"uint32\",\n 'generated-type': \"\"\"YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"color\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\"\"\",\n })\n\n self.__color = t\n if hasattr(self, '_set'):\n self._set()","def _set_color(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"color\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"color must be of a type compatible with uint32\"\"\",\n 'defined-type': \"uint32\",\n 'generated-type': \"\"\"YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"color\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\"\"\",\n })\n\n self.__color = t\n if hasattr(self, '_set'):\n self._set()","def setLeds(number: int, red: int, green: int, blue: int):\n pass","def setColor(self, color):\n color = rgba(color)\n if color != self._color:\n self._color = color\n self._updateColor(self._color)\n self._updated(ItemChangedType.COLOR)","def set_color_brightness(color, brightness):\n if brightness == 0:\n put_light_state(False, 0, 0, 16000)\n else:\n put_light_state(\n True,\n 254 * color // 100,\n 254 * brightness // 100,\n 16000\n )","def set_color(self, color):\n with doc_ctrl.open_command():\n doc_ctrl.set_color(self.lbl, color)\n std_events.document_modified.emit()","async def Turn_On_Lights_With_Color(\n color: str = Path(..., title=\"Color name or hexadecimal string\")\n) -> Dict[str, Any]:\n busylightapi.manager.light_on(ALL_LIGHTS, color)\n return {\n \"action\": \"on\",\n \"light_id\": \"all\",\n \"color\": color,\n }","def setColor(pnj, color):\r\n\r\n assert isinstance(color, (int, tuple, str))\r\n pnj[\"color\"] = color","def initColor(self, color=None, brightness=100):\n r = self.controller.send(self.light.on(self.group))\n logger.debug('Turned on lights (group: %s): %s' % (self.group, r))\n r = self.controller.send(self.light.brightness(brightness, self.group))\n logger.debug('Set brightness to %s (group: %s): %s' % (brightness, self.group, r))\n if color:\n self.setColor(color)","def set_trace_color(color): #py:set_trace_color\n RUR._set_trace_color_(color)","def change_color(self, color):\r\n if color == \"black\":\r\n self.color = \"white\"\r\n self.canvas.itemconfig(self.ball, fill='white')\r\n else:\r\n self.color = \"black\"\r\n self.canvas.itemconfig(self.ball, fill='black')","def dimmer_switch(turtle, color):\n turtle.fillcolor(color + \"4\")","def set_color(self, r=0, g=0, b=0):\n r = clamp(r)\n g = clamp(g)\n b = clamp(b)\n self._state.color = (r, g, b)\n self.send_command(Command.SET_COLOR, [int(r), int(g), int(b)])","def set_color(self, color, filled):\n for cell in filled:\n self.board[cell[0], cell[1]] = color","def setColor(self, color):\n for patch in self._patches:\n patch.setColor(color)","def color(self, color=0):\n if color not in [0, 1, 2, 3, 4, 5, 6, 7]:\n raise ValueError('color must be a positive integer less than and 8 or 0')\n else:\n self._write(self.__class__.__ESC + 'r' + chr(color))","def setColor(self, color):\n self.point_color = color\n self.side_color = color\n self.area_color = color","def color(self, color_value):\n self.app.color = color_value","def _updateColor(self, color):\n primitive = self._getScenePrimitive()\n if len(primitive.children) != 0:\n primitive.children[0].setAttribute('color', color)","def setNewColor(self, color: QColor):\n self.drawNewColor = color","def set_color(color, level):\n ok = True\n if color not in ['r', 'g', 'b']:\n ok = False\n\n if len(level) > 3:\n ok = False\n\n if level in ['0', '1']:\n ok = True\n\n if len(level) == 3 and is_float(level) and float(level) < 1:\n ok = True\n\n if ok:\n logger.info('set color '+color+' at level '+level)\n pin = get_pin_by_color(color)\n set_gpio(pin, level)\n return False\n else:\n logger.info('set color, unrecognized combination: color '+color+' at level '+level)\n return False","def set_color_rgb(r, g, b):\r\n global _current_color\r\n _current_color = (r, g, b)","def set_red_light(self, value):\n self.diffuse_light[0] = value\n self.redraw()","async def Turn_On_Light_With_Color(\n light_id: int = Path(..., title=\"Numeric light identifier\", ge=0),\n color: str = Path(..., title=\"Color name or hexadecimal string\"),\n) -> Dict[str, Any]:\n busylightapi.manager.light_on(light_id, color)\n return {\n \"action\": \"on\",\n \"light_id\": light_id,\n \"color\": color,\n }","def setColour(self, col):\n\t\tself.colour = col","def setColorString(clr):\n dislin.color(clr)","def set_pixel_rgb(self, led_num, rgb_color, bright_percent=100):\r\n self.set_pixel(led_num, (rgb_color & 0xFF0000) >> 16,\r\n (rgb_color & 0x00FF00) >> 8, rgb_color & 0x0000FF,\r\n bright_percent)","def setRandomColor():\n setColor(getRandomColor())","def UseColor(self, use_color):\n self.use_color = use_color","def set_led(self, value):\n GPIO.output(LED_PIN, value)","def set_color(objname, rgb):\r\n return f'\\ncmd.set_color(\"{objname}\", {(rgb[0], rgb[1], rgb[2])})'","def set_colour(self, address, colour):\n idaapi.set_item_color(address, colour)","def resetColor(self):\n self.setColor(255, 255, 255 ,255)","def ledFlash(strip, color, t = 1):\r\n utime.sleep(t)\r\n setStrip(strip, color)\r\n utime.sleep(t)\r\n setStrip(strip, LED_COLOR_OFF)","def led(self, value):\n self._write(MX_LED, value)","def color(self, value: tuple) -> None:\n if value in Color.PALETTE:\n self._color = value","def _set_hsv(self, color):\n\n self.qcolor.setHsv(color[0], color[1], color[2], 255)","def setColor(self, color):\n color = QtGui.QColor(color)\n color.setAlpha(50)\n self.setBrush(QtGui.QBrush(color))\n color.setAlpha(255)\n self.setPen(QtGui.QPen(color, 1.0))","def goToRGB(self, color: tuple) -> None:\n r, g, b = color\n self._sendi2c('n', [r, g, b])","def set_color(mask: int, position: int, color: int):\n return mask | (color << (position << 1))","def setPixelColor(self, n, color):\n self._logger.debug(\"setPixelColor\")","def set_led(self, on=True):\n if on:\n GPIO.output(self.LED, GPIO.HIGH)\n else:\n GPIO.output(self.LED, GPIO.LOW)","def color(self, color):\n if color is None:\n raise ValueError(\"Invalid value for `color`, must not be `None`\") # noqa: E501\n\n self._color = color","def set_rgbColorAtPowerOn(self, ledIndex, count, rgbValue):\n return self.sendCommand(\"SC\" + str(int(ledIndex)) + \",\" + str(int(count)) + \",\" + (\"%x\" % rgbValue))","def updateColorFor(self, id, color):\n\n # find the good LED strip\n currentStrip = None\n index = 0\n for LEDStrip in self._LEDStrips:\n if LEDStrip._id == id:\n currentStrip = LEDStrip\n if currentStrip == None:\n index += 1\n \n if currentStrip == None:\n return\n\n self._colors[index] = color","def color(self, new_color):\n if not isinstance(new_color, str):\n raise TypeError('''Color should be a valid str object''')\n else:\n self._color = new_color","def _set_backpack_led(self, msg):\n # setup color as integer values\n color = [int(x * 255) for x in [msg.r, msg.g, msg.b, msg.a]]\n # create lights object with duration\n light = cozmo.lights.Light(cozmo.lights.Color(rgba=color), on_period_ms=1000)\n # set lights\n self._cozmo.set_all_backpack_lights(light)","def switch_color(color):\n return \"b\" if color == \"w\" else \"w\"","def set(self, coords, colors):\n if all(isinstance(e, list) for e in coords):\n # unpack list of coordinates\n for e, c in zip(coords, colors):\n self.set(e, c)\n else:\n led_nr = self.pos_to_led_nr(coords)\n #print \"Setting LED at [%d, %d] (nr. %d) to color %s\" % (coords[0], coords[1], led_nr, colors)\n self.strip.setPixelColor(led_nr, colors)","def _set_all(self, red, green, blue):\n self.blinkt_iface.WriteValue([0x06, 0x01, red, green, blue], ())","def the_user_changes_the_color_of_the_device(color):\n web_app.change_property_softassert(\"color\",color)","def changeColor(self):\n self.layer.new_colormap()","def setDisabledColor(*args):","def setDisabledColor(*args):","def set_led(self, led, value):\n if led < 0 or led > 127:\n raise ValueError('LED must be value of 0 to 127.')\n\n # Calculate position in byte buffer and bit offset of desired LED.\n pos = led // 8\n offset = led % 8\n\n if not value:\n # Turn off the specified LED (set bit to zero).\n self.buffer[pos] &= ~(1 << offset)\n else:\n # Turn on the specified LED (set bit to one).\n self.buffer[pos] |= (1 << offset)","def setSegmentColor(self, color):\n for segment in self.segments:\n segment.color = color","def setColorIndex(idx):\n dislin.setclr(idx)","def setColor(val):\n if isinstance(val, str):\n val = val.upper()\n colors = {\"BLACK\": \"\\u001b[30m\",\n \"RED\": \"\\u001b[31m\",\n \"GREEN\": \"\\u001b[32m\",\n \"YELLOW\": \"\\u001b[33m\",\n \"BLUE\": \"\\u001b[34m\",\n \"MAGENTA\": \"\\u001b[35m\",\n \"CYAN\": \"\\u001b[36m\",\n \"WHITE\": \"\\u001b[37m\",\n \"RESET\": \"\\u001b[0m\"}\n if val in colors.keys():\n print(colors[val], end=\"\")\n return 0\n return -1","def changeColor( self ):\n\t\t\n\t\tx, y = self.position.xy\n\t\tself.color = ( int((x / WINDOW_X) * 128), int((x / WINDOW_X) * 128) + int((y / WINDOW_Y) * 128 ), int((y / WINDOW_Y) * 128))","def set_color(self, background_color, color):\n self.background_color = background_color\n self.tile_color = color\n self.controller.refresh_board()","def setFill(self, color):\n self._reconfig(\"fill\", color)"],"string":"[\n \"def set_color(self, color):\\n pass\",\n \"def led(color: int, /) -> None:\",\n \"def set_color(self, color):\\n\\t\\tpass\",\n \"def set_status_led(self, color):\\n raise NotImplementedError\",\n \"def set_led_color(color):\\n requests.post('http://192.168.4.1/pixel', data=json.dumps(color))\",\n \"def set_color(self, color):\\n self.color = color\",\n \"def change_color(self, color):\\n self.color = color\",\n \"def set_color(self, new_color):\\n self.color = new_color\",\n \"def set_color(color):\\r\\n global _current_color\\r\\n _current_color = color\",\n \"def set_color(self, color):\\n self._color = color\",\n \"def set_color(self, color: str):\\n self.color = color\",\n \"def set_light_rgb(self, light, color):\\n light_kwargs = { \\\"rgb_color\\\": color }\\n if not self.use_current_brightness:\\n light_kwargs[\\\"brightness\\\"] = 255\\n self.turn_on(light, **light_kwargs)\",\n \"def led(color: Tuple[int, int, int], /) -> None:\",\n \"def set_color(self, color):\\n self.light_color = color\\n for f in self.color_change_cb:\\n f(self)\",\n \"def lamp_set_color(color):\\n addresses = lamp_addresses\\n\\n r = hex(color[0])[2:].zfill(2)\\n g = hex(color[1])[2:].zfill(2)\\n b = hex(color[2])[2:].zfill(2)\\n\\n # the 01 here at the beginning of the message means that\\n # the lamp will hold the color even when the connection is lost\\n value = \\\"01\\\" + r + g + b\\n\\n for address in addresses:\\n command = \\\"gatttool -b {} -t random --char-write --handle=0x0011 --value={}\\\".format(address, value)\\n logging.debug(\\\"Sending command to RFduino: \\\" + command)\\n os.system(command)\",\n \"def set_led_color():\\n webserver_node = webserver_publisher_node.get_webserver_node()\\n try:\\n data = request.json\\n if int(data[\\\"red\\\"]) < 0 or int(data[\\\"red\\\"]) > 255 \\\\\\n or int(data[\\\"green\\\"]) < 0 or int(data[\\\"green\\\"]) > 255 \\\\\\n or int(data[\\\"blue\\\"]) < 0 or int(data[\\\"blue\\\"]) > 255:\\n return jsonify(success=False, reason=\\\"Input is not valid\\\")\\n # Convert to PWM\\n red = int(data[\\\"red\\\"]) * LED_SCALING_FACTOR\\n green = int(data[\\\"green\\\"]) * LED_SCALING_FACTOR\\n blue = int(data[\\\"blue\\\"]) * LED_SCALING_FACTOR\\n webserver_node.get_logger().info(\\\"Set LED Color: \\\"\\n f\\\"Red: {red} \\\"\\n f\\\"Green: {green} \\\"\\n f\\\"Blue: {blue}\\\")\\n\\n set_led_color_req = SetLedCtrlSrv.Request()\\n set_led_color_req.red = red\\n set_led_color_req.green = green\\n set_led_color_req.blue = blue\\n set_led_color_res = call_service_sync(webserver_node.set_led_color_cli,\\n set_led_color_req)\\n if set_led_color_res and set_led_color_res.error == 0:\\n data = {\\\"success\\\": True}\\n else:\\n webserver_node.get_logger().error(\\\"Set led color service call failed\\\")\\n data = {\\n \\\"reason\\\": \\\"Error\\\",\\n \\\"success\\\": False\\n }\\n return jsonify(data)\\n\\n except Exception as ex:\\n webserver_node.get_logger().error(f\\\"Unable to reach set led color server: {ex}\\\")\\n return jsonify(success=False, reason=\\\"Error\\\")\",\n \"def setColor(self, color, group=None):\\n group = group is None and self.group or group\\n r = self.controller.send(self.light.color(milight.color_from_rgb(*color), group))\\n logger.debug('Set color to %s (group: %s): %s' % (color, self.group, r))\",\n \"def set_color(self, color: str):\\n self.color = bytes.fromhex(color.replace('#', ''))\",\n \"def setColor(self, color):\\n self.__color = color\",\n \"def set_color(self, color):\\n # type: (Color) -> None\\n\\n self.color = color\",\n \"def setColor(color):\\n turtleTmp.color = color\\n turtleTmp.penColor(color)\",\n \"def _update_color(self, color):\\n self.color = color\",\n \"def led(red: int, green: int, blue: int, /) -> None:\",\n \"def color(self, color):\\n #self._color = color\\n new_color = \\\"{0}{1}{2}\\\".format(hex(int(color[0]))[2:].zfill(2),\\n hex(int(color[1]))[2:].zfill(2),\\n hex(int(color[2]))[2:].zfill(2))\\n #self.log.info(\\\"RASPLes.color(%s : %s -> %s)\\\" % (self.number, color, new_color))\\n #print(\\\"color(%s -> %s)\\\" % (self.number, new_color))\\n try:\\n self.current_color = new_color\\n #self.strip.setPixelColor(int(self.number), self.current_color)\\n self.strip.setPixelColorRGB(int(self.number), color[0], color[1], color[2])\\n\\n self.strip.updated = True\\n except Exception as e:\\n self.log.error(\\\"led update error\\\" + str(e))\",\n \"def setPixelColor(self, n, color):\\n\\t\\t#print \\\"pxl %s = %s\\\" % (n, color)\\n\\t\\tif isinstance(n, slice):\\n\\t\\t\\tself.leds[n] = [color]*len(self.leds[n])\\n\\t\\telse:\\n\\t\\t\\tif n >= 0 or n <= self.size:\\n\\t\\t\\t\\tself.leds[n] = color\\n\\t\\t#pprint(self.leds)\",\n \"def fill(self, color: int) -> None:\\n red = (color >> 16) & 0xFF\\n green = (color >> 8) & 0xFF\\n blue = color & 0xFF\\n for x in range(24):\\n offset = unpack_from(\\\">HHH\\\", self.ledmap_bytes, x * 6)\\n self._is31[offset[self.r_offset]] = red\\n self._is31[offset[self.g_offset]] = green\\n self._is31[offset[self.b_offset]] = blue\",\n \"def fill(self, color: int) -> None:\\n red = (color >> 16) & 0xFF\\n green = (color >> 8) & 0xFF\\n blue = color & 0xFF\\n for x in range(24):\\n offset = unpack_from(\\\">HHH\\\", self.ledmap_bytes, x * 6)\\n self._is31[offset[self.r_offset]] = red\\n self._is31[offset[self.g_offset]] = green\\n self._is31[offset[self.b_offset]] = blue\",\n \"def color(self, color):\\n\\n self.container['color'] = color\",\n \"def _set_color(color):\\r\\n\\r\\n return FontColor.get_color(color, add_reset=False)\",\n \"def set_light_color(self, light_color):\\n\\n self.light_color = light_color\",\n \"def setColor(clr):\\n if type(clr) == types.StringType:\\n setColorString(clr)\\n return \\n if type(clr) == types.IntType:\\n setColorIndex(clr)\\n return\\n if type(clr) == types.TupleType:\\n setColorRGB(*clr)\",\n \"def set_color(self, red, green, blue, white):\\n color_specs = [self._red_spec, self._green_spec, \\n self._blue_spec, self._white_spec]\\n\\n for spec, color in zip(color_specs, [red, green, blue, white]):\\n driver = DRIVERS[spec.addr]\\n driver.set_time_off(spec.pin, color)\",\n \"def brighter_switch(turtle, color):\\n turtle.fillcolor(color + \\\"1\\\")\",\n \"async def set_rgb_led(self,\\n red=0,\\n green=0,\\n blue=0,\\n save_as_user_led_color=False,\\n wait_for_response=True,\\n reset_inactivity_timeout=True,\\n response_timeout_in_seconds=None):\\n command = _create_set_rgb_led_command(red,\\n green,\\n blue,\\n save_as_user_led_color,\\n sequence_number=self._get_and_increment_command_sequence_number(),\\n wait_for_response=wait_for_response,\\n reset_inactivity_timeout=reset_inactivity_timeout)\\n\\n await self._send_command(command,\\n response_timeout_in_seconds=response_timeout_in_seconds)\",\n \"def set_color(color='black', index=-1): # (8)\\n if index == -1:\\n global color_buffer\\n color_buffer = deque([color]*NUM_LEDS, maxlen=NUM_LEDS)\\n else:\\n color_buffer[index] = color\",\n \"def _set_color(self, r):\\n c = COLORS[self.color]\\n r.setLineColor(c[0], c[1], c[2])\\n r.setColor(c[0], c[1], c[2])\",\n \"def set_led(self, *args, **kw):\\n return self.execute_command('set_led', *args, **kw)\",\n \"def _set_color(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\\\"color\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"color must be of a type compatible with uint32\\\"\\\"\\\",\\n 'defined-type': \\\"uint32\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\\\"color\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\\\"\\\"\\\",\\n })\\n\\n self.__color = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def _set_color(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\\\"color\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"color must be of a type compatible with uint32\\\"\\\"\\\",\\n 'defined-type': \\\"uint32\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\\\"color\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\\\"\\\"\\\",\\n })\\n\\n self.__color = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def _set_color(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\\\"color\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"color must be of a type compatible with uint32\\\"\\\"\\\",\\n 'defined-type': \\\"uint32\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\\\"color\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\\\"\\\"\\\",\\n })\\n\\n self.__color = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def _set_color(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\\\"color\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"color must be of a type compatible with uint32\\\"\\\"\\\",\\n 'defined-type': \\\"uint32\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\\\"color\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='uint32', is_config=False)\\\"\\\"\\\",\\n })\\n\\n self.__color = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def setLeds(number: int, red: int, green: int, blue: int):\\n pass\",\n \"def setColor(self, color):\\n color = rgba(color)\\n if color != self._color:\\n self._color = color\\n self._updateColor(self._color)\\n self._updated(ItemChangedType.COLOR)\",\n \"def set_color_brightness(color, brightness):\\n if brightness == 0:\\n put_light_state(False, 0, 0, 16000)\\n else:\\n put_light_state(\\n True,\\n 254 * color // 100,\\n 254 * brightness // 100,\\n 16000\\n )\",\n \"def set_color(self, color):\\n with doc_ctrl.open_command():\\n doc_ctrl.set_color(self.lbl, color)\\n std_events.document_modified.emit()\",\n \"async def Turn_On_Lights_With_Color(\\n color: str = Path(..., title=\\\"Color name or hexadecimal string\\\")\\n) -> Dict[str, Any]:\\n busylightapi.manager.light_on(ALL_LIGHTS, color)\\n return {\\n \\\"action\\\": \\\"on\\\",\\n \\\"light_id\\\": \\\"all\\\",\\n \\\"color\\\": color,\\n }\",\n \"def setColor(pnj, color):\\r\\n\\r\\n assert isinstance(color, (int, tuple, str))\\r\\n pnj[\\\"color\\\"] = color\",\n \"def initColor(self, color=None, brightness=100):\\n r = self.controller.send(self.light.on(self.group))\\n logger.debug('Turned on lights (group: %s): %s' % (self.group, r))\\n r = self.controller.send(self.light.brightness(brightness, self.group))\\n logger.debug('Set brightness to %s (group: %s): %s' % (brightness, self.group, r))\\n if color:\\n self.setColor(color)\",\n \"def set_trace_color(color): #py:set_trace_color\\n RUR._set_trace_color_(color)\",\n \"def change_color(self, color):\\r\\n if color == \\\"black\\\":\\r\\n self.color = \\\"white\\\"\\r\\n self.canvas.itemconfig(self.ball, fill='white')\\r\\n else:\\r\\n self.color = \\\"black\\\"\\r\\n self.canvas.itemconfig(self.ball, fill='black')\",\n \"def dimmer_switch(turtle, color):\\n turtle.fillcolor(color + \\\"4\\\")\",\n \"def set_color(self, r=0, g=0, b=0):\\n r = clamp(r)\\n g = clamp(g)\\n b = clamp(b)\\n self._state.color = (r, g, b)\\n self.send_command(Command.SET_COLOR, [int(r), int(g), int(b)])\",\n \"def set_color(self, color, filled):\\n for cell in filled:\\n self.board[cell[0], cell[1]] = color\",\n \"def setColor(self, color):\\n for patch in self._patches:\\n patch.setColor(color)\",\n \"def color(self, color=0):\\n if color not in [0, 1, 2, 3, 4, 5, 6, 7]:\\n raise ValueError('color must be a positive integer less than and 8 or 0')\\n else:\\n self._write(self.__class__.__ESC + 'r' + chr(color))\",\n \"def setColor(self, color):\\n self.point_color = color\\n self.side_color = color\\n self.area_color = color\",\n \"def color(self, color_value):\\n self.app.color = color_value\",\n \"def _updateColor(self, color):\\n primitive = self._getScenePrimitive()\\n if len(primitive.children) != 0:\\n primitive.children[0].setAttribute('color', color)\",\n \"def setNewColor(self, color: QColor):\\n self.drawNewColor = color\",\n \"def set_color(color, level):\\n ok = True\\n if color not in ['r', 'g', 'b']:\\n ok = False\\n\\n if len(level) > 3:\\n ok = False\\n\\n if level in ['0', '1']:\\n ok = True\\n\\n if len(level) == 3 and is_float(level) and float(level) < 1:\\n ok = True\\n\\n if ok:\\n logger.info('set color '+color+' at level '+level)\\n pin = get_pin_by_color(color)\\n set_gpio(pin, level)\\n return False\\n else:\\n logger.info('set color, unrecognized combination: color '+color+' at level '+level)\\n return False\",\n \"def set_color_rgb(r, g, b):\\r\\n global _current_color\\r\\n _current_color = (r, g, b)\",\n \"def set_red_light(self, value):\\n self.diffuse_light[0] = value\\n self.redraw()\",\n \"async def Turn_On_Light_With_Color(\\n light_id: int = Path(..., title=\\\"Numeric light identifier\\\", ge=0),\\n color: str = Path(..., title=\\\"Color name or hexadecimal string\\\"),\\n) -> Dict[str, Any]:\\n busylightapi.manager.light_on(light_id, color)\\n return {\\n \\\"action\\\": \\\"on\\\",\\n \\\"light_id\\\": light_id,\\n \\\"color\\\": color,\\n }\",\n \"def setColour(self, col):\\n\\t\\tself.colour = col\",\n \"def setColorString(clr):\\n dislin.color(clr)\",\n \"def set_pixel_rgb(self, led_num, rgb_color, bright_percent=100):\\r\\n self.set_pixel(led_num, (rgb_color & 0xFF0000) >> 16,\\r\\n (rgb_color & 0x00FF00) >> 8, rgb_color & 0x0000FF,\\r\\n bright_percent)\",\n \"def setRandomColor():\\n setColor(getRandomColor())\",\n \"def UseColor(self, use_color):\\n self.use_color = use_color\",\n \"def set_led(self, value):\\n GPIO.output(LED_PIN, value)\",\n \"def set_color(objname, rgb):\\r\\n return f'\\\\ncmd.set_color(\\\"{objname}\\\", {(rgb[0], rgb[1], rgb[2])})'\",\n \"def set_colour(self, address, colour):\\n idaapi.set_item_color(address, colour)\",\n \"def resetColor(self):\\n self.setColor(255, 255, 255 ,255)\",\n \"def ledFlash(strip, color, t = 1):\\r\\n utime.sleep(t)\\r\\n setStrip(strip, color)\\r\\n utime.sleep(t)\\r\\n setStrip(strip, LED_COLOR_OFF)\",\n \"def led(self, value):\\n self._write(MX_LED, value)\",\n \"def color(self, value: tuple) -> None:\\n if value in Color.PALETTE:\\n self._color = value\",\n \"def _set_hsv(self, color):\\n\\n self.qcolor.setHsv(color[0], color[1], color[2], 255)\",\n \"def setColor(self, color):\\n color = QtGui.QColor(color)\\n color.setAlpha(50)\\n self.setBrush(QtGui.QBrush(color))\\n color.setAlpha(255)\\n self.setPen(QtGui.QPen(color, 1.0))\",\n \"def goToRGB(self, color: tuple) -> None:\\n r, g, b = color\\n self._sendi2c('n', [r, g, b])\",\n \"def set_color(mask: int, position: int, color: int):\\n return mask | (color << (position << 1))\",\n \"def setPixelColor(self, n, color):\\n self._logger.debug(\\\"setPixelColor\\\")\",\n \"def set_led(self, on=True):\\n if on:\\n GPIO.output(self.LED, GPIO.HIGH)\\n else:\\n GPIO.output(self.LED, GPIO.LOW)\",\n \"def color(self, color):\\n if color is None:\\n raise ValueError(\\\"Invalid value for `color`, must not be `None`\\\") # noqa: E501\\n\\n self._color = color\",\n \"def set_rgbColorAtPowerOn(self, ledIndex, count, rgbValue):\\n return self.sendCommand(\\\"SC\\\" + str(int(ledIndex)) + \\\",\\\" + str(int(count)) + \\\",\\\" + (\\\"%x\\\" % rgbValue))\",\n \"def updateColorFor(self, id, color):\\n\\n # find the good LED strip\\n currentStrip = None\\n index = 0\\n for LEDStrip in self._LEDStrips:\\n if LEDStrip._id == id:\\n currentStrip = LEDStrip\\n if currentStrip == None:\\n index += 1\\n \\n if currentStrip == None:\\n return\\n\\n self._colors[index] = color\",\n \"def color(self, new_color):\\n if not isinstance(new_color, str):\\n raise TypeError('''Color should be a valid str object''')\\n else:\\n self._color = new_color\",\n \"def _set_backpack_led(self, msg):\\n # setup color as integer values\\n color = [int(x * 255) for x in [msg.r, msg.g, msg.b, msg.a]]\\n # create lights object with duration\\n light = cozmo.lights.Light(cozmo.lights.Color(rgba=color), on_period_ms=1000)\\n # set lights\\n self._cozmo.set_all_backpack_lights(light)\",\n \"def switch_color(color):\\n return \\\"b\\\" if color == \\\"w\\\" else \\\"w\\\"\",\n \"def set(self, coords, colors):\\n if all(isinstance(e, list) for e in coords):\\n # unpack list of coordinates\\n for e, c in zip(coords, colors):\\n self.set(e, c)\\n else:\\n led_nr = self.pos_to_led_nr(coords)\\n #print \\\"Setting LED at [%d, %d] (nr. %d) to color %s\\\" % (coords[0], coords[1], led_nr, colors)\\n self.strip.setPixelColor(led_nr, colors)\",\n \"def _set_all(self, red, green, blue):\\n self.blinkt_iface.WriteValue([0x06, 0x01, red, green, blue], ())\",\n \"def the_user_changes_the_color_of_the_device(color):\\n web_app.change_property_softassert(\\\"color\\\",color)\",\n \"def changeColor(self):\\n self.layer.new_colormap()\",\n \"def setDisabledColor(*args):\",\n \"def setDisabledColor(*args):\",\n \"def set_led(self, led, value):\\n if led < 0 or led > 127:\\n raise ValueError('LED must be value of 0 to 127.')\\n\\n # Calculate position in byte buffer and bit offset of desired LED.\\n pos = led // 8\\n offset = led % 8\\n\\n if not value:\\n # Turn off the specified LED (set bit to zero).\\n self.buffer[pos] &= ~(1 << offset)\\n else:\\n # Turn on the specified LED (set bit to one).\\n self.buffer[pos] |= (1 << offset)\",\n \"def setSegmentColor(self, color):\\n for segment in self.segments:\\n segment.color = color\",\n \"def setColorIndex(idx):\\n dislin.setclr(idx)\",\n \"def setColor(val):\\n if isinstance(val, str):\\n val = val.upper()\\n colors = {\\\"BLACK\\\": \\\"\\\\u001b[30m\\\",\\n \\\"RED\\\": \\\"\\\\u001b[31m\\\",\\n \\\"GREEN\\\": \\\"\\\\u001b[32m\\\",\\n \\\"YELLOW\\\": \\\"\\\\u001b[33m\\\",\\n \\\"BLUE\\\": \\\"\\\\u001b[34m\\\",\\n \\\"MAGENTA\\\": \\\"\\\\u001b[35m\\\",\\n \\\"CYAN\\\": \\\"\\\\u001b[36m\\\",\\n \\\"WHITE\\\": \\\"\\\\u001b[37m\\\",\\n \\\"RESET\\\": \\\"\\\\u001b[0m\\\"}\\n if val in colors.keys():\\n print(colors[val], end=\\\"\\\")\\n return 0\\n return -1\",\n \"def changeColor( self ):\\n\\t\\t\\n\\t\\tx, y = self.position.xy\\n\\t\\tself.color = ( int((x / WINDOW_X) * 128), int((x / WINDOW_X) * 128) + int((y / WINDOW_Y) * 128 ), int((y / WINDOW_Y) * 128))\",\n \"def set_color(self, background_color, color):\\n self.background_color = background_color\\n self.tile_color = color\\n self.controller.refresh_board()\",\n \"def setFill(self, color):\\n self._reconfig(\\\"fill\\\", color)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79685086","0.7963265","0.7882642","0.7830038","0.7777075","0.7772559","0.7689048","0.7609751","0.7561696","0.7547319","0.7526898","0.75140256","0.74926007","0.7445177","0.74438715","0.7430585","0.741375","0.73898387","0.73771507","0.7346666","0.7305123","0.72747093","0.72687155","0.71840864","0.7130954","0.7103072","0.7103072","0.70966136","0.7046952","0.7029563","0.6967964","0.6948798","0.6924422","0.6887847","0.6868575","0.6865929","0.6848465","0.6811287","0.6811287","0.6811287","0.6811287","0.6798989","0.67960006","0.6779764","0.6775324","0.67571574","0.6752627","0.67466164","0.6742793","0.6742194","0.6740286","0.6725959","0.672419","0.6718614","0.67122793","0.67021793","0.66584283","0.6609771","0.66043717","0.6604235","0.65972656","0.6593919","0.6588328","0.6556946","0.65535915","0.65468264","0.65445507","0.65379393","0.6523506","0.6514353","0.6507703","0.64842826","0.6463011","0.6457596","0.64515984","0.6449057","0.6389546","0.6386578","0.636371","0.63579094","0.6357788","0.6347943","0.63428676","0.63385856","0.63299257","0.6327272","0.63087106","0.6301098","0.6286001","0.6285706","0.6285045","0.62839437","0.62839437","0.62779385","0.6277856","0.62774694","0.6270267","0.6269983","0.6268607","0.62666315"],"string":"[\n \"0.79685086\",\n \"0.7963265\",\n \"0.7882642\",\n \"0.7830038\",\n \"0.7777075\",\n \"0.7772559\",\n \"0.7689048\",\n \"0.7609751\",\n \"0.7561696\",\n \"0.7547319\",\n \"0.7526898\",\n \"0.75140256\",\n \"0.74926007\",\n \"0.7445177\",\n \"0.74438715\",\n \"0.7430585\",\n \"0.741375\",\n \"0.73898387\",\n \"0.73771507\",\n \"0.7346666\",\n \"0.7305123\",\n \"0.72747093\",\n \"0.72687155\",\n \"0.71840864\",\n \"0.7130954\",\n \"0.7103072\",\n \"0.7103072\",\n \"0.70966136\",\n \"0.7046952\",\n \"0.7029563\",\n \"0.6967964\",\n \"0.6948798\",\n \"0.6924422\",\n \"0.6887847\",\n \"0.6868575\",\n \"0.6865929\",\n \"0.6848465\",\n \"0.6811287\",\n \"0.6811287\",\n \"0.6811287\",\n \"0.6811287\",\n \"0.6798989\",\n \"0.67960006\",\n \"0.6779764\",\n \"0.6775324\",\n \"0.67571574\",\n \"0.6752627\",\n \"0.67466164\",\n \"0.6742793\",\n \"0.6742194\",\n \"0.6740286\",\n \"0.6725959\",\n \"0.672419\",\n \"0.6718614\",\n \"0.67122793\",\n \"0.67021793\",\n \"0.66584283\",\n \"0.6609771\",\n \"0.66043717\",\n \"0.6604235\",\n \"0.65972656\",\n \"0.6593919\",\n \"0.6588328\",\n \"0.6556946\",\n \"0.65535915\",\n \"0.65468264\",\n \"0.65445507\",\n \"0.65379393\",\n \"0.6523506\",\n \"0.6514353\",\n \"0.6507703\",\n \"0.64842826\",\n \"0.6463011\",\n \"0.6457596\",\n \"0.64515984\",\n \"0.6449057\",\n \"0.6389546\",\n \"0.6386578\",\n \"0.636371\",\n \"0.63579094\",\n \"0.6357788\",\n \"0.6347943\",\n \"0.63428676\",\n \"0.63385856\",\n \"0.63299257\",\n \"0.6327272\",\n \"0.63087106\",\n \"0.6301098\",\n \"0.6286001\",\n \"0.6285706\",\n \"0.6285045\",\n \"0.62839437\",\n \"0.62839437\",\n \"0.62779385\",\n \"0.6277856\",\n \"0.62774694\",\n \"0.6270267\",\n \"0.6269983\",\n \"0.6268607\",\n \"0.62666315\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76878345"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":9091,"cells":{"query":{"kind":"string","value":"This method send the led data over SPI"},"document":{"kind":"string","value":"def send(self):\n self.spi.send(self.startframe + self.buffer)"},"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 send(self, data):\n self._serial.write('spi = SPI(2, SPI.SLAVE, baudrate=500000, polarity=0, phase=0)\\r\\n'.encode('utf-8'))\n self._serial.write('data=bytearray({})\\r\\n'.format(data).encode('utf-8'))\n self._serial.write('spi.send(data, timeout=50000)\\r\\n'.encode('utf-8'))\n sleep(1)","def _data(self, data):\n# \"\"\"Send data to spi bus of display chip, most DC pin need set to HIGH \"\"\"\n# if self._spi == None: raise \"Do not setting SPI\"\n# GPIO.output( self._spi_dc, 1 )\n# self._spi.writebytes( data )\n raise NotImplementedError","def send_recv(self, data):\n self._serial.write('spi = SPI(2, SPI.SLAVE, baudrate=500000, polarity=0, phase=0)\\r\\n'.encode('utf-8'))\n self._serial.write('data=bytearray({})\\r\\n'.format(data).encode('utf-8'))\n self._serial.write('list(spi.send_recv(data, timeout=50000))\\r\\n'.encode('utf-8'))\n sleep(1)","def update(self):\n\t\tfor x in range(self.leds):\n\t\t\tself.spi.write(self.buffer[x])\n\t\t\t#self.spi.flush()\n\t\t\t\n\t\tself.spi.write(bytearray(b'\\x00'))\n\t\tself.spi.flush()","def _send_data(self, data):\n if isinstance(data, int):\n data = [data]\n self._spi_write(_SPI_DATA, data)","def send_to_port(self):\r\n time.sleep(2)\r\n # ser.write(\"R\".encode())\r\n ser.flush()\r\n ser.write(\"{},{},{},{},{}\".format(self.x_Pos, self.y_Pos, self.t_Tap, self.U_on, self.u_off).encode())\r\n # ser.flush()\r\n # while (1 == 1):\r\n # mydata = ser.readline().lstrip()\r\n # print(mydata.decode('utf-8'))\r\n # value = str(mydata)\r","def SPIwriteenable(self):\n data=[0x06];\n self.SPItrans(data);","def data(self, data):\n self._gpio.set_high(self._dc)\n for t in data:\n\t\t self._spi.write([t])","def SPItrans(self,data):\n self.data=data;\n self.writecmd(0x01,0x00,len(data),data);\n return self.data;","def send_traffic_data(serialport, pack):\n pack[0] = 0x01\n pack[1] = 0x00\n serialport.write(pack)\n logging.debug(\"Traffic Data - Sent.\")\n logging.debug(str(pack))","def SPIsetup(self):\n self.writecmd(0x01,0x10,0,self.data); #SPI/SETUP","def write(self, buffer):\n utils.print_for_unimplemented_functions(SPI.write.__name__)\n telemetry_py.send_telemetry(TelemetryEvent.MICROBIT_API_SPI)","def __transfer(self, data: int):\n self.__spi.writebytes(data)","def send_data(self, data: int):\n self.write_pin(self.DC_PIN, RPi.GPIO.HIGH)\n self.__transfer([data])","def _command(self, commands):\n# \"\"\"Send command to spi bus of display chip, most DC pin need set to LOW \"\"\"\n# if self._spi == None: raise \"Do not setting SPI\"\n# GPIO.output( self._spi_dc, 0 )\n# self._spi.writebytes( commands )\n raise NotImplementedError","def send(self, data):\n \n try:\n self.s.send(data)\n LED.blink(2, 0.1, 0x00ff00)\n print(\"Sending data:\")\n print(data)\n except OSError as e:\n if e.errno == 11:\n print(\"Caught exception while sending\")\n print(\"errno: \", e.errno)\n \n LED.off()\n data = self.s.recv(64)\n print(\"Received data:\", data)\n\n return data","def send_event(ser, led, total, on, off):\n ser.flushInput()\n # Start byte\n ser.write('~')\n # Led id\n ser.write(chr(led))\n # Total time\n ser.write(chr(total))\n # On Time\n ser.write(chr(on))\n # Off Time\n ser.write(chr(off))","def send_byte(byte_out):\n GPIO.output(clock_pin, 0)\n # set the chip select to write\n GPIO.output(chip_select, 1)\n # send the byte \n values = [(ord(byte_out) >> i) % 2 for i in range(0, 8)]\n GPIO.setup(data_pins, GPIO.OUT)\n GPIO.output(data_pins, values)\n # flash the clock pin\n GPIO.output(clock_pin, 1)\n GPIO.output(clock_pin, 0)","def send_data(self, SPEED, STEER, BRAKE, GEAR):\n GEAR = 2 if SPEED >= 0.0 else 0\n\n # if self.feedbackMsg.AorM == 0:\n # return\n\n if self.doPIControl is True:\n\n current_speed = self.mps2kph(self.feedbackMsg.speed) # kph\n desired_speed = SPEED # kph\n SPEED, BRAKE = self.PIControl(\n currentSpeed=current_speed, desiredSpeed=desired_speed, brake=BRAKE)\n\n SPEED = abs(SPEED) * 10\n if SPEED > 200:\n SPEED = 200\n elif SPEED < 0:\n SPEED = 0\n\n STEER = STEER * 71\n if STEER > 1999:\n STEER = 1999\n if STEER < -1999:\n STEER = -1999\n\n try:\n\n if STEER >= 0:\n self.DATA[8] = int(STEER // 256)\n self.DATA[9] = int(STEER % 256)\n else:\n STEER = -STEER\n self.DATA[8] = int(255 - STEER // 256)\n self.DATA[9] = int(255 - STEER % 256)\n\n self.DATA[5] = GEAR # GEAR\n self.DATA[6] = int(SPEED // 256)\n self.DATA[7] = int(SPEED % 256)\n self.DATA[10] = BRAKE # BREAK\n self.DATA[11] = self.ALIVE\n\n self.ser.write((self.DATA))\n\n self.ALIVE = self.ALIVE + 1\n if self.ALIVE == 256:\n self.ALIVE = 0\n\n except Exception as ex:\n print(ex)","def send_event(self, led):\n ser.flushInput()\n # Start byte\n ser.write('~')\n # Led id\n ser.write(chr(led))\n # Total time\n ser.write(chr(self.total))\n # On Time\n ser.write(chr(self.on))\n # Off Time\n ser.write(chr(self.off))","def setled(self, led, red=0, green=0, blue=0):\n\n # Set the offset for the bytes to be sent over SPI\n offset = led * 4\n self.buffer[offset] = 255 # equals a 1 or 0\n self.buffer[offset + 1] = blue\n self.buffer[offset + 2] = green\n self.buffer[offset + 3] = red","def _send_command(self, command, data=None):\n self._spi_write(_SPI_COMMAND, [command])\n if data is not None:\n self._send_data(data)","def _write_spi(self, register, data):\n logger.debug(\"Writing to register {0}: {1}\".format(register, data))\n if isinstance(register, str):\n w_data = [self.registers[register]]\n elif isinstance(register, int):\n w_data = [register]\n else:\n raise (ValueError(\"Register must be string name or int address\"))\n # Select write register:\n self._toggle_pin(\"IO_RESET\")\n # self.spi.writebytes(w_data)\n # # Write data to register:\n w_data = [int(x) for x in np.uint8(data)]\n self.spi.writebytes(w_data)\n\n for x in data:\n w_data.append(int(np.uint8(x)))\n self.spi.writebytes(w_data)","def apa102_send_bytes( clock_pin, data_pin, bytes_ ):\n \n # implementeer deze functie:\n \n # zend iedere byte in bytes:\n assert len(bytes_) == 4\n for byte in bytes_:\n # zend ieder bit in byte:\n# print(byte)\n assert len(byte) == 8\n for bit in byte:\n GPIO.output(data_pin, bit)\n #time.sleep(.1)\n GPIO.output(clock_pin, 1)\n #time.sleep(.1)\n GPIO.output(clock_pin, 0)\n # maak de data pin hoog als het bit 1 is, laag als het 0 is\n # maak de clock pin hoog\n # maak de clock pin laag","def _spi_cmd(command, data=None):\n spi_cs.write_digital(CS_ACTIVE)\n spi_dc.write_digital(0)\n spi.write(bytearray([command]))\n if data is not None:\n spi_dc.write_digital(1)\n spi.write(bytearray(data))\n spi_cs.write_digital(CS_INACTIVE)","def send(self, data):\r\n\r\n self._serial_object.write(data)","def recv(self):\n self._serial.write('spi = SPI(2, SPI.SLAVE, baudrate=500000, polarity=0, phase=0)\\r\\n'.encode('utf-8'))\n self._serial.write('list(spi.recv(16, timeout=50000))\\r\\n'.encode('utf-8'))\n sleep(1)","def write(self, data):\n try:\n self.arduino.write(data)\n except Exception:\n raise","def _spi_write(self, dc, values):\n self._gpio.output(self.cs_pin, 0)\n self._gpio.output(self.dc_pin, dc)\n\n if type(values) is str:\n values = [ord(c) for c in values]\n\n for byte_value in values:\n self._spi_bus.xfer([byte_value])\n\n self._gpio.output(self.cs_pin, 1)","def initiate():\n\n log = \"Initiate the SPI communication of the OPC-N3\"\n logger.debug(log)\n\n time.sleep(1)\n log = \"Sending bytes to the sensor...\"\n logger.debug(log)\n spi.writebytes([0x5A, 0x01])\n reading = spi.readbytes(3)\n log = \"Data read after sending bytes are: \" + str(reading)\n logger.debug(log)\n time.sleep(wait_between_bytes)\n\n log = \"Sending bytes to the sensor...\"\n logger.debug(log)\n spi.writebytes([0x5A, 0x03])\n reading = spi.readbytes(9)\n log = \"Bytes read after sending bytes are: \" + str(reading)\n logger.debug(log)\n time.sleep(wait_between_bytes)\n\n # SPI conncetion\n log = \"Sending bytes to the sensor...\"\n logger.debug(log)\n spi.writebytes([0x5A, 0x02, 0x92, 0x07])\n reading = spi.readbytes(2)\n log = \"Bytes read after sending bytes are: \" + str(reading)\n logger.debug(log)\n time.sleep(wait_between_bytes)\n\n return","def sendCommand(self, data):\n #make sure data has an even number of elements\n if(len(data) % 2 == 1):\n data.append(0)\n\n #Initiate message as an empty list\n message = []\n\n #Fill message by combining two bytes in one register\n for i in range(0, len(data)/2):\n message.append((data[2*i] << 8) + data[2*i+1])\n\n #To do!: Implement try/except\n with self.lock:\n self.client.write_registers(0, message)","def transmit(self, data):\n # ascii_stream = bytes(data, 'ascii')\n # self.log.info('Encoding bytestream: %s to ascii: %s', data, ascii_stream)\n try:\n self.ser.write(data)\n # Purge scheduler and reboot transmitter\n except serial.SerialTimeoutException as exc:\n self.log.exception(\"Frame write to transmitter timed out: %s\", exc)\n self.log.info(\"Successfully wrote %s to tesseract transmitter\", data)\n # # disconnect handle\n # if bin_frame is None:\n # # delete `SessionQueue` instance from `ReceiverRegister`\n # self.rec_reg.write(ap_index)\n # else:\n # hex_code = binascii.hexlify(bin_frame.tobytes())\n # hardware_encode = self.cache.cache_map(bin_frame,ap_index)\n # transmit_hex = binascii.hexlify(hardware_encode.tobytes())\n # print(str(hex_code) + \" | To Access Point \" + str(ap_index), end='\\r')\n # if os.environ['TCS_ENV'] == 'dev':\n # # TODO: Move these prints to cache logger\n # self.log.debug(\"Binary Frame Data: %s\", bin_frame)\n # self.log.debug(\"Hardware Mapping: %s\", hardware_encode)\n # self.log.debug(\"Decode from AP0: %s\", self.cache._cache[-1][0])\n # self.log.debug(\"Decode from AP1: %s\", self.cache._cache[-1][1])\n # self.log.debug(\"Decode from AP2: %s\", self.cache._cache[-1][2])\n # self.log.debug(\"Decode from AP3: %s\", self.cache._cache[-1][3])","def write_data(self, data):\n # send data\n for ptr, value in data:\n self._write_byte(ptr, value)\n # set 'data changed'\n self._write_byte(fixed_format['data_changed'][0], 0xAA)\n # wait for station to clear 'data changed'\n while True:\n ack = _decode(self._read_fixed_block(0x0020),\n fixed_format['data_changed'])\n if ack == 0:\n break\n log.debug('waiting for ack')\n time.sleep(6)","def expanderWrite( self, _data ): # uint8_t\n\t\t#Wire.beginTransmission(_Addr);\n\t\t#printIIC((int)(_data) | _backlightval) # print II\n\t\tself.i2c.writeto( self.address, bytes( [_data | self._backlightval] ))\n\t\t#Wire.endTransmission();","def send_data(servo: str, degrees: float, subtract: bool, fire: bool):\n data = json.dumps({\n 'servo': servo,\n 'degrees': degrees,\n 'subtract': subtract,\n 'fire': fire\n })\n ser.write(bytes(data.strip('\\n').encode('utf-8') + '\\0'.encode('utf-8')))","def _send_command(self, data):\n # make sure data has an even number of elements\n if(len(data) % 2 == 1):\n data.append(0)\n\n # Initiate message as an empty list\n message = []\n\n # Fill message by combining two bytes in one register\n for i in range(int(len(data)/2)):\n message.append((data[2*i] << 8) + data[2*i+1])\n\n # To do!: Implement try/except\n self.client.write_registers(0x03E8, message, unit=0x0009)","def Send(self, data):\n # TODO(josephsih): should have a method to check the connection status.\n # Currently, once RN-42 is connected to a remote host, all characters\n # except chr(0) transmitted through the serial port are interpreted\n # as characters to send to the remote host.\n logging.debug('HID device sending %r...', data)\n self.SerialSendReceive(data, msg='BluetoothHID.Send')\n time.sleep(self.send_delay)","def sndData(self, dat):\r\n\t\t# comando da inviare\r\n\t\tstrCmd=\"\"\r\n\t\tfor byt in dat:\r\n\t\t\tstrCmd+=(\"%c\" %byt)\r\n\t\t# Non uso sndByte per evitare il ritardo self.dlTx\r\n\t\tself.ser.write(strCmd)\r\n\t\tif self.deb:\r\n\t\t\tfor ele in dat:\r\n\t\t\t\tprint \"\\\\x%02X\" %ele,\r\n\t\t\tprint\r\n\t\tsleep(0.001)","def send(self, output):\n assert output == 0 or output == 1\n GPIO.output(self.d_out, output)","def send_data(data_string):\n if connection_type == USE_I2C:\n cmd = \"\"\n cmd += chr( SSD1306_ADDRESS )\n cmd += chr( SELECT_DATA_BYTE )\n cmd += data_string\n i2cWrite(cmd, 10, False)\n else:\n print \"Not implemented for that connection type yet.\"","def __send__(self,val):\n assert(len(val) == 1)\n assert(type(val) == bytes)\n v = int.from_bytes(val,byteorder=\"little\")\n if(self.verbose):\n pc.color_stdout(\"GREEN\")\n print(\">> %s\\t - %s\\t - %d\"% (hex(v),bin(v),v))\n pc.color_stdout(\"RESET\")\n self.port.write(val)","def command(self, *cmd):\n self._gpio.set_low(self._dc)\n for t in cmd:\n self._spi.write([t])\n #assert(len(cmd) <= 32)\n #self.bus.write_i2c_block_data(self.addr, self.cmd_mode, list(cmd))","def data(self, c):\n if self._spi is not None:\n # SPI write.\n self._gpio.set_high(self._dc)\n self._spi.write([c])\n else:\n # I2C write.\n control = 0x40 # Co = 0, DC = 0\n self._i2c.write8(control, c)","def _send(self, value, mode):\n\n # Choose instruction or data mode\n self.output(self._rs_pin, mode)\n\n # If the RW pin is used, set it to low in order to write.\n if self._rw_pin is not None:\n self.output(self._rw_pin, 0)\n\n # Write data out in chunks of 4 or 8 bit\n if self._bus_mode == self.LCD_8BITMODE:\n self._write8bits(value)\n else:\n self._write4bits(value >> 4)\n self._write4bits(value)","def send_btn_clicked(self):\n command = self.SendLine.text()\n self.Serial.send(command)","def request_realtime_info(self):\n self.socket_datastream.sendto(b\"!r\", self.ip_port_arduino_datastream)\n self.socket_datastream.sendto(b\"!s\", self.ip_port_arduino_datastream)","def send(self,cmd):\n bit_list = '{:b}'.format(int(cmd,16))\n self._lead()\n for i in bit_list:\n self.ir_pin.duty(512)\n time.sleep_us(_Const.NEC_BIT_MARK)\n self.ir_pin.duty(0)\n if i == '0':\n time.sleep_us(_Const.NEC_ZERO_SPACE)\n else:\n time.sleep_us(_Const.NEC_ONE_SPACE)\n self._end()","def sendInstruction(self, instruction):\n # instruction = '!'\n print(f'Sending: {instruction}')\n self.ser.write(instruction.encode(\"ascii\"))\n self.ser.write('\\n'.encode(\"ascii\"))\n\n self.ser.reset_input_buffer()\n\n ser_bytes = self.ser.read(1)\n print(f'Receiving\\nraw data: {ser_bytes}')\n\n # decoded_bytes = (ser_bytes.decode(\"ascii\"))\n # print(f'Ascii Value: {decoded_bytes}', flush=True)","def send_command_with_parameter(self):\n button = self.sender()\n param = self.spins[button].value() if button != self.BtnSetFine else\\\n get_dac_value(self.SpinFine.value(), self.calibr_table, self.state.range)\n\n answer: str = self.UsbHost.send_command(self.state.ser, self.command_dict[button],\n str(self.state.device_id), param)\n if answer != 'Ok':\n error_message(self.error_dict[button])\n self.statusbar.showMessage(answer_translate[answer])\n else:\n self.statusbar.showMessage(self.result_dict[button])\n try:\n # добавляем размерность\n if self.val_labels[button]:\n self.val_labels[button].setText(str(self.spins[button].value()) + self.val_dimensions[button])\n # устанавливаем зависимость цап и сдвига\n self.set_fine_and_dac(button)\n # пересчитываем значение сдвига\n self.LblMoveVal.setText(str(self.SpinFine.value() + self.SpinRough.value())\n + self.val_dimensions[self.BtnSetRough])\n # пересчитываем результирующую частоту\n if self.state.range:\n self.LblResVal.setText(\"%.4f MГц\" % (states_dict[self.state.range][0] +\n float(self.LblMoveVal.text().split()[0])/1000000))\n except KeyError:\n pass\n self.create_log_message(self.command_dict[button], answer, str(param))","def send_data(self, data):\n self._transport.write(data)","def send_reg_command(self):\n button = self.sender()\n if button in self.btns.keys():\n state: str = button.text()\n move = None\n else:\n state = self.state.range\n move = (self.SpinRough.value() // 500) * 500\n param = registers.get_reg_str(state, move)\n answer: str = self.UsbHost.send_command(self.state.ser, \"SetAdf14\", str(self.state.device_id),\n param)\n if answer == 'Ok':\n self.statusbar.showMessage(self.result_dict[button])\n # при установлении диапазона, он записывается в интерфейсе везде\n if button in self.btn.keys():\n self.state.range = button.text()\n self.LblFreqVal.setText(button.text())\n self.LblResVal.setText(str(states_dict[button.text()][0] +\n self.SpinFine.value() + self.SpinRough.value()))\n # все кнопки серые, кроме кнопки режима\n for btn in self.btns.keys():\n btn.setStyleSheet(\"\")\n self.btns[btn].setStyleSheet(\"font: 16px\")\n button.setStyleSheet(\"background-color : rgb(70, 210, 00)\")\n self.btns[button].setStyleSheet(\"color: red; font: bold 16px\")\n else:\n error_message(self.error_dict[button])\n self.statusbar.showMessage(answer_translate[answer])\n\n # add commands to log\n param = registers.get_reg_str(state, move).replace(\" \", '\\n')\n param.replace(\" \", \"\\n\")\n self.create_log_message(button.text(), answer, param)\n\n # set sw command\n if answer == 'Ok' and button in self.btn.keys():\n params = '0 1' if button == self.BtnL1 else \"1 0\"\n self.set_sw(params)","def write_firmware(self, data):\n self.check_validity()\n\n data = list(map(int, data))\n\n return self.ipcon.send_request(self, BrickletIndustrialDualAnalogInV2.FUNCTION_WRITE_FIRMWARE, (data,), '64B', 9, 'B')","def _write(self, data):\n\n ret = False\n extended_address = SettingsBase.get_setting(self, \"extended_address\")\n addr = (extended_address, 0xe8, 0xc105, 0x11)#prey this works, I can't test it...\n try:\n self.__xbee_manager.xbee_device_xmit(0xe8, data, addr)\n ret = True\n print \"success!\" #\n except:\n print \"(..., 0xc105, 0x11) faild, trying (..., 0, 0)\" #\n try: #\n addr = (extended_address, 0xe8, 0, 0) #\n self.__xbee_manager.xbee_device_xmit(0xe8, data, addr) #\n ret = True #\n print \"success!\" #\n except: #\n print \"(..., 0, 0) faild\" #\n pass\n return ret","def _write_v1(self, data):\n return self.usb_dev.write(self.ep_out, data, self.interface, self.usb_wr_timeout)","def wr32(add,dat):\r\n global this_fpga_ip\r\n global this_sock\r\n global this_udp_port\r\n \r\n pkt = array.array('L')\r\n pkt.append(1001) #psn\r\n pkt.append(2) #opcode\r\n pkt.append(1) #noo\r\n pkt.append(add) #sa\r\n pkt.append(dat) #dat\r\n \r\n this_sock.sendto(bytes(pkt.tostring()),(this_fpga_ip,this_udp_port))\r\n data, addr = this_sock.recvfrom(10240)\r\n return","def send(self, value, char_mode=False):\n \n # Sends 8b ``value`` in ``char_mode``.\n # :param value: bytes\n # :param char_mode: character/data mode selector. False (default) for\n # data only, True for character bits.\n # one ms delay to prevent writing too quickly.\n time.sleep(0.001)\n # set character/data bit. (charmode = False)\n self.reset.value = char_mode\n # WRITE upper 4 bits\n self.dl4.value = ((value >> 4) & 1) > 0\n self.dl5.value = ((value >> 5) & 1) > 0\n self.dl6.value = ((value >> 6) & 1) > 0\n self.dl7.value = ((value >> 7) & 1) > 0\n # send command\n self._pulse_enable()\n # WRITE lower 4 bits\n self.dl4.value = (value & 1) > 0\n self.dl5.value = ((value >> 1) & 1) > 0\n self.dl6.value = ((value >> 2) & 1) > 0\n self.dl7.value = ((value >> 3) & 1) > 0\n self._pulse_enable()","def sendData(self, data):\n self.tx.sendBuffer(data)","def WriteFLASH_old(self, data):\n # print('program flash start')\n start_addr = 9 << 18\n cmd = self.board_def.CMD_WRITE_MEM\n pad = 0xFFFFFF\n #I need to pack bank into 4 bytes and then only use the 3\n packedPad = struct.pack(\"L\", pad)\n unpackedPad = struct.unpack('4b', packedPad)\n length = len(data)\n packet = struct.pack(\"4bLL\", cmd, unpackedPad[0], unpackedPad[1], unpackedPad[2], start_addr, length)\n #Next I need to send the command\n self.send_data(packet)\n #next read from the socket\n recv_stat, recv_data = self.receive_data()\n if recv_stat != 0x0:\n print ('Ram Write cmd Error stat={}!!!'.format(recv_stat))\n return self.board_def.STAT_ERROR\n\n self.send_data(data)\n #next read from the socket to ensure no errors occur\n self.sockfd.settimeout(1000);\n stat, data = self.receive_data()\n self.sockfd.settimeout(5)\n # print(packet)\n\n # print('program flash end')\n if stat != 0x0:\n print ('Ram Write Error stat={}!!!'.format(stat))\n return self.board_def.STAT_ERROR","def command(self, c):\n if self._spi is not None:\n # SPI write.\n self._gpio.set_low(self._dc)\n self._spi.write([c])\n else:\n # I2C write.\n control = 0x00 # Co = 0, DC = 0\n self._i2c.write8(control, c)","def send_command(self, command):\n self.enable_serial_port(self.port)\n time.sleep(.2)\n self.serial_com.write(command.encode() + b'\\r\\n')\n time.sleep(.2)","def callback_serial_write(data):\n serial_write(data.data)","def _write(self, register, data):\n\n # data: list of bytes to write to register\n assert register in _registers, '%r is not a valid register. Register must be passed as string.' %register\n assert len(data) == _register_len[register], 'Must pass %r byte(s) to %r register.' %(_register_len[register], register)\n\n # send the register we want to write to\n self.spi.writebytes([_registers[register]])\n\n # send the bytes we write to the register\n self.spi.writebytes(data)","def sn(self):\n\t\tstring = []\n\t\tresp = [0x00]\n\t\tself.spi.transfer([0x10], [0x00], 1)\n\t\ttime.sleep(9e-3)\n\t\tfor i in range(60):\n\t\t\tself.spi.transfer([0x00], resp, 1)\n\t\t\tstring.append(chr(resp[0]))\n\t\ttime.sleep(0.1)\n\t\treturn ''.join(string).strip()","def write(self, data):\n try:\n self.ser.write(data)\n except SerialException as se:\n log.debug('Serial connection write error: {}'.format(se))","def s_write(self, data):\n self.s.flushOutput()\n\n if self.s.is_open:\n try:\n self.s.write(data)\n if self.log_output:\n self.logfile.write('\\nIN :' + str(len(data)) + '[' + hexlify(data) + ']' + '\\n')\n except Exception as e:\n print(\"Could not write to port \" + str(e))\n else:\n raise IOError('Comport is not open, use ctl_connect()')","def leds(self, state):\n if state:\n state = b'\\x01'\n else:\n state = b'\\x00'\n msg = b'\\x0D' + state\n self.__bt.write(msg)","def send(self, data):","def write_cmd(self, cmd):\n self._dc_pin.value = False\n with self.spi_device as spi:\n spi.write(bytearray([cmd])) # pylint: disable=no-member","def _send_data(self, data, time):\n pass","def send_to_engine(self, wi):\n pass","def __init__(self, leds):\n self.ledcount = leds\n # create a buffer\n self.buffersize = self.ledcount * 4\n self.buffer = bytearray(self.ledcount * 4)\n self.emptybuffer = bytearray(self.ledcount * 4)\n for i in range(0, self.buffersize, 4):\n self.emptybuffer[i] = 0xff\n self.emptybuffer[i + 1] = 0x0\n self.emptybuffer[i + 2] = 0x0\n self.emptybuffer[i + 3] = 0x0\n # Start frame and endframe for the SPI communication (end frame is not\n # needed)\n self.startframe = bytes([0x00, 0x00, 0x00, 0x00])\n self.endframe = bytes([0xff, 0xff, 0xff, 0xff])\n # initialize SPI (needs to be at 45 MHz in order to maximize the speed.\n # This is the limiting factor for the system's speed)\n self.spi = SPI(1, SPI.MASTER, baudrate=45000000,\n polarity=0, phase=0, bits=8, firstbit=SPI.MSB)\n self.clearleds()","def use_spi():\n _LIB.oled_click_use_spi()","def write(self):\n mask = 0\n for pin in self.pins:\n if pin.mode == OUTPUT:\n if pin.value == 1:\n pin_nr = pin.pin_number - self.port_number * 8\n mask |= 1 << pin_nr\n msg = chr(DIGITAL_MESSAGE + self.port_number)\n msg += chr(mask % 128)\n msg += chr(mask >> 7)\n self.board.sp.write(msg)","def write(self, data: bytes) -> None:\n self.device.write(binascii.unhexlify(data))","def sendValue(self, value):\n\n print(f'Sending: {value}\\n')\n self.ser.write(bytes([value]))\n self.ser.write('\\n'.encode(\"ascii\"))\n\n self.ser.reset_input_buffer()\n ser_bytes = self.ser.read(1)\n print(f'Receiving\\nraw data: {ser_bytes}')\n\n\n #decoded_bytes = (ser_bytes.decode(\"ascii\"))\n\n #print(f'Ascii Value: {decoded_bytes}', flush=True)","def send_packet(self, buffer_id, raw_data, out_port, in_port):\n # We tell the switch to take the packet with id buffer_if from in_port \n # and send it to out_port\n # If the switch did not specify a buffer_id, it must have specified\n # the raw data of the packet, so in this case we tell it to send\n # the raw data\n msg = of.ofp_packet_out()\n msg.in_port = in_port\n if buffer_id != -1 and buffer_id is not None:\n # We got a buffer ID from the switch; use that\n msg.buffer_id = buffer_id\n else:\n # No buffer ID from switch -- we got the raw data\n if raw_data is None:\n # No raw_data specified -- nothing to send!\n return\n msg.data = raw_data\n \n # Add an action to send to the specified port\n if out_port == of.OFPP_FLOOD:\n # send to all active ports according to STP\n for outPort in self.ports_use:\n if outPort != in_port:\n action = of.ofp_action_output(port=outPort)\n msg.actions.append(action)\n else:\n action = of.ofp_action_output(port=out_port)\n msg.actions.append(action)\n # Send message to switch\n self.connection.send(msg)","def _send_data_to_wbt(self,nnData):\n\t\tnnData += \"END\\n\"\n\t\tself._conn.send(nnData)","def send_data(self, data):\r\n try:\r\n self.sock.sendto(data, self.addr)\r\n except Exception:\r\n print(\"Cant't send a package\")","def send_data(self, str_data):\n try:\n self.s.sendall(str_data.encode())\n except OSError as e:\n print(e)","def serial_write(data):\n global ser\n if ser.writable():\n ser.write(data)\n else:\n print 'The serial', ser.portstr, 'cannot be written.'","def sendtoserial(self, module, msg):\n self.send(\"sendserial/{}/{}:{}\\n\".format(self.msg_id, module, msg))\n self.msg_id += 1","def write(byte, inc=False):\n # Make the D-ports output\n for port in D_ports:\n GPIO.setup(port, GPIO.OUT)\n\n # write the byte as zero-padded binary\n byte_string = '{0:08b}'.format(byte)\n # put the reversed bits on the D-pins\n for i,b in enumerate(byte_string[::-1]):\n set(D_ports[i], int(b))\n # READ to HI (inactive)\n on(READ)\n # pulse WR to LO (active) for 5ms\n pulse_lo(WRITE, length=0.005)\n # OE to LO (active)\n off(READ)\n\n # Put the ports back to read and they should read the byte written\n for port in D_ports:\n GPIO.setup(port, GPIO.IN)\n\n if inc:\n incr()","def send_serial_command(data):\n print(data)\n serial_command = data\n SERIAL_PARENT.send(serial_command)\n OUTGOING.append(serial_command)","def led1(self, val):\n data = val & self.LED1_MASK\n self._ftdi.spi_write(self.LED1_ADDR, [data], burst='fixed')","def _sendSRAM(self, data):\n p = self.makePacket()\n self.makeSRAM(data, p)\n p.send()","def transmit(self) -> None:\n # Like RadioHead library, turn on high power boost if enabled.\n self.set_boost(_TEST_PA1_BOOST)\n # Enable packet sent interrupt for D0 line.\n self.dio_0_mapping = 0b00\n # Enter TX mode (will clear FIFO!).\n self.operation_mode = TX_MODE","def wr(self, port, val):\n hw = self.device.peripherals[port]\n hw.ODR.wr(val)","def main():\n if not bcm2835_init():\n return\n\n bcm2835_spi_begin()\n bcm2835_spi_setBitOrder(BCM2835_SPI_BIT_ORDER_MSBFIRST) # The default\n bcm2835_spi_setDataMode(BCM2835_SPI_MODE0) # The default\n bcm2835_spi_setClockDivider(BCM2835_SPI_CLOCK_DIVIDER_65536) # The default\n bcm2835_spi_chipSelect(BCM2835_SPI_CS0) # The default\n bcm2835_spi_setChipSelectPolarity(BCM2835_SPI_CS0, LOW) # the default\n\n # Send a byte to the slave and simultaneously read a byte back from the slave\n # If you tie MISO to MOSI, you should read back what was sent\n data = bcm2835_spi_transfer(0x23);\n print(\"Read from SPI: %02X\" % data)\n\n bcm2835_spi_end()\n bcm2835_close()","def _send_command(self, command):\n self._serial_port.write(command + '\\n')\n self._serial_port.flush()","def send(self, seq_number, *voltage_list):\r\n\r\n timestamp = time.perf_counter()\r\n volt_list = list()\r\n for volt in voltage_list:\r\n volt_list.append(volt)\r\n try:\r\n self.sock.sendto(struct.pack(packet.H2R_PACKET_FORMAT, seq_number, packet.time2int(timestamp), *volt_list),\r\n (self.robot_ip, self.robot_port))\r\n\r\n self.tx_cntr.inc()\r\n\r\n self.tastx_ks[seq_number + 1] = timestamp\r\n\r\n try:\r\n tsr_k = self.tsr_ks[seq_number]\r\n tsstx_k = self.tsstx_ks[seq_number]\r\n tssrx_k = self.tssrx_ks[seq_number]\r\n tastx_k = self.tastx_ks[seq_number]\r\n tasrx_k = self.tasrx_ks[seq_number]\r\n taw_k = self.taw_ks[seq_number]\r\n\r\n if packet.time2int(tasrx_k) is not 0:\r\n self.tsr_k_logger.timestamp(timestamp=tsr_k, value=tsr_k)\r\n self.tsstx_k_logger.timestamp(timestamp=tsstx_k, value=tsstx_k)\r\n\r\n self.tssrx_k_logger.timestamp(timestamp=tssrx_k, value=tssrx_k)\r\n self.tastx_k_logger.timestamp(timestamp=tastx_k, value=tastx_k)\r\n\r\n self.tasrx_k_logger.timestamp(timestamp=tasrx_k, value=tasrx_k)\r\n self.taw_k_logger.timestamp(timestamp=taw_k, value=taw_k)\r\n\r\n del self.tsr_ks[seq_number - 1]\r\n del self.tsstx_ks[seq_number - 1]\r\n\r\n del self.tasrx_ks[seq_number - 1]\r\n del self.taw_ks[seq_number - 1]\r\n\r\n except KeyError:\r\n logging.debug(\"Packet not found\")\r\n\r\n except socket.error:\r\n logging.error('Tx error')\r\n return","def on(self):\n\t\trb0 = [0x00]\n\t\trb1 = [0x00, 0x00]\n\t\tattempts = 0\n\n\t\twhile self.state != ON and attempts < MAX_RETRIES:\n\t\t\tself.spi.transfer([0x03], rb0, 1)\t\t## Send the command byte; response will be written to rb0\n\t\t\ttime.sleep(9e-3) \t\t\t\t\t\t## Sleep for 9 ms\n\t\t\tself.spi.transfer([0x00, 0x01], rb1, 2)\t## Send the following 2 bytes; response will be written to rb1\n\t\t\ttime.sleep(0.1)\n\n\t\t\tif rb0[0] < 0: \t\t\t\t\t\t## Account for implicit unsigned-to-signed \n\t\t\t\trb0[0] += 256\t\t\t\t\t## conversion from the transfer operation\n\n\t\t\tattempts += 1\n\t\t\tprint(f\"[{self.__class__.__name__}::on]\", end=' ')\n\t\t\tif rb0[0] == 0xF3 and rb1[0] == 0x03: \t## Ensure response values are as expected\n\t\t\t\tself.state = ON \n\t\t\t\tprint(\"SUCCESS -- device powered on.\")\n\t\t\telse:\n\t\t\t\tif attempts != MAX_RETRIES:\n\t\t\t\t\tprint(f\"Attempt #{attempts} failed -- retrying after delay ...\")\n\t\t\t\t\ttime.sleep(RETRY_DELAY)\n\t\t\t\telse:\n\t\t\t\t\tprint(\"ERROR -- command failed.\")\n\n\t\treturn self.state == ON","def spi_controller(\n # ---[ Module Ports]---\n glbl, # global interface, clock, reset, etc.\n spibus, # external SPI bus\n # optional ports\n fifobus=None, # streaming interface, FIFO bus\n mmbus=None, # memory-mapped bus, contro status access\n cso=None, # control-status object\n \n # ---[ Module Parameters ]---\n include_fifo=True, # include aan 8 byte deep FIFO\n):\n clock, reset = glbl.clock, glbl.reset\n if cso is None:\n cso = spi_controller.cso()\n\n # -- local signals --\n ena = Signal(False)\n clkcnt = Signal(modbv(0, min=0, max=2**12))\n bcnt = Signal(intbv(0, min=0, max=8))\n\n # separate tx and rx shift-registers (could be one in the same)\n treg = Signal(intbv(0)[8:]) # tx shift register\n rreg = Signal(intbv(0)[8:]) # rx shift register\n\n x_sck, x_ss, x_mosi, x_miso = Signals(bool(0), 4)\n\n # internal FIFO bus interfaces\n # external FIFO side (FIFO to external SPI bus)\n itx = FIFOBus(size=fifobus.size, width=fifobus.width)\n # internal FIFO side (FIFO to internal bus)\n irx = FIFOBus(size=fifobus.size, width=fifobus.width)\n \n states = enum('idle', 'wait_hclk', 'data_in', 'data_change',\n 'write_fifo', 'end')\n state = Signal(states.idle)\n\n # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n # memory- mapped registers\n # add the peripheral's regfile to the bus (informational only)\n # @todo: the automatic building of the register files is incomplete\n if mmbus is not None:\n # the register-file (rf) will drive all the cso signals\n rf = cso.get_register_file()\n mmbus.add(rf, 'spi')\n\n # FIFO for the wishbone data transfer\n if include_fifo:\n fifo_fast.debug = spi_controller.debug\n fifo_tx_inst = fifo_fast(reset, clock, itx)\n fifo_rx_inst = fifo_fast(reset, clock, irx)\n\n @always_comb\n def rtl_assign():\n cso.tx_fifo_count.next = itx.count\n cso.rx_fifo_count.next = irx.count\n\n if clkcnt > 0:\n ena.next = False\n else:\n ena.next = True\n\n clock_counts = tuple([(2**ii)-1 for ii in range(13)])\n\n @always(clock.posedge)\n def rtl_clk_div():\n if cso.enable and clkcnt != 0 and state != states.idle:\n clkcnt.next = (clkcnt - 1)\n else:\n clkcnt.next = clock_counts[cso.clock_divisor]\n\n @always_seq(clock.posedge, reset=reset)\n def rtl_state_and_more():\n \"\"\"\n Designed to the following timing diagram\n\n SCK CPOL=0 ______/---\\___/---\\___/---\\___/---\\___/---\\___/---\\___/---\\___/---\\___/---\\ \n CPOL=1 ------\\___/---\\___/---\\___/---\\___/---\\___/---\\___/---\\___/---\\___/---\\___/ \n SS ---\\_______________________________________________________________________ \n CPHA=0 MOSI ...|.0....|.1.....|.2.....|.3.....|.4.....|.5.....|.6.....|.7.....|.0.....| \n MISO ...|.0....|.1.....|.2.....|.3.....|.4.....|.5.....|.6.....|.7.....|.0.....| \n CPHA=1 MOSI ...|....0.....|.1.....|.2.....|.3.....|.4.....|.5.....|.6.....|.7.....|.0...\n MISO ......|.0.....|.1.....|.2.....|.3.....|.4.....|.5.....|.6.....|.7.....|.0...\n \"\"\"\n if not cso.enable:\n state.next = states.idle\n bcnt.next = 0\n treg.next = 0\n \n itx.read.next = False\n irx.write.next = False\n\n x_sck.next = False\n x_ss.next = False\n else:\n if not cso.freeze:\n # ~~~~ Idle state ~~~~\n if state == states.idle:\n bcnt.next = 7\n treg.next = itx.read_data\n x_sck.next = cso.clock_polarity\n irx.write.next = False\n \n if not itx.empty and not irx.full:\n itx.read.next = True\n x_ss.next = False\n if cso.clock_phase: # Clock in on second phase\n state.next = states.wait_hclk\n else: # Clock in on first phase\n state.next = states.data_in\n else:\n itx.read.next = False\n x_ss.next = True\n\n # ~~~~ Wait half clock period for cpha=1 ~~~~\n elif state == states.wait_hclk:\n itx.read.next = False\n irx.write.next = False\n if ena:\n x_sck.next = not x_sck\n state.next = states.data_in\n\n # ~~~~ Clock data in (and out) ~~~~\n elif state == states.data_in:\n itx.read.next = False\n irx.write.next = False\n if ena: # clk div\n x_sck.next = not x_sck\n rreg.next = concat(rreg[7:0], x_miso)\n \n if cso.clock_phase and bcnt == 0:\n irx.write.next = True\n if itx.empty or irx.full:\n state.next = states.end\n else:\n state.next = states.data_change\n else:\n state.next = states.data_change\n\n # ~~~~ Get ready for next byte out/in ~~~~\n elif state == states.data_change:\n itx.read.next = False\n irx.write.next = False\n if ena:\n x_sck.next = not x_sck\n if bcnt == 0: \n if not cso.clock_phase:\n irx.write.next = True\n \n if itx.empty or irx.full:\n state.next = states.end\n else: # more data to transfer\n bcnt.next = 7\n state.next = states.data_in\n itx.read.next = True\n treg.next = itx.read_data\n else:\n treg.next = concat(treg[7:0], intbv(0)[1:])\n bcnt.next = bcnt - 1 \n state.next = states.data_in\n\n # ~~~~ End state ~~~~\n elif state == states.end:\n itx.read.next = False\n irx.write.next = False\n if ena: # Wait half clock cycle go idle\n state.next = states.idle\n\n # Shouldn't happen, error in logic\n else:\n state.next = states.idle\n assert False, \"SPI Invalid State\"\n\n @always_comb\n def rtl_fifo_sel():\n \"\"\"\n The `itx` and `irx` FIFO interfaces are driven by different\n logic depending on the configuration. This modules accesses\n the `itx` read side and drives the `irx` write side. The\n `itx` write side is driven by the `cso` or the `fifobus` port.\n The `irx` read side is accessed by the `cso` or the `fifobus`\n port.\n \"\"\"\n if cso.bypass_fifo:\n # data comes from the register file\n cso.tx_empty.next = itx.empty\n cso.tx_full.next = itx.full\n itx.write_data.next = cso.tx_byte\n\n cso.rx_empty.next = irx.empty\n cso.rx_full.next = irx.full\n cso.rx_byte.next = irx.read_data\n cso.rx_byte_valid.next = irx.read_valid\n\n # @todo: if cso.tx_byte write signal (written by bus) drive the\n # @todo: FIFO write signals, same if the cso.rx_byte is accessed\n itx.write.next = cso.tx_write\n irx.read.next = cso.rx_read\n\n else:\n # data comes from external FIFO bus interface\n fifobus.full.next = itx.full\n itx.write_data.next = fifobus.write_data\n itx.write.next = fifobus.write\n\n fifobus.empty.next = irx.empty\n fifobus.read_data.next = irx.read_data\n fifobus.read_valid.next = irx.read_valid\n irx.read.next = fifobus.read\n\n # same for all modes\n irx.write_data.next = rreg\n\n @always_comb\n def rtl_x_mosi():\n # @todo lsb control signal\n x_mosi.next = treg[7]\n\n @always_comb\n def rtl_gate_mosi():\n if cso.loopback:\n spibus.mosi.next = False\n else:\n spibus.mosi.next = x_mosi\n\n @always_comb #(clock.posedge)\n def rtl_spi_sigs():\n spibus.sck.next = x_sck\n if cso.loopback:\n x_miso.next = x_mosi\n else:\n x_miso.next = spibus.miso\n\n @always_comb\n def rtl_slave_select():\n if cso.manual_slave_select:\n spibus.ss.next = ~cso.slave_select\n elif x_ss:\n spibus.ss.next = 0xFF\n else:\n spibus.ss.next = ~cso.slave_select\n\n # myhdl generators in the __debug__ conditionals are not converted.\n if spi_controller.debug:\n @instance\n def mon_state():\n print(\" :{:<8d}: initial state {}\".format(\n now(), str(state)))\n \n while True:\n yield state\n print(\" :{:<8d}: state transition --> {}\".format(\n now(), str(state)))\n \n fbidle = intbv('0000')[4:]\n\n @instance\n def mon_trace():\n while True:\n yield clock.posedge\n ccfb = concat(itx.write, itx.read, irx.write, irx.read)\n if ccfb != fbidle:\n fstr = \" :{:<8d}: tx: w{} r{}, f{} e{}, rx: w{} r{} f{} e{}\"\n print(fstr.format(now(),\n int(itx.write), int(itx.read), int(itx.full), int(itx.empty),\n int(irx.write), int(irx.read), int(irx.full), int(irx.empty),)\n )\n \n @always(clock.posedge)\n def mon_tx_fifo_write():\n if itx.write:\n print(\" WRITE tx fifo {:02X}\".format(int(itx.write_data)))\n if itx.read:\n print(\" READ tx fifo {:02X}\".format(int(itx.read_data)))\n \n @always(clock.posedge)\n def mon_rx_fifo_write():\n if irx.write:\n print(\" WRITE rx fifo {:02X}\".format(int(irx.write_data)))\n \n if irx.read:\n print(\" READ rx fifo {:02X}\".format(int(irx.read_data)))\n\n # return the myhdl generators\n gens = myhdl.instances()\n return gens","def send( self, value, mode=LCD_RS ): # RegisterSelect bit by default\n\t\thighnib = value & 0xF0\n\t\tlownib=(value<<4) & 0xF0\n\t\tself.write4bits( highnib | mode )\n\t\tself.write4bits( lownib | mode )","def sendAuto(self):\n if (self.ser is not None):\n if len(self.cmd)>0:\n try:\n # TODO gestion python 2.0 (str) ou 3.0 (encode)\n cmd = self.cmd[0] + \"\\n\"\n self.ser.write(cmd.encode())\n self.t_TX = time.time()\n if self.mutexCmd.tryLock(100):\n del self.cmd[0]\n self.mutexCmd.unlock()\n else:\n print(\"WARN: cmd not send\")\n print(self.t_TX, cmd[:-1])\n except Exception as e:\n print(\"ERROR:Serial:sendAuto\",e)","def write(self, register, value): #good\r\n\t\tself.i2c.write8(register, value)","def send(self, data):\n starttime = time.time()\n while 1:\n if self._waiting_response==1:\n if time.time() - starttime > self._maxrespdelay:\n break\n _LOGGER.debug(\"Send going to sleep\\n\")\n time.sleep(self._sleeptime)\n else:\n break\n\n currtime = time.time()\n if currtime - self._lastcall > self._maxtime:\n self.reset()\n self._lastcall = currtime\n _LOGGER.debug(\"Sending: %s\", data)\n if not testing:\n self.serial.reset_input_buffer()\n bytessent = self.serial.write(data.encode())\n return bytessent\n else:\n self._waiting_response = 1\n return len(data)","def write_firmware(self, data):\n data = list(map(int, data))\n\n return self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_WRITE_FIRMWARE, (data,), '64B', 'B')","def flash_write16(self, addr, data):\n return self.flash_write(addr, data, 16)","def _command(self, servo_id, instruction, *params):\n length = 3 + len(params)\n #print('length', length)\n \"\"\"\n checksum calculation:\n checksum = ~(ID + length+instruction+parms) if the numbers in the brackets\n are calculated and exceeded 255, then it takes the lowest one byte, \"~\"\n means Negation\n \"\"\"\n checksum = 255 - ((servo_id + length + instruction + sum(params))% 256)\n #print('checksum', checksum)\n packet = [0x55, 0x55, servo_id, length, instruction, *params, checksum]\n #print('packet', packet)\n self._serial.write(bytearray(packet))\n #print('Sending packet', packet)","def set_switch(self, node_uuid, index, data):\n if data == \"on\":\n self._bus.i2c_acquire()\n try:\n p = self.values['num'].get_data_index(index=index)\n self._bus.pca9685_manager.set_pwm(p, 4096, 0)\n self.values['level'].set_data_index(index=index, data=100)\n except Exception:\n logger.exception('[%s] - Exception when switching on', self.__class__.__name__)\n finally:\n self._bus.i2c_release()\n elif data == \"off\":\n self._bus.i2c_acquire()\n try:\n p = self.values['num'].get_data_index(index=index)\n self._bus.pca9685_manager.set_pwm(p, 0, 4096)\n self.values['level'].set_data_index(index=index, data=0)\n except Exception:\n logger.exception('[%s] - Exception when switching off', self.__class__.__name__)\n finally:\n self._bus.i2c_release()\n else:\n logger.warning(\"[%s] - set_switch unknown data : %s\", self.__class__.__name__, data)"],"string":"[\n \"def send(self, data):\\n self._serial.write('spi = SPI(2, SPI.SLAVE, baudrate=500000, polarity=0, phase=0)\\\\r\\\\n'.encode('utf-8'))\\n self._serial.write('data=bytearray({})\\\\r\\\\n'.format(data).encode('utf-8'))\\n self._serial.write('spi.send(data, timeout=50000)\\\\r\\\\n'.encode('utf-8'))\\n sleep(1)\",\n \"def _data(self, data):\\n# \\\"\\\"\\\"Send data to spi bus of display chip, most DC pin need set to HIGH \\\"\\\"\\\"\\n# if self._spi == None: raise \\\"Do not setting SPI\\\"\\n# GPIO.output( self._spi_dc, 1 )\\n# self._spi.writebytes( data )\\n raise NotImplementedError\",\n \"def send_recv(self, data):\\n self._serial.write('spi = SPI(2, SPI.SLAVE, baudrate=500000, polarity=0, phase=0)\\\\r\\\\n'.encode('utf-8'))\\n self._serial.write('data=bytearray({})\\\\r\\\\n'.format(data).encode('utf-8'))\\n self._serial.write('list(spi.send_recv(data, timeout=50000))\\\\r\\\\n'.encode('utf-8'))\\n sleep(1)\",\n \"def update(self):\\n\\t\\tfor x in range(self.leds):\\n\\t\\t\\tself.spi.write(self.buffer[x])\\n\\t\\t\\t#self.spi.flush()\\n\\t\\t\\t\\n\\t\\tself.spi.write(bytearray(b'\\\\x00'))\\n\\t\\tself.spi.flush()\",\n \"def _send_data(self, data):\\n if isinstance(data, int):\\n data = [data]\\n self._spi_write(_SPI_DATA, data)\",\n \"def send_to_port(self):\\r\\n time.sleep(2)\\r\\n # ser.write(\\\"R\\\".encode())\\r\\n ser.flush()\\r\\n ser.write(\\\"{},{},{},{},{}\\\".format(self.x_Pos, self.y_Pos, self.t_Tap, self.U_on, self.u_off).encode())\\r\\n # ser.flush()\\r\\n # while (1 == 1):\\r\\n # mydata = ser.readline().lstrip()\\r\\n # print(mydata.decode('utf-8'))\\r\\n # value = str(mydata)\\r\",\n \"def SPIwriteenable(self):\\n data=[0x06];\\n self.SPItrans(data);\",\n \"def data(self, data):\\n self._gpio.set_high(self._dc)\\n for t in data:\\n\\t\\t self._spi.write([t])\",\n \"def SPItrans(self,data):\\n self.data=data;\\n self.writecmd(0x01,0x00,len(data),data);\\n return self.data;\",\n \"def send_traffic_data(serialport, pack):\\n pack[0] = 0x01\\n pack[1] = 0x00\\n serialport.write(pack)\\n logging.debug(\\\"Traffic Data - Sent.\\\")\\n logging.debug(str(pack))\",\n \"def SPIsetup(self):\\n self.writecmd(0x01,0x10,0,self.data); #SPI/SETUP\",\n \"def write(self, buffer):\\n utils.print_for_unimplemented_functions(SPI.write.__name__)\\n telemetry_py.send_telemetry(TelemetryEvent.MICROBIT_API_SPI)\",\n \"def __transfer(self, data: int):\\n self.__spi.writebytes(data)\",\n \"def send_data(self, data: int):\\n self.write_pin(self.DC_PIN, RPi.GPIO.HIGH)\\n self.__transfer([data])\",\n \"def _command(self, commands):\\n# \\\"\\\"\\\"Send command to spi bus of display chip, most DC pin need set to LOW \\\"\\\"\\\"\\n# if self._spi == None: raise \\\"Do not setting SPI\\\"\\n# GPIO.output( self._spi_dc, 0 )\\n# self._spi.writebytes( commands )\\n raise NotImplementedError\",\n \"def send(self, data):\\n \\n try:\\n self.s.send(data)\\n LED.blink(2, 0.1, 0x00ff00)\\n print(\\\"Sending data:\\\")\\n print(data)\\n except OSError as e:\\n if e.errno == 11:\\n print(\\\"Caught exception while sending\\\")\\n print(\\\"errno: \\\", e.errno)\\n \\n LED.off()\\n data = self.s.recv(64)\\n print(\\\"Received data:\\\", data)\\n\\n return data\",\n \"def send_event(ser, led, total, on, off):\\n ser.flushInput()\\n # Start byte\\n ser.write('~')\\n # Led id\\n ser.write(chr(led))\\n # Total time\\n ser.write(chr(total))\\n # On Time\\n ser.write(chr(on))\\n # Off Time\\n ser.write(chr(off))\",\n \"def send_byte(byte_out):\\n GPIO.output(clock_pin, 0)\\n # set the chip select to write\\n GPIO.output(chip_select, 1)\\n # send the byte \\n values = [(ord(byte_out) >> i) % 2 for i in range(0, 8)]\\n GPIO.setup(data_pins, GPIO.OUT)\\n GPIO.output(data_pins, values)\\n # flash the clock pin\\n GPIO.output(clock_pin, 1)\\n GPIO.output(clock_pin, 0)\",\n \"def send_data(self, SPEED, STEER, BRAKE, GEAR):\\n GEAR = 2 if SPEED >= 0.0 else 0\\n\\n # if self.feedbackMsg.AorM == 0:\\n # return\\n\\n if self.doPIControl is True:\\n\\n current_speed = self.mps2kph(self.feedbackMsg.speed) # kph\\n desired_speed = SPEED # kph\\n SPEED, BRAKE = self.PIControl(\\n currentSpeed=current_speed, desiredSpeed=desired_speed, brake=BRAKE)\\n\\n SPEED = abs(SPEED) * 10\\n if SPEED > 200:\\n SPEED = 200\\n elif SPEED < 0:\\n SPEED = 0\\n\\n STEER = STEER * 71\\n if STEER > 1999:\\n STEER = 1999\\n if STEER < -1999:\\n STEER = -1999\\n\\n try:\\n\\n if STEER >= 0:\\n self.DATA[8] = int(STEER // 256)\\n self.DATA[9] = int(STEER % 256)\\n else:\\n STEER = -STEER\\n self.DATA[8] = int(255 - STEER // 256)\\n self.DATA[9] = int(255 - STEER % 256)\\n\\n self.DATA[5] = GEAR # GEAR\\n self.DATA[6] = int(SPEED // 256)\\n self.DATA[7] = int(SPEED % 256)\\n self.DATA[10] = BRAKE # BREAK\\n self.DATA[11] = self.ALIVE\\n\\n self.ser.write((self.DATA))\\n\\n self.ALIVE = self.ALIVE + 1\\n if self.ALIVE == 256:\\n self.ALIVE = 0\\n\\n except Exception as ex:\\n print(ex)\",\n \"def send_event(self, led):\\n ser.flushInput()\\n # Start byte\\n ser.write('~')\\n # Led id\\n ser.write(chr(led))\\n # Total time\\n ser.write(chr(self.total))\\n # On Time\\n ser.write(chr(self.on))\\n # Off Time\\n ser.write(chr(self.off))\",\n \"def setled(self, led, red=0, green=0, blue=0):\\n\\n # Set the offset for the bytes to be sent over SPI\\n offset = led * 4\\n self.buffer[offset] = 255 # equals a 1 or 0\\n self.buffer[offset + 1] = blue\\n self.buffer[offset + 2] = green\\n self.buffer[offset + 3] = red\",\n \"def _send_command(self, command, data=None):\\n self._spi_write(_SPI_COMMAND, [command])\\n if data is not None:\\n self._send_data(data)\",\n \"def _write_spi(self, register, data):\\n logger.debug(\\\"Writing to register {0}: {1}\\\".format(register, data))\\n if isinstance(register, str):\\n w_data = [self.registers[register]]\\n elif isinstance(register, int):\\n w_data = [register]\\n else:\\n raise (ValueError(\\\"Register must be string name or int address\\\"))\\n # Select write register:\\n self._toggle_pin(\\\"IO_RESET\\\")\\n # self.spi.writebytes(w_data)\\n # # Write data to register:\\n w_data = [int(x) for x in np.uint8(data)]\\n self.spi.writebytes(w_data)\\n\\n for x in data:\\n w_data.append(int(np.uint8(x)))\\n self.spi.writebytes(w_data)\",\n \"def apa102_send_bytes( clock_pin, data_pin, bytes_ ):\\n \\n # implementeer deze functie:\\n \\n # zend iedere byte in bytes:\\n assert len(bytes_) == 4\\n for byte in bytes_:\\n # zend ieder bit in byte:\\n# print(byte)\\n assert len(byte) == 8\\n for bit in byte:\\n GPIO.output(data_pin, bit)\\n #time.sleep(.1)\\n GPIO.output(clock_pin, 1)\\n #time.sleep(.1)\\n GPIO.output(clock_pin, 0)\\n # maak de data pin hoog als het bit 1 is, laag als het 0 is\\n # maak de clock pin hoog\\n # maak de clock pin laag\",\n \"def _spi_cmd(command, data=None):\\n spi_cs.write_digital(CS_ACTIVE)\\n spi_dc.write_digital(0)\\n spi.write(bytearray([command]))\\n if data is not None:\\n spi_dc.write_digital(1)\\n spi.write(bytearray(data))\\n spi_cs.write_digital(CS_INACTIVE)\",\n \"def send(self, data):\\r\\n\\r\\n self._serial_object.write(data)\",\n \"def recv(self):\\n self._serial.write('spi = SPI(2, SPI.SLAVE, baudrate=500000, polarity=0, phase=0)\\\\r\\\\n'.encode('utf-8'))\\n self._serial.write('list(spi.recv(16, timeout=50000))\\\\r\\\\n'.encode('utf-8'))\\n sleep(1)\",\n \"def write(self, data):\\n try:\\n self.arduino.write(data)\\n except Exception:\\n raise\",\n \"def _spi_write(self, dc, values):\\n self._gpio.output(self.cs_pin, 0)\\n self._gpio.output(self.dc_pin, dc)\\n\\n if type(values) is str:\\n values = [ord(c) for c in values]\\n\\n for byte_value in values:\\n self._spi_bus.xfer([byte_value])\\n\\n self._gpio.output(self.cs_pin, 1)\",\n \"def initiate():\\n\\n log = \\\"Initiate the SPI communication of the OPC-N3\\\"\\n logger.debug(log)\\n\\n time.sleep(1)\\n log = \\\"Sending bytes to the sensor...\\\"\\n logger.debug(log)\\n spi.writebytes([0x5A, 0x01])\\n reading = spi.readbytes(3)\\n log = \\\"Data read after sending bytes are: \\\" + str(reading)\\n logger.debug(log)\\n time.sleep(wait_between_bytes)\\n\\n log = \\\"Sending bytes to the sensor...\\\"\\n logger.debug(log)\\n spi.writebytes([0x5A, 0x03])\\n reading = spi.readbytes(9)\\n log = \\\"Bytes read after sending bytes are: \\\" + str(reading)\\n logger.debug(log)\\n time.sleep(wait_between_bytes)\\n\\n # SPI conncetion\\n log = \\\"Sending bytes to the sensor...\\\"\\n logger.debug(log)\\n spi.writebytes([0x5A, 0x02, 0x92, 0x07])\\n reading = spi.readbytes(2)\\n log = \\\"Bytes read after sending bytes are: \\\" + str(reading)\\n logger.debug(log)\\n time.sleep(wait_between_bytes)\\n\\n return\",\n \"def sendCommand(self, data):\\n #make sure data has an even number of elements\\n if(len(data) % 2 == 1):\\n data.append(0)\\n\\n #Initiate message as an empty list\\n message = []\\n\\n #Fill message by combining two bytes in one register\\n for i in range(0, len(data)/2):\\n message.append((data[2*i] << 8) + data[2*i+1])\\n\\n #To do!: Implement try/except\\n with self.lock:\\n self.client.write_registers(0, message)\",\n \"def transmit(self, data):\\n # ascii_stream = bytes(data, 'ascii')\\n # self.log.info('Encoding bytestream: %s to ascii: %s', data, ascii_stream)\\n try:\\n self.ser.write(data)\\n # Purge scheduler and reboot transmitter\\n except serial.SerialTimeoutException as exc:\\n self.log.exception(\\\"Frame write to transmitter timed out: %s\\\", exc)\\n self.log.info(\\\"Successfully wrote %s to tesseract transmitter\\\", data)\\n # # disconnect handle\\n # if bin_frame is None:\\n # # delete `SessionQueue` instance from `ReceiverRegister`\\n # self.rec_reg.write(ap_index)\\n # else:\\n # hex_code = binascii.hexlify(bin_frame.tobytes())\\n # hardware_encode = self.cache.cache_map(bin_frame,ap_index)\\n # transmit_hex = binascii.hexlify(hardware_encode.tobytes())\\n # print(str(hex_code) + \\\" | To Access Point \\\" + str(ap_index), end='\\\\r')\\n # if os.environ['TCS_ENV'] == 'dev':\\n # # TODO: Move these prints to cache logger\\n # self.log.debug(\\\"Binary Frame Data: %s\\\", bin_frame)\\n # self.log.debug(\\\"Hardware Mapping: %s\\\", hardware_encode)\\n # self.log.debug(\\\"Decode from AP0: %s\\\", self.cache._cache[-1][0])\\n # self.log.debug(\\\"Decode from AP1: %s\\\", self.cache._cache[-1][1])\\n # self.log.debug(\\\"Decode from AP2: %s\\\", self.cache._cache[-1][2])\\n # self.log.debug(\\\"Decode from AP3: %s\\\", self.cache._cache[-1][3])\",\n \"def write_data(self, data):\\n # send data\\n for ptr, value in data:\\n self._write_byte(ptr, value)\\n # set 'data changed'\\n self._write_byte(fixed_format['data_changed'][0], 0xAA)\\n # wait for station to clear 'data changed'\\n while True:\\n ack = _decode(self._read_fixed_block(0x0020),\\n fixed_format['data_changed'])\\n if ack == 0:\\n break\\n log.debug('waiting for ack')\\n time.sleep(6)\",\n \"def expanderWrite( self, _data ): # uint8_t\\n\\t\\t#Wire.beginTransmission(_Addr);\\n\\t\\t#printIIC((int)(_data) | _backlightval) # print II\\n\\t\\tself.i2c.writeto( self.address, bytes( [_data | self._backlightval] ))\\n\\t\\t#Wire.endTransmission();\",\n \"def send_data(servo: str, degrees: float, subtract: bool, fire: bool):\\n data = json.dumps({\\n 'servo': servo,\\n 'degrees': degrees,\\n 'subtract': subtract,\\n 'fire': fire\\n })\\n ser.write(bytes(data.strip('\\\\n').encode('utf-8') + '\\\\0'.encode('utf-8')))\",\n \"def _send_command(self, data):\\n # make sure data has an even number of elements\\n if(len(data) % 2 == 1):\\n data.append(0)\\n\\n # Initiate message as an empty list\\n message = []\\n\\n # Fill message by combining two bytes in one register\\n for i in range(int(len(data)/2)):\\n message.append((data[2*i] << 8) + data[2*i+1])\\n\\n # To do!: Implement try/except\\n self.client.write_registers(0x03E8, message, unit=0x0009)\",\n \"def Send(self, data):\\n # TODO(josephsih): should have a method to check the connection status.\\n # Currently, once RN-42 is connected to a remote host, all characters\\n # except chr(0) transmitted through the serial port are interpreted\\n # as characters to send to the remote host.\\n logging.debug('HID device sending %r...', data)\\n self.SerialSendReceive(data, msg='BluetoothHID.Send')\\n time.sleep(self.send_delay)\",\n \"def sndData(self, dat):\\r\\n\\t\\t# comando da inviare\\r\\n\\t\\tstrCmd=\\\"\\\"\\r\\n\\t\\tfor byt in dat:\\r\\n\\t\\t\\tstrCmd+=(\\\"%c\\\" %byt)\\r\\n\\t\\t# Non uso sndByte per evitare il ritardo self.dlTx\\r\\n\\t\\tself.ser.write(strCmd)\\r\\n\\t\\tif self.deb:\\r\\n\\t\\t\\tfor ele in dat:\\r\\n\\t\\t\\t\\tprint \\\"\\\\\\\\x%02X\\\" %ele,\\r\\n\\t\\t\\tprint\\r\\n\\t\\tsleep(0.001)\",\n \"def send(self, output):\\n assert output == 0 or output == 1\\n GPIO.output(self.d_out, output)\",\n \"def send_data(data_string):\\n if connection_type == USE_I2C:\\n cmd = \\\"\\\"\\n cmd += chr( SSD1306_ADDRESS )\\n cmd += chr( SELECT_DATA_BYTE )\\n cmd += data_string\\n i2cWrite(cmd, 10, False)\\n else:\\n print \\\"Not implemented for that connection type yet.\\\"\",\n \"def __send__(self,val):\\n assert(len(val) == 1)\\n assert(type(val) == bytes)\\n v = int.from_bytes(val,byteorder=\\\"little\\\")\\n if(self.verbose):\\n pc.color_stdout(\\\"GREEN\\\")\\n print(\\\">> %s\\\\t - %s\\\\t - %d\\\"% (hex(v),bin(v),v))\\n pc.color_stdout(\\\"RESET\\\")\\n self.port.write(val)\",\n \"def command(self, *cmd):\\n self._gpio.set_low(self._dc)\\n for t in cmd:\\n self._spi.write([t])\\n #assert(len(cmd) <= 32)\\n #self.bus.write_i2c_block_data(self.addr, self.cmd_mode, list(cmd))\",\n \"def data(self, c):\\n if self._spi is not None:\\n # SPI write.\\n self._gpio.set_high(self._dc)\\n self._spi.write([c])\\n else:\\n # I2C write.\\n control = 0x40 # Co = 0, DC = 0\\n self._i2c.write8(control, c)\",\n \"def _send(self, value, mode):\\n\\n # Choose instruction or data mode\\n self.output(self._rs_pin, mode)\\n\\n # If the RW pin is used, set it to low in order to write.\\n if self._rw_pin is not None:\\n self.output(self._rw_pin, 0)\\n\\n # Write data out in chunks of 4 or 8 bit\\n if self._bus_mode == self.LCD_8BITMODE:\\n self._write8bits(value)\\n else:\\n self._write4bits(value >> 4)\\n self._write4bits(value)\",\n \"def send_btn_clicked(self):\\n command = self.SendLine.text()\\n self.Serial.send(command)\",\n \"def request_realtime_info(self):\\n self.socket_datastream.sendto(b\\\"!r\\\", self.ip_port_arduino_datastream)\\n self.socket_datastream.sendto(b\\\"!s\\\", self.ip_port_arduino_datastream)\",\n \"def send(self,cmd):\\n bit_list = '{:b}'.format(int(cmd,16))\\n self._lead()\\n for i in bit_list:\\n self.ir_pin.duty(512)\\n time.sleep_us(_Const.NEC_BIT_MARK)\\n self.ir_pin.duty(0)\\n if i == '0':\\n time.sleep_us(_Const.NEC_ZERO_SPACE)\\n else:\\n time.sleep_us(_Const.NEC_ONE_SPACE)\\n self._end()\",\n \"def sendInstruction(self, instruction):\\n # instruction = '!'\\n print(f'Sending: {instruction}')\\n self.ser.write(instruction.encode(\\\"ascii\\\"))\\n self.ser.write('\\\\n'.encode(\\\"ascii\\\"))\\n\\n self.ser.reset_input_buffer()\\n\\n ser_bytes = self.ser.read(1)\\n print(f'Receiving\\\\nraw data: {ser_bytes}')\\n\\n # decoded_bytes = (ser_bytes.decode(\\\"ascii\\\"))\\n # print(f'Ascii Value: {decoded_bytes}', flush=True)\",\n \"def send_command_with_parameter(self):\\n button = self.sender()\\n param = self.spins[button].value() if button != self.BtnSetFine else\\\\\\n get_dac_value(self.SpinFine.value(), self.calibr_table, self.state.range)\\n\\n answer: str = self.UsbHost.send_command(self.state.ser, self.command_dict[button],\\n str(self.state.device_id), param)\\n if answer != 'Ok':\\n error_message(self.error_dict[button])\\n self.statusbar.showMessage(answer_translate[answer])\\n else:\\n self.statusbar.showMessage(self.result_dict[button])\\n try:\\n # добавляем размерность\\n if self.val_labels[button]:\\n self.val_labels[button].setText(str(self.spins[button].value()) + self.val_dimensions[button])\\n # устанавливаем зависимость цап и сдвига\\n self.set_fine_and_dac(button)\\n # пересчитываем значение сдвига\\n self.LblMoveVal.setText(str(self.SpinFine.value() + self.SpinRough.value())\\n + self.val_dimensions[self.BtnSetRough])\\n # пересчитываем результирующую частоту\\n if self.state.range:\\n self.LblResVal.setText(\\\"%.4f MГц\\\" % (states_dict[self.state.range][0] +\\n float(self.LblMoveVal.text().split()[0])/1000000))\\n except KeyError:\\n pass\\n self.create_log_message(self.command_dict[button], answer, str(param))\",\n \"def send_data(self, data):\\n self._transport.write(data)\",\n \"def send_reg_command(self):\\n button = self.sender()\\n if button in self.btns.keys():\\n state: str = button.text()\\n move = None\\n else:\\n state = self.state.range\\n move = (self.SpinRough.value() // 500) * 500\\n param = registers.get_reg_str(state, move)\\n answer: str = self.UsbHost.send_command(self.state.ser, \\\"SetAdf14\\\", str(self.state.device_id),\\n param)\\n if answer == 'Ok':\\n self.statusbar.showMessage(self.result_dict[button])\\n # при установлении диапазона, он записывается в интерфейсе везде\\n if button in self.btn.keys():\\n self.state.range = button.text()\\n self.LblFreqVal.setText(button.text())\\n self.LblResVal.setText(str(states_dict[button.text()][0] +\\n self.SpinFine.value() + self.SpinRough.value()))\\n # все кнопки серые, кроме кнопки режима\\n for btn in self.btns.keys():\\n btn.setStyleSheet(\\\"\\\")\\n self.btns[btn].setStyleSheet(\\\"font: 16px\\\")\\n button.setStyleSheet(\\\"background-color : rgb(70, 210, 00)\\\")\\n self.btns[button].setStyleSheet(\\\"color: red; font: bold 16px\\\")\\n else:\\n error_message(self.error_dict[button])\\n self.statusbar.showMessage(answer_translate[answer])\\n\\n # add commands to log\\n param = registers.get_reg_str(state, move).replace(\\\" \\\", '\\\\n')\\n param.replace(\\\" \\\", \\\"\\\\n\\\")\\n self.create_log_message(button.text(), answer, param)\\n\\n # set sw command\\n if answer == 'Ok' and button in self.btn.keys():\\n params = '0 1' if button == self.BtnL1 else \\\"1 0\\\"\\n self.set_sw(params)\",\n \"def write_firmware(self, data):\\n self.check_validity()\\n\\n data = list(map(int, data))\\n\\n return self.ipcon.send_request(self, BrickletIndustrialDualAnalogInV2.FUNCTION_WRITE_FIRMWARE, (data,), '64B', 9, 'B')\",\n \"def _write(self, data):\\n\\n ret = False\\n extended_address = SettingsBase.get_setting(self, \\\"extended_address\\\")\\n addr = (extended_address, 0xe8, 0xc105, 0x11)#prey this works, I can't test it...\\n try:\\n self.__xbee_manager.xbee_device_xmit(0xe8, data, addr)\\n ret = True\\n print \\\"success!\\\" #\\n except:\\n print \\\"(..., 0xc105, 0x11) faild, trying (..., 0, 0)\\\" #\\n try: #\\n addr = (extended_address, 0xe8, 0, 0) #\\n self.__xbee_manager.xbee_device_xmit(0xe8, data, addr) #\\n ret = True #\\n print \\\"success!\\\" #\\n except: #\\n print \\\"(..., 0, 0) faild\\\" #\\n pass\\n return ret\",\n \"def _write_v1(self, data):\\n return self.usb_dev.write(self.ep_out, data, self.interface, self.usb_wr_timeout)\",\n \"def wr32(add,dat):\\r\\n global this_fpga_ip\\r\\n global this_sock\\r\\n global this_udp_port\\r\\n \\r\\n pkt = array.array('L')\\r\\n pkt.append(1001) #psn\\r\\n pkt.append(2) #opcode\\r\\n pkt.append(1) #noo\\r\\n pkt.append(add) #sa\\r\\n pkt.append(dat) #dat\\r\\n \\r\\n this_sock.sendto(bytes(pkt.tostring()),(this_fpga_ip,this_udp_port))\\r\\n data, addr = this_sock.recvfrom(10240)\\r\\n return\",\n \"def send(self, value, char_mode=False):\\n \\n # Sends 8b ``value`` in ``char_mode``.\\n # :param value: bytes\\n # :param char_mode: character/data mode selector. False (default) for\\n # data only, True for character bits.\\n # one ms delay to prevent writing too quickly.\\n time.sleep(0.001)\\n # set character/data bit. (charmode = False)\\n self.reset.value = char_mode\\n # WRITE upper 4 bits\\n self.dl4.value = ((value >> 4) & 1) > 0\\n self.dl5.value = ((value >> 5) & 1) > 0\\n self.dl6.value = ((value >> 6) & 1) > 0\\n self.dl7.value = ((value >> 7) & 1) > 0\\n # send command\\n self._pulse_enable()\\n # WRITE lower 4 bits\\n self.dl4.value = (value & 1) > 0\\n self.dl5.value = ((value >> 1) & 1) > 0\\n self.dl6.value = ((value >> 2) & 1) > 0\\n self.dl7.value = ((value >> 3) & 1) > 0\\n self._pulse_enable()\",\n \"def sendData(self, data):\\n self.tx.sendBuffer(data)\",\n \"def WriteFLASH_old(self, data):\\n # print('program flash start')\\n start_addr = 9 << 18\\n cmd = self.board_def.CMD_WRITE_MEM\\n pad = 0xFFFFFF\\n #I need to pack bank into 4 bytes and then only use the 3\\n packedPad = struct.pack(\\\"L\\\", pad)\\n unpackedPad = struct.unpack('4b', packedPad)\\n length = len(data)\\n packet = struct.pack(\\\"4bLL\\\", cmd, unpackedPad[0], unpackedPad[1], unpackedPad[2], start_addr, length)\\n #Next I need to send the command\\n self.send_data(packet)\\n #next read from the socket\\n recv_stat, recv_data = self.receive_data()\\n if recv_stat != 0x0:\\n print ('Ram Write cmd Error stat={}!!!'.format(recv_stat))\\n return self.board_def.STAT_ERROR\\n\\n self.send_data(data)\\n #next read from the socket to ensure no errors occur\\n self.sockfd.settimeout(1000);\\n stat, data = self.receive_data()\\n self.sockfd.settimeout(5)\\n # print(packet)\\n\\n # print('program flash end')\\n if stat != 0x0:\\n print ('Ram Write Error stat={}!!!'.format(stat))\\n return self.board_def.STAT_ERROR\",\n \"def command(self, c):\\n if self._spi is not None:\\n # SPI write.\\n self._gpio.set_low(self._dc)\\n self._spi.write([c])\\n else:\\n # I2C write.\\n control = 0x00 # Co = 0, DC = 0\\n self._i2c.write8(control, c)\",\n \"def send_command(self, command):\\n self.enable_serial_port(self.port)\\n time.sleep(.2)\\n self.serial_com.write(command.encode() + b'\\\\r\\\\n')\\n time.sleep(.2)\",\n \"def callback_serial_write(data):\\n serial_write(data.data)\",\n \"def _write(self, register, data):\\n\\n # data: list of bytes to write to register\\n assert register in _registers, '%r is not a valid register. Register must be passed as string.' %register\\n assert len(data) == _register_len[register], 'Must pass %r byte(s) to %r register.' %(_register_len[register], register)\\n\\n # send the register we want to write to\\n self.spi.writebytes([_registers[register]])\\n\\n # send the bytes we write to the register\\n self.spi.writebytes(data)\",\n \"def sn(self):\\n\\t\\tstring = []\\n\\t\\tresp = [0x00]\\n\\t\\tself.spi.transfer([0x10], [0x00], 1)\\n\\t\\ttime.sleep(9e-3)\\n\\t\\tfor i in range(60):\\n\\t\\t\\tself.spi.transfer([0x00], resp, 1)\\n\\t\\t\\tstring.append(chr(resp[0]))\\n\\t\\ttime.sleep(0.1)\\n\\t\\treturn ''.join(string).strip()\",\n \"def write(self, data):\\n try:\\n self.ser.write(data)\\n except SerialException as se:\\n log.debug('Serial connection write error: {}'.format(se))\",\n \"def s_write(self, data):\\n self.s.flushOutput()\\n\\n if self.s.is_open:\\n try:\\n self.s.write(data)\\n if self.log_output:\\n self.logfile.write('\\\\nIN :' + str(len(data)) + '[' + hexlify(data) + ']' + '\\\\n')\\n except Exception as e:\\n print(\\\"Could not write to port \\\" + str(e))\\n else:\\n raise IOError('Comport is not open, use ctl_connect()')\",\n \"def leds(self, state):\\n if state:\\n state = b'\\\\x01'\\n else:\\n state = b'\\\\x00'\\n msg = b'\\\\x0D' + state\\n self.__bt.write(msg)\",\n \"def send(self, data):\",\n \"def write_cmd(self, cmd):\\n self._dc_pin.value = False\\n with self.spi_device as spi:\\n spi.write(bytearray([cmd])) # pylint: disable=no-member\",\n \"def _send_data(self, data, time):\\n pass\",\n \"def send_to_engine(self, wi):\\n pass\",\n \"def __init__(self, leds):\\n self.ledcount = leds\\n # create a buffer\\n self.buffersize = self.ledcount * 4\\n self.buffer = bytearray(self.ledcount * 4)\\n self.emptybuffer = bytearray(self.ledcount * 4)\\n for i in range(0, self.buffersize, 4):\\n self.emptybuffer[i] = 0xff\\n self.emptybuffer[i + 1] = 0x0\\n self.emptybuffer[i + 2] = 0x0\\n self.emptybuffer[i + 3] = 0x0\\n # Start frame and endframe for the SPI communication (end frame is not\\n # needed)\\n self.startframe = bytes([0x00, 0x00, 0x00, 0x00])\\n self.endframe = bytes([0xff, 0xff, 0xff, 0xff])\\n # initialize SPI (needs to be at 45 MHz in order to maximize the speed.\\n # This is the limiting factor for the system's speed)\\n self.spi = SPI(1, SPI.MASTER, baudrate=45000000,\\n polarity=0, phase=0, bits=8, firstbit=SPI.MSB)\\n self.clearleds()\",\n \"def use_spi():\\n _LIB.oled_click_use_spi()\",\n \"def write(self):\\n mask = 0\\n for pin in self.pins:\\n if pin.mode == OUTPUT:\\n if pin.value == 1:\\n pin_nr = pin.pin_number - self.port_number * 8\\n mask |= 1 << pin_nr\\n msg = chr(DIGITAL_MESSAGE + self.port_number)\\n msg += chr(mask % 128)\\n msg += chr(mask >> 7)\\n self.board.sp.write(msg)\",\n \"def write(self, data: bytes) -> None:\\n self.device.write(binascii.unhexlify(data))\",\n \"def sendValue(self, value):\\n\\n print(f'Sending: {value}\\\\n')\\n self.ser.write(bytes([value]))\\n self.ser.write('\\\\n'.encode(\\\"ascii\\\"))\\n\\n self.ser.reset_input_buffer()\\n ser_bytes = self.ser.read(1)\\n print(f'Receiving\\\\nraw data: {ser_bytes}')\\n\\n\\n #decoded_bytes = (ser_bytes.decode(\\\"ascii\\\"))\\n\\n #print(f'Ascii Value: {decoded_bytes}', flush=True)\",\n \"def send_packet(self, buffer_id, raw_data, out_port, in_port):\\n # We tell the switch to take the packet with id buffer_if from in_port \\n # and send it to out_port\\n # If the switch did not specify a buffer_id, it must have specified\\n # the raw data of the packet, so in this case we tell it to send\\n # the raw data\\n msg = of.ofp_packet_out()\\n msg.in_port = in_port\\n if buffer_id != -1 and buffer_id is not None:\\n # We got a buffer ID from the switch; use that\\n msg.buffer_id = buffer_id\\n else:\\n # No buffer ID from switch -- we got the raw data\\n if raw_data is None:\\n # No raw_data specified -- nothing to send!\\n return\\n msg.data = raw_data\\n \\n # Add an action to send to the specified port\\n if out_port == of.OFPP_FLOOD:\\n # send to all active ports according to STP\\n for outPort in self.ports_use:\\n if outPort != in_port:\\n action = of.ofp_action_output(port=outPort)\\n msg.actions.append(action)\\n else:\\n action = of.ofp_action_output(port=out_port)\\n msg.actions.append(action)\\n # Send message to switch\\n self.connection.send(msg)\",\n \"def _send_data_to_wbt(self,nnData):\\n\\t\\tnnData += \\\"END\\\\n\\\"\\n\\t\\tself._conn.send(nnData)\",\n \"def send_data(self, data):\\r\\n try:\\r\\n self.sock.sendto(data, self.addr)\\r\\n except Exception:\\r\\n print(\\\"Cant't send a package\\\")\",\n \"def send_data(self, str_data):\\n try:\\n self.s.sendall(str_data.encode())\\n except OSError as e:\\n print(e)\",\n \"def serial_write(data):\\n global ser\\n if ser.writable():\\n ser.write(data)\\n else:\\n print 'The serial', ser.portstr, 'cannot be written.'\",\n \"def sendtoserial(self, module, msg):\\n self.send(\\\"sendserial/{}/{}:{}\\\\n\\\".format(self.msg_id, module, msg))\\n self.msg_id += 1\",\n \"def write(byte, inc=False):\\n # Make the D-ports output\\n for port in D_ports:\\n GPIO.setup(port, GPIO.OUT)\\n\\n # write the byte as zero-padded binary\\n byte_string = '{0:08b}'.format(byte)\\n # put the reversed bits on the D-pins\\n for i,b in enumerate(byte_string[::-1]):\\n set(D_ports[i], int(b))\\n # READ to HI (inactive)\\n on(READ)\\n # pulse WR to LO (active) for 5ms\\n pulse_lo(WRITE, length=0.005)\\n # OE to LO (active)\\n off(READ)\\n\\n # Put the ports back to read and they should read the byte written\\n for port in D_ports:\\n GPIO.setup(port, GPIO.IN)\\n\\n if inc:\\n incr()\",\n \"def send_serial_command(data):\\n print(data)\\n serial_command = data\\n SERIAL_PARENT.send(serial_command)\\n OUTGOING.append(serial_command)\",\n \"def led1(self, val):\\n data = val & self.LED1_MASK\\n self._ftdi.spi_write(self.LED1_ADDR, [data], burst='fixed')\",\n \"def _sendSRAM(self, data):\\n p = self.makePacket()\\n self.makeSRAM(data, p)\\n p.send()\",\n \"def transmit(self) -> None:\\n # Like RadioHead library, turn on high power boost if enabled.\\n self.set_boost(_TEST_PA1_BOOST)\\n # Enable packet sent interrupt for D0 line.\\n self.dio_0_mapping = 0b00\\n # Enter TX mode (will clear FIFO!).\\n self.operation_mode = TX_MODE\",\n \"def wr(self, port, val):\\n hw = self.device.peripherals[port]\\n hw.ODR.wr(val)\",\n \"def main():\\n if not bcm2835_init():\\n return\\n\\n bcm2835_spi_begin()\\n bcm2835_spi_setBitOrder(BCM2835_SPI_BIT_ORDER_MSBFIRST) # The default\\n bcm2835_spi_setDataMode(BCM2835_SPI_MODE0) # The default\\n bcm2835_spi_setClockDivider(BCM2835_SPI_CLOCK_DIVIDER_65536) # The default\\n bcm2835_spi_chipSelect(BCM2835_SPI_CS0) # The default\\n bcm2835_spi_setChipSelectPolarity(BCM2835_SPI_CS0, LOW) # the default\\n\\n # Send a byte to the slave and simultaneously read a byte back from the slave\\n # If you tie MISO to MOSI, you should read back what was sent\\n data = bcm2835_spi_transfer(0x23);\\n print(\\\"Read from SPI: %02X\\\" % data)\\n\\n bcm2835_spi_end()\\n bcm2835_close()\",\n \"def _send_command(self, command):\\n self._serial_port.write(command + '\\\\n')\\n self._serial_port.flush()\",\n \"def send(self, seq_number, *voltage_list):\\r\\n\\r\\n timestamp = time.perf_counter()\\r\\n volt_list = list()\\r\\n for volt in voltage_list:\\r\\n volt_list.append(volt)\\r\\n try:\\r\\n self.sock.sendto(struct.pack(packet.H2R_PACKET_FORMAT, seq_number, packet.time2int(timestamp), *volt_list),\\r\\n (self.robot_ip, self.robot_port))\\r\\n\\r\\n self.tx_cntr.inc()\\r\\n\\r\\n self.tastx_ks[seq_number + 1] = timestamp\\r\\n\\r\\n try:\\r\\n tsr_k = self.tsr_ks[seq_number]\\r\\n tsstx_k = self.tsstx_ks[seq_number]\\r\\n tssrx_k = self.tssrx_ks[seq_number]\\r\\n tastx_k = self.tastx_ks[seq_number]\\r\\n tasrx_k = self.tasrx_ks[seq_number]\\r\\n taw_k = self.taw_ks[seq_number]\\r\\n\\r\\n if packet.time2int(tasrx_k) is not 0:\\r\\n self.tsr_k_logger.timestamp(timestamp=tsr_k, value=tsr_k)\\r\\n self.tsstx_k_logger.timestamp(timestamp=tsstx_k, value=tsstx_k)\\r\\n\\r\\n self.tssrx_k_logger.timestamp(timestamp=tssrx_k, value=tssrx_k)\\r\\n self.tastx_k_logger.timestamp(timestamp=tastx_k, value=tastx_k)\\r\\n\\r\\n self.tasrx_k_logger.timestamp(timestamp=tasrx_k, value=tasrx_k)\\r\\n self.taw_k_logger.timestamp(timestamp=taw_k, value=taw_k)\\r\\n\\r\\n del self.tsr_ks[seq_number - 1]\\r\\n del self.tsstx_ks[seq_number - 1]\\r\\n\\r\\n del self.tasrx_ks[seq_number - 1]\\r\\n del self.taw_ks[seq_number - 1]\\r\\n\\r\\n except KeyError:\\r\\n logging.debug(\\\"Packet not found\\\")\\r\\n\\r\\n except socket.error:\\r\\n logging.error('Tx error')\\r\\n return\",\n \"def on(self):\\n\\t\\trb0 = [0x00]\\n\\t\\trb1 = [0x00, 0x00]\\n\\t\\tattempts = 0\\n\\n\\t\\twhile self.state != ON and attempts < MAX_RETRIES:\\n\\t\\t\\tself.spi.transfer([0x03], rb0, 1)\\t\\t## Send the command byte; response will be written to rb0\\n\\t\\t\\ttime.sleep(9e-3) \\t\\t\\t\\t\\t\\t## Sleep for 9 ms\\n\\t\\t\\tself.spi.transfer([0x00, 0x01], rb1, 2)\\t## Send the following 2 bytes; response will be written to rb1\\n\\t\\t\\ttime.sleep(0.1)\\n\\n\\t\\t\\tif rb0[0] < 0: \\t\\t\\t\\t\\t\\t## Account for implicit unsigned-to-signed \\n\\t\\t\\t\\trb0[0] += 256\\t\\t\\t\\t\\t## conversion from the transfer operation\\n\\n\\t\\t\\tattempts += 1\\n\\t\\t\\tprint(f\\\"[{self.__class__.__name__}::on]\\\", end=' ')\\n\\t\\t\\tif rb0[0] == 0xF3 and rb1[0] == 0x03: \\t## Ensure response values are as expected\\n\\t\\t\\t\\tself.state = ON \\n\\t\\t\\t\\tprint(\\\"SUCCESS -- device powered on.\\\")\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif attempts != MAX_RETRIES:\\n\\t\\t\\t\\t\\tprint(f\\\"Attempt #{attempts} failed -- retrying after delay ...\\\")\\n\\t\\t\\t\\t\\ttime.sleep(RETRY_DELAY)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tprint(\\\"ERROR -- command failed.\\\")\\n\\n\\t\\treturn self.state == ON\",\n \"def spi_controller(\\n # ---[ Module Ports]---\\n glbl, # global interface, clock, reset, etc.\\n spibus, # external SPI bus\\n # optional ports\\n fifobus=None, # streaming interface, FIFO bus\\n mmbus=None, # memory-mapped bus, contro status access\\n cso=None, # control-status object\\n \\n # ---[ Module Parameters ]---\\n include_fifo=True, # include aan 8 byte deep FIFO\\n):\\n clock, reset = glbl.clock, glbl.reset\\n if cso is None:\\n cso = spi_controller.cso()\\n\\n # -- local signals --\\n ena = Signal(False)\\n clkcnt = Signal(modbv(0, min=0, max=2**12))\\n bcnt = Signal(intbv(0, min=0, max=8))\\n\\n # separate tx and rx shift-registers (could be one in the same)\\n treg = Signal(intbv(0)[8:]) # tx shift register\\n rreg = Signal(intbv(0)[8:]) # rx shift register\\n\\n x_sck, x_ss, x_mosi, x_miso = Signals(bool(0), 4)\\n\\n # internal FIFO bus interfaces\\n # external FIFO side (FIFO to external SPI bus)\\n itx = FIFOBus(size=fifobus.size, width=fifobus.width)\\n # internal FIFO side (FIFO to internal bus)\\n irx = FIFOBus(size=fifobus.size, width=fifobus.width)\\n \\n states = enum('idle', 'wait_hclk', 'data_in', 'data_change',\\n 'write_fifo', 'end')\\n state = Signal(states.idle)\\n\\n # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n # memory- mapped registers\\n # add the peripheral's regfile to the bus (informational only)\\n # @todo: the automatic building of the register files is incomplete\\n if mmbus is not None:\\n # the register-file (rf) will drive all the cso signals\\n rf = cso.get_register_file()\\n mmbus.add(rf, 'spi')\\n\\n # FIFO for the wishbone data transfer\\n if include_fifo:\\n fifo_fast.debug = spi_controller.debug\\n fifo_tx_inst = fifo_fast(reset, clock, itx)\\n fifo_rx_inst = fifo_fast(reset, clock, irx)\\n\\n @always_comb\\n def rtl_assign():\\n cso.tx_fifo_count.next = itx.count\\n cso.rx_fifo_count.next = irx.count\\n\\n if clkcnt > 0:\\n ena.next = False\\n else:\\n ena.next = True\\n\\n clock_counts = tuple([(2**ii)-1 for ii in range(13)])\\n\\n @always(clock.posedge)\\n def rtl_clk_div():\\n if cso.enable and clkcnt != 0 and state != states.idle:\\n clkcnt.next = (clkcnt - 1)\\n else:\\n clkcnt.next = clock_counts[cso.clock_divisor]\\n\\n @always_seq(clock.posedge, reset=reset)\\n def rtl_state_and_more():\\n \\\"\\\"\\\"\\n Designed to the following timing diagram\\n\\n SCK CPOL=0 ______/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\ \\n CPOL=1 ------\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/---\\\\___/ \\n SS ---\\\\_______________________________________________________________________ \\n CPHA=0 MOSI ...|.0....|.1.....|.2.....|.3.....|.4.....|.5.....|.6.....|.7.....|.0.....| \\n MISO ...|.0....|.1.....|.2.....|.3.....|.4.....|.5.....|.6.....|.7.....|.0.....| \\n CPHA=1 MOSI ...|....0.....|.1.....|.2.....|.3.....|.4.....|.5.....|.6.....|.7.....|.0...\\n MISO ......|.0.....|.1.....|.2.....|.3.....|.4.....|.5.....|.6.....|.7.....|.0...\\n \\\"\\\"\\\"\\n if not cso.enable:\\n state.next = states.idle\\n bcnt.next = 0\\n treg.next = 0\\n \\n itx.read.next = False\\n irx.write.next = False\\n\\n x_sck.next = False\\n x_ss.next = False\\n else:\\n if not cso.freeze:\\n # ~~~~ Idle state ~~~~\\n if state == states.idle:\\n bcnt.next = 7\\n treg.next = itx.read_data\\n x_sck.next = cso.clock_polarity\\n irx.write.next = False\\n \\n if not itx.empty and not irx.full:\\n itx.read.next = True\\n x_ss.next = False\\n if cso.clock_phase: # Clock in on second phase\\n state.next = states.wait_hclk\\n else: # Clock in on first phase\\n state.next = states.data_in\\n else:\\n itx.read.next = False\\n x_ss.next = True\\n\\n # ~~~~ Wait half clock period for cpha=1 ~~~~\\n elif state == states.wait_hclk:\\n itx.read.next = False\\n irx.write.next = False\\n if ena:\\n x_sck.next = not x_sck\\n state.next = states.data_in\\n\\n # ~~~~ Clock data in (and out) ~~~~\\n elif state == states.data_in:\\n itx.read.next = False\\n irx.write.next = False\\n if ena: # clk div\\n x_sck.next = not x_sck\\n rreg.next = concat(rreg[7:0], x_miso)\\n \\n if cso.clock_phase and bcnt == 0:\\n irx.write.next = True\\n if itx.empty or irx.full:\\n state.next = states.end\\n else:\\n state.next = states.data_change\\n else:\\n state.next = states.data_change\\n\\n # ~~~~ Get ready for next byte out/in ~~~~\\n elif state == states.data_change:\\n itx.read.next = False\\n irx.write.next = False\\n if ena:\\n x_sck.next = not x_sck\\n if bcnt == 0: \\n if not cso.clock_phase:\\n irx.write.next = True\\n \\n if itx.empty or irx.full:\\n state.next = states.end\\n else: # more data to transfer\\n bcnt.next = 7\\n state.next = states.data_in\\n itx.read.next = True\\n treg.next = itx.read_data\\n else:\\n treg.next = concat(treg[7:0], intbv(0)[1:])\\n bcnt.next = bcnt - 1 \\n state.next = states.data_in\\n\\n # ~~~~ End state ~~~~\\n elif state == states.end:\\n itx.read.next = False\\n irx.write.next = False\\n if ena: # Wait half clock cycle go idle\\n state.next = states.idle\\n\\n # Shouldn't happen, error in logic\\n else:\\n state.next = states.idle\\n assert False, \\\"SPI Invalid State\\\"\\n\\n @always_comb\\n def rtl_fifo_sel():\\n \\\"\\\"\\\"\\n The `itx` and `irx` FIFO interfaces are driven by different\\n logic depending on the configuration. This modules accesses\\n the `itx` read side and drives the `irx` write side. The\\n `itx` write side is driven by the `cso` or the `fifobus` port.\\n The `irx` read side is accessed by the `cso` or the `fifobus`\\n port.\\n \\\"\\\"\\\"\\n if cso.bypass_fifo:\\n # data comes from the register file\\n cso.tx_empty.next = itx.empty\\n cso.tx_full.next = itx.full\\n itx.write_data.next = cso.tx_byte\\n\\n cso.rx_empty.next = irx.empty\\n cso.rx_full.next = irx.full\\n cso.rx_byte.next = irx.read_data\\n cso.rx_byte_valid.next = irx.read_valid\\n\\n # @todo: if cso.tx_byte write signal (written by bus) drive the\\n # @todo: FIFO write signals, same if the cso.rx_byte is accessed\\n itx.write.next = cso.tx_write\\n irx.read.next = cso.rx_read\\n\\n else:\\n # data comes from external FIFO bus interface\\n fifobus.full.next = itx.full\\n itx.write_data.next = fifobus.write_data\\n itx.write.next = fifobus.write\\n\\n fifobus.empty.next = irx.empty\\n fifobus.read_data.next = irx.read_data\\n fifobus.read_valid.next = irx.read_valid\\n irx.read.next = fifobus.read\\n\\n # same for all modes\\n irx.write_data.next = rreg\\n\\n @always_comb\\n def rtl_x_mosi():\\n # @todo lsb control signal\\n x_mosi.next = treg[7]\\n\\n @always_comb\\n def rtl_gate_mosi():\\n if cso.loopback:\\n spibus.mosi.next = False\\n else:\\n spibus.mosi.next = x_mosi\\n\\n @always_comb #(clock.posedge)\\n def rtl_spi_sigs():\\n spibus.sck.next = x_sck\\n if cso.loopback:\\n x_miso.next = x_mosi\\n else:\\n x_miso.next = spibus.miso\\n\\n @always_comb\\n def rtl_slave_select():\\n if cso.manual_slave_select:\\n spibus.ss.next = ~cso.slave_select\\n elif x_ss:\\n spibus.ss.next = 0xFF\\n else:\\n spibus.ss.next = ~cso.slave_select\\n\\n # myhdl generators in the __debug__ conditionals are not converted.\\n if spi_controller.debug:\\n @instance\\n def mon_state():\\n print(\\\" :{:<8d}: initial state {}\\\".format(\\n now(), str(state)))\\n \\n while True:\\n yield state\\n print(\\\" :{:<8d}: state transition --> {}\\\".format(\\n now(), str(state)))\\n \\n fbidle = intbv('0000')[4:]\\n\\n @instance\\n def mon_trace():\\n while True:\\n yield clock.posedge\\n ccfb = concat(itx.write, itx.read, irx.write, irx.read)\\n if ccfb != fbidle:\\n fstr = \\\" :{:<8d}: tx: w{} r{}, f{} e{}, rx: w{} r{} f{} e{}\\\"\\n print(fstr.format(now(),\\n int(itx.write), int(itx.read), int(itx.full), int(itx.empty),\\n int(irx.write), int(irx.read), int(irx.full), int(irx.empty),)\\n )\\n \\n @always(clock.posedge)\\n def mon_tx_fifo_write():\\n if itx.write:\\n print(\\\" WRITE tx fifo {:02X}\\\".format(int(itx.write_data)))\\n if itx.read:\\n print(\\\" READ tx fifo {:02X}\\\".format(int(itx.read_data)))\\n \\n @always(clock.posedge)\\n def mon_rx_fifo_write():\\n if irx.write:\\n print(\\\" WRITE rx fifo {:02X}\\\".format(int(irx.write_data)))\\n \\n if irx.read:\\n print(\\\" READ rx fifo {:02X}\\\".format(int(irx.read_data)))\\n\\n # return the myhdl generators\\n gens = myhdl.instances()\\n return gens\",\n \"def send( self, value, mode=LCD_RS ): # RegisterSelect bit by default\\n\\t\\thighnib = value & 0xF0\\n\\t\\tlownib=(value<<4) & 0xF0\\n\\t\\tself.write4bits( highnib | mode )\\n\\t\\tself.write4bits( lownib | mode )\",\n \"def sendAuto(self):\\n if (self.ser is not None):\\n if len(self.cmd)>0:\\n try:\\n # TODO gestion python 2.0 (str) ou 3.0 (encode)\\n cmd = self.cmd[0] + \\\"\\\\n\\\"\\n self.ser.write(cmd.encode())\\n self.t_TX = time.time()\\n if self.mutexCmd.tryLock(100):\\n del self.cmd[0]\\n self.mutexCmd.unlock()\\n else:\\n print(\\\"WARN: cmd not send\\\")\\n print(self.t_TX, cmd[:-1])\\n except Exception as e:\\n print(\\\"ERROR:Serial:sendAuto\\\",e)\",\n \"def write(self, register, value): #good\\r\\n\\t\\tself.i2c.write8(register, value)\",\n \"def send(self, data):\\n starttime = time.time()\\n while 1:\\n if self._waiting_response==1:\\n if time.time() - starttime > self._maxrespdelay:\\n break\\n _LOGGER.debug(\\\"Send going to sleep\\\\n\\\")\\n time.sleep(self._sleeptime)\\n else:\\n break\\n\\n currtime = time.time()\\n if currtime - self._lastcall > self._maxtime:\\n self.reset()\\n self._lastcall = currtime\\n _LOGGER.debug(\\\"Sending: %s\\\", data)\\n if not testing:\\n self.serial.reset_input_buffer()\\n bytessent = self.serial.write(data.encode())\\n return bytessent\\n else:\\n self._waiting_response = 1\\n return len(data)\",\n \"def write_firmware(self, data):\\n data = list(map(int, data))\\n\\n return self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_WRITE_FIRMWARE, (data,), '64B', 'B')\",\n \"def flash_write16(self, addr, data):\\n return self.flash_write(addr, data, 16)\",\n \"def _command(self, servo_id, instruction, *params):\\n length = 3 + len(params)\\n #print('length', length)\\n \\\"\\\"\\\"\\n checksum calculation:\\n checksum = ~(ID + length+instruction+parms) if the numbers in the brackets\\n are calculated and exceeded 255, then it takes the lowest one byte, \\\"~\\\"\\n means Negation\\n \\\"\\\"\\\"\\n checksum = 255 - ((servo_id + length + instruction + sum(params))% 256)\\n #print('checksum', checksum)\\n packet = [0x55, 0x55, servo_id, length, instruction, *params, checksum]\\n #print('packet', packet)\\n self._serial.write(bytearray(packet))\\n #print('Sending packet', packet)\",\n \"def set_switch(self, node_uuid, index, data):\\n if data == \\\"on\\\":\\n self._bus.i2c_acquire()\\n try:\\n p = self.values['num'].get_data_index(index=index)\\n self._bus.pca9685_manager.set_pwm(p, 4096, 0)\\n self.values['level'].set_data_index(index=index, data=100)\\n except Exception:\\n logger.exception('[%s] - Exception when switching on', self.__class__.__name__)\\n finally:\\n self._bus.i2c_release()\\n elif data == \\\"off\\\":\\n self._bus.i2c_acquire()\\n try:\\n p = self.values['num'].get_data_index(index=index)\\n self._bus.pca9685_manager.set_pwm(p, 0, 4096)\\n self.values['level'].set_data_index(index=index, data=0)\\n except Exception:\\n logger.exception('[%s] - Exception when switching off', self.__class__.__name__)\\n finally:\\n self._bus.i2c_release()\\n else:\\n logger.warning(\\\"[%s] - set_switch unknown data : %s\\\", self.__class__.__name__, data)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79480565","0.75796175","0.74145585","0.71241754","0.70519936","0.7026349","0.69845456","0.69544286","0.68782145","0.68735623","0.6855078","0.6780902","0.67396015","0.6739508","0.6665076","0.66579545","0.6576727","0.6573629","0.6531924","0.6527273","0.6477034","0.64688987","0.6459149","0.64537716","0.64059985","0.64010686","0.6366813","0.6349548","0.6340872","0.6185139","0.61171186","0.6102041","0.60558033","0.6049153","0.601123","0.60008967","0.59840375","0.5981327","0.59785175","0.5946093","0.5908002","0.590496","0.5896874","0.589377","0.5854047","0.5828965","0.58159703","0.5780565","0.5769477","0.57427156","0.5742339","0.5739623","0.5738773","0.573436","0.5723754","0.5713511","0.5710283","0.57084894","0.57061815","0.56993264","0.5694183","0.5691384","0.56761533","0.5674242","0.5670356","0.56672037","0.5651529","0.5648787","0.5625144","0.5614202","0.56087196","0.560422","0.5599468","0.5597625","0.5595329","0.55912566","0.5587608","0.55875313","0.55639285","0.5554185","0.5551544","0.5549665","0.5546999","0.5540577","0.5510476","0.5502372","0.55002826","0.5499179","0.5495476","0.5485021","0.54847836","0.5467527","0.5465589","0.54632926","0.5463004","0.5462038","0.54528844","0.54502106","0.54422647","0.54306906"],"string":"[\n \"0.79480565\",\n \"0.75796175\",\n \"0.74145585\",\n \"0.71241754\",\n \"0.70519936\",\n \"0.7026349\",\n \"0.69845456\",\n \"0.69544286\",\n \"0.68782145\",\n \"0.68735623\",\n \"0.6855078\",\n \"0.6780902\",\n \"0.67396015\",\n \"0.6739508\",\n \"0.6665076\",\n \"0.66579545\",\n \"0.6576727\",\n \"0.6573629\",\n \"0.6531924\",\n \"0.6527273\",\n \"0.6477034\",\n \"0.64688987\",\n \"0.6459149\",\n \"0.64537716\",\n \"0.64059985\",\n \"0.64010686\",\n \"0.6366813\",\n \"0.6349548\",\n \"0.6340872\",\n \"0.6185139\",\n \"0.61171186\",\n \"0.6102041\",\n \"0.60558033\",\n \"0.6049153\",\n \"0.601123\",\n \"0.60008967\",\n \"0.59840375\",\n \"0.5981327\",\n \"0.59785175\",\n \"0.5946093\",\n \"0.5908002\",\n \"0.590496\",\n \"0.5896874\",\n \"0.589377\",\n \"0.5854047\",\n \"0.5828965\",\n \"0.58159703\",\n \"0.5780565\",\n \"0.5769477\",\n \"0.57427156\",\n \"0.5742339\",\n \"0.5739623\",\n \"0.5738773\",\n \"0.573436\",\n \"0.5723754\",\n \"0.5713511\",\n \"0.5710283\",\n \"0.57084894\",\n \"0.57061815\",\n \"0.56993264\",\n \"0.5694183\",\n \"0.5691384\",\n \"0.56761533\",\n \"0.5674242\",\n \"0.5670356\",\n \"0.56672037\",\n \"0.5651529\",\n \"0.5648787\",\n \"0.5625144\",\n \"0.5614202\",\n \"0.56087196\",\n \"0.560422\",\n \"0.5599468\",\n \"0.5597625\",\n \"0.5595329\",\n \"0.55912566\",\n \"0.5587608\",\n \"0.55875313\",\n \"0.55639285\",\n \"0.5554185\",\n \"0.5551544\",\n \"0.5549665\",\n \"0.5546999\",\n \"0.5540577\",\n \"0.5510476\",\n \"0.5502372\",\n \"0.55002826\",\n \"0.5499179\",\n \"0.5495476\",\n \"0.5485021\",\n \"0.54847836\",\n \"0.5467527\",\n \"0.5465589\",\n \"0.54632926\",\n \"0.5463004\",\n \"0.5462038\",\n \"0.54528844\",\n \"0.54502106\",\n \"0.54422647\",\n \"0.54306906\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58544874"},"document_rank":{"kind":"string","value":"44"}}},{"rowIdx":9092,"cells":{"query":{"kind":"string","value":"Extracts function arguments for the decorated function."},"document":{"kind":"string","value":"def _extract_func_args(\n obj: str,\n arg_formats: Dict[str, int],\n arg_defaults: Dict[str, Any],\n input_dict: Dict[str, List[tfx_types.Artifact]],\n output_dict: Dict[str, List[tfx_types.Artifact]],\n exec_properties: Dict[str, Any],\n beam_pipeline: Optional[_BeamPipeline] = None,\n) -> Dict[str, Any]:\n result = {}\n for name, arg_format in arg_formats.items():\n if arg_format == function_parser.ArgFormats.INPUT_ARTIFACT:\n input_list = input_dict.get(name, [])\n if len(input_list) == 1:\n result[name] = input_list[0]\n elif not input_list and name in arg_defaults:\n # Do not pass the missing optional input.\n pass\n else:\n raise ValueError(\n ('Expected input %r to %s to be a singleton ValueArtifact channel '\n '(got %s instead).') % (name, obj, input_list))\n elif arg_format == function_parser.ArgFormats.OUTPUT_ARTIFACT:\n output_list = output_dict.get(name, [])\n if len(output_list) == 1:\n result[name] = output_list[0]\n else:\n raise ValueError(\n ('Expected output %r to %s to be a singleton ValueArtifact channel '\n '(got %s instead).') % (name, obj, output_list))\n elif arg_format == function_parser.ArgFormats.ARTIFACT_VALUE:\n input_list = input_dict.get(name, [])\n if len(input_list) == 1:\n result[name] = input_list[0].value\n elif not input_list and name in arg_defaults:\n # Do not pass the missing optional input.\n pass\n else:\n raise ValueError(\n ('Expected input %r to %s to be a singleton ValueArtifact channel '\n '(got %s instead).') % (name, obj, input_list))\n elif arg_format == function_parser.ArgFormats.PARAMETER:\n if name in exec_properties:\n result[name] = exec_properties[name]\n elif name in arg_defaults:\n # Do not pass the missing optional input.\n pass\n else:\n raise ValueError(\n ('Expected non-optional parameter %r of %s to be provided, but no '\n 'value was passed.') % (name, obj))\n elif arg_format == function_parser.ArgFormats.BEAM_PARAMETER:\n result[name] = beam_pipeline\n if name in arg_defaults and arg_defaults[name] is not None:\n raise ValueError('beam Pipeline parameter does not allow default ',\n 'value other than None.')\n else:\n raise ValueError('Unknown argument format: %r' % (arg_format,))\n return result"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def extract_captured_arguments(func):\n captured_arguments = getattr(func, ATTR_NAME)\n if type(captured_arguments) is not _CapturedArguments: # pylint: disable=unidiomatic-typecheck\n # The attribute was not set by tcm, so effectively it does not exist.\n raise AttributeError\n delattr(func, ATTR_NAME)\n return captured_arguments","def _extract_args(self, func):\n sig = inspect.signature(func)\n\n # Backwards compatibility\n if len(sig.parameters) == 1:\n ((name, parameter),) = sig.parameters.items()\n if (\n parameter.kind is parameter.POSITIONAL_OR_KEYWORD\n and parameter.annotation in (parameter.empty, argparse.Namespace)\n ):\n self._require_namespace = name\n return\n\n for name, parameter in sig.parameters.items():\n if parameter.annotation is argparse.Namespace:\n self._require_namespace = name\n else:\n arg = Argument.from_parameter(name, parameter)\n action = arg.register_with_proxy(self)\n self._args.append((name, action.dest))","def inspect_args_func(frame):\n args, _, _, values = inspect.getargvalues(frame)\n return {key: values[key] for key in args if key != 'self'}","def arguments(*args):\n def decorate(func):\n func.arguments = args\n return func\n return decorate","def arguments_from_call_funccode(f):\n fc = fc_or_c(f.__call__)\n argcount = fc.co_argcount\n args = list(fc.co_varnames[1:argcount])\n if not args:\n raise RuntimeError('Function has variable number of arguments')\n return args","def extract_args(*args: str, **kwargs) -> Optional[AttributeExtractor]:\n def extract(values: Dict[str, any], fn) -> Dict[Attribute, any]:\n out = {}\n\n for name in args:\n if name not in values:\n logging.warning(\n f\"@trace decorator refers to an argument '{name}' that was not found in the \"\n f\"signature for {fn.__qualname__}! (this attribute will not be added)\")\n else:\n out[Attribute(name, register=False)] = values[name]\n\n for name, value in kwargs.items():\n if name not in values:\n logging.warning(\n f\"@trace decorator refers to an argument '{name}' that was not found in the \"\n f\"signature for {fn.__qualname__}! (this attribute will not be added)\")\n else:\n if isinstance(value, Attribute):\n out[value] = values[name]\n elif isinstance(value, str):\n out[Attribute(value, register=False)] = values[name]\n elif value == Label:\n out[Label(name, register=False)] = values[name]\n elif value == Attribute:\n out[Attribute(name, register=False)] = values[name]\n else:\n logging.warning(\n f\"@trace decorator has invalid mapping for argument '{name}'. Expected one of Label, Attribute or str but got {type(value)}\")\n return out\n return extract","def extractArguments(frame):\n\n\targuments = ([], None, None)\n\ttry:\n\t\tsource = textwrap.dedent(str().join(inspect.getsourcelines(frame)[0]).replace(\"\\\\\\n\", str()))\n\texcept (IOError, TypeError) as error:\n\t\treturn arguments\n\n\ttry:\n\t\tnode = ast.parse(source)\n\texcept:\n\t\treturn arguments\n\n\tif not node.body:\n\t\treturn arguments\n\n\tnode = node.body[0]\n\tif not isinstance(node, ast.FunctionDef):\n\t\treturn arguments\n\n\treturn [arg.id for arg in node.args.args], node.args.vararg, node.args.kwarg","def GetFunctionParametersAndValues():\n frame = inspect.currentframe().f_back\n args, _, _, values = inspect.getargvalues(frame)\n return ([(i, values[i]) for i in args])","def arguments_from_funccode(f):\n fc = fc_or_c(f)\n vnames = fc.co_varnames\n nargs = fc.co_argcount\n # bound method and fake function will be None\n args = vnames[1 if is_bound(f) else 0:nargs]\n if not args:\n raise RuntimeError('Function has variable number of arguments')\n return list(args)","def get_input_arguments(kwargs, function, warn=True):\n np.set_printoptions(threshold=20)\n print('\\narguments to {}:'.format(function.__qualname__))\n params = inspect.signature(function)\n input_kwargs = {}\n not_arguments = {}\n for k, v in kwargs.items():\n if k in params.parameters:\n input_kwargs[k] = v\n print_item(k, v)\n else:\n not_arguments[k] = v\n if warn:\n print('\\nother arguments:')\n for k, v in not_arguments.items():\n #print('{}: {}'.format(k, v))\n print_item(k, v)\n print('\\n')\n return input_kwargs","def get_input_arguments(kwargs, function, warn=True):\n np.set_printoptions(threshold=20)\n print('\\narguments to {}:'.format(function.__qualname__))\n params = inspect.signature(function)\n input_kwargs = {}\n not_arguments = {}\n for k, v in kwargs.items():\n if k in params.parameters:\n input_kwargs[k] = v\n print_item(k, v)\n else:\n not_arguments[k] = v\n if warn:\n print('\\nother arguments:')\n for k, v in not_arguments.items():\n #print('{}: {}'.format(k, v))\n print_item(k, v)\n print('\\n')\n return input_kwargs","def as_args(function):\n return lambda x: function(*x)","def to_args(f, *args, **kwargs):\n kwargs = to_kwargs(f, *args, **kwargs)\n s = inspect.getargspec(f)\n return [kwargs[a] for a in s.args]","def get_python_function_arguments(f):\n # Note that we only return non-optional arguments (we assume that any optional args are not specified).\n # This allows to, e.g., accept max(a, b, *more, name='') as a binary function\n param_specs = inspect.getfullargspec(f)\n annotations = param_specs.annotations\n arg_names = param_specs.args\n defaults = param_specs.defaults # \"if this tuple has n elements, they correspond to the last n elements listed\n # in args\"\n if defaults:\n arg_names = arg_names[:-len(defaults)]\n return (arg_names, annotations)","def derive_args(func):\n args = inspect.getfullargspec(func).args\n if args and is_selfish_name(args[0]):\n del args[0]\n return args","def _get_args(function, varargs=False):\n\n try:\n params = signature(function).parameters\n except ValueError:\n # Error on builtin C function\n return []\n args = [\n key\n for key, param in params.items()\n if param.kind not in (param.VAR_POSITIONAL, param.VAR_KEYWORD)\n ]\n if varargs:\n varargs = [\n param.name\n for param in params.values()\n if param.kind == param.VAR_POSITIONAL\n ]\n if len(varargs) == 0:\n varargs = None\n return args, varargs\n else:\n return args","def extract_function_metadata(wrapped, instance, args, kwargs, return_value):\n LOGGER.debug(\n \"Extracting function call metadata\", args=args, kwargs=kwargs,\n )\n return {\n \"metadata\": {\"args\": args, \"kwargs\": kwargs},\n }","def list_kwargs(func):\n \n details = inspect.getargspec(func)\n nopt = len(details.defaults)\n \n return details.args[-nopt:]","def preprocess_arguments(self, *args, **kwargs):\n return (args, kwargs)","def func_args(self) -> str:\n\n return self.call_data[10:]","def as_kwargs(function):\n return lambda x: function(**x)","def extract_arguments(args, method):\n intersection = lambda list1, list2: [x for x in list1 if x in list2]\n filterByKey = lambda keys, data: {x: data[x] for x in keys if x in data }\n keys = intersection(signature(method).parameters.keys(), args.keys())\n params = filterByKey(keys, args)\n return params","def extracts(*extract):\n def decorate(func):\n function = to_function(func)\n setattr(function, EXTRACTS, extract)\n return function\n return decorate","def dump_args(func):\n\n def wrapper(*args, **kwargs):\n func_args = inspect.signature(func).bind(*args, **kwargs).arguments\n func_args_str = ', '.join('{} = {!r}'.format(*item) for item in func_args.items())\n log(f'{func.__module__}.{func.__qualname__} ( {func_args_str} )')\n return func(*args, **kwargs)\n\n return wrapper","def get_keyword_args(function):\n argspec = inspect.getargspec(function)\n kwargs = argspec.args[len(argspec.args) - len(argspec.defaults):]\n kwargs = {arg: value for arg, value in zip(kwargs, argspec.defaults)}\n return kwargs","def dumpArgs(func):\n def wrapper(*args, **kwargs):\n func_args = inspect.signature(func).bind(*args, **kwargs).arguments\n func_args_str = ', '.join('{} = {!r}'.format(*item)\n for item in func_args.items())\n print(f'{func.__module__}.{func.__qualname__} ( {func_args_str} )')\n result = func(*args, **kwargs)\n print(f'{func.__module__}.{func.__qualname__} Return Result: \\n {result}')\n return result\n return wrapper","def test_arguments(self):\n calls = []\n decorator = self.decorator()\n\n @decorator\n def func(a, b, c):\n calls.append((a, b, c))\n\n func(1, 2, c=3)\n self.assertEqual(calls, [(1, 2, 3)])","def filter_function_arguments(self, fn_node):\n return self.filter_nodes('Argument', parent=fn_node)","def getargvalues(frame):\r\n args, varargs, varkw = getargs(frame.f_code)\r\n return ArgInfo(args, varargs, varkw, frame.f_locals)","def kwargsdec(f):\n def wrapper(**kwargs):\n args = inspect.getargspec(f).args\n return f(**{ k: kwargs[k] for k in args})\n return wrapper","def dump_args(func):\n\n def wrapper(*args, **kwargs):\n func_args = inspect.signature(func).bind(*args, **kwargs).arguments\n func_args_str = ', '.join('{} = {!r}'.format(*item) for item in func_args.items())\n print(f'{func.__module__}.{func.__qualname__} ( {func_args_str} )')\n return func(*args, **kwargs)\n\n return wrapper","def getargspec(self,obj):\n\n if inspect.isfunction(obj):\n func_obj = obj\n elif inspect.ismethod(obj):\n func_obj = obj.im_func\n else:\n raise TypeError, 'arg is not a Python function'\n args, varargs, varkw = inspect.getargs(func_obj.func_code)\n return args, varargs, varkw, func_obj.func_defaults","def getFunctionArguments(tokens: List[LEX_Type], last_token: LEX_Type) -> (List[AST_FunctionArgument], List[LEX_Type]):\n if tokens[0].type == \"LineEnd\":\n if tokens[1].type == \"Keyword\":\n return [], tokens\n return getFunctionArguments(tokens[1:], last_token)\n if tokens[0].type == \"ItemLister\":\n if tokens[1].type == \"Type\":\n if tokens[2].type == \"Identifier\":\n arguments: List[AST_FunctionArgument]\n last: List[LEX_Type]\n arguments, last = getFunctionArguments(tokens[3:], last_token)\n return [AST_FunctionArgument(tokens[1].value, tokens[2].value)] + arguments, last","def filter_args(fn, args_tuple):\n sig = inspect.signature(fn)\n flag_var_positional = any([\n inspect.Parameter.VAR_POSITIONAL == value.kind for\n value in sig.parameters.values()])\n if flag_var_positional:\n return args_tuple\n else:\n num_args = len(sig.parameters.items())\n return args_tuple[:num_args]","def get_kwargs_applicable_to_function(function, kwargs):\n return {\n key: value\n for key, value in kwargs.items()\n if key in inspect.getfullargspec(function).args\n }","def request_args(args):\n\n def _decorator(fn):\n fn.args = args\n return fn\n\n return _decorator","def create_args(func):\n # Get a dictionary of the params of the function\n params = dict(inspect.signature(func).parameters)\n # We will always use z for the vector input so delete that from the dict\n del params['z']\n return {k: peturb(v) for k, v in params.items()}","def getArgs(func):\n # exclude the defaults at the end (hence the [:-1])\n args = list(utils.flatten(inspect.getargspec(func)[:-1]))\n return set(args).difference(set([None]))","def params(funcarglist):\n def wrapper(function):\n function.funcarglist = funcarglist\n return function\n return wrapper","def register_args(f):\n\n @wraps(f)\n def inner(*_args, **_kwargs):\n self = _args[0]\n args, kwargs = args_kwargs(f)\n args = dict(zip(args[1::], _args[1::]))\n kwargs.update(_kwargs)\n self.args = args\n self.kwargs = kwargs\n return f(self, *args.values(), **kwargs)\n\n return inner","def get_fn_arg_contexts(cls, ctx: AntlrTelParser.FnContext) -> List[Any]:\n if len(ctx.children) <= 3:\n # [fn_name,(,)] => 3 children means no args, return empty array\n return []\n else:\n # Skip fnname and '(', step 2 to skip ','\n return ctx.children[2::2]","def _get_required_args(func):\n module_logger.debug(f\"_get_required_args: func={func}\")\n fas = inspect.getfullargspec(func)\n module_logger.debug(f\"_get_required_args: fas={fas}\")\n len_args = len(fas.args)\n len_args += len(fas.kwonlyargs)\n if fas.kwonlydefaults is not None:\n len_args -= len(fas.kwonlydefaults)\n if fas.defaults is not None:\n len_args -= len(fas.defaults)\n return len_args","def get_arguments(callable, exclude):\n info = arginfo(callable)\n defaults = info.defaults or []\n defaults = [None] * (len(info.args) - len(defaults)) + list(defaults)\n return {name: default for (name, default) in zip(info.args, defaults)\n if name not in exclude}","def _get_arguments(self) -> str:\n func = self.node\n\n # Early logic used to iterate over, `func.get_arguments()`, however when there\n # is an unknown type clang will sometimes fail to provide tokens for that\n # argument. For example in \"unknown_type foo[]\" the brackets will cause clang\n # to return back no tokens for the argument.\n start = func.location\n end = func.extent.end\n if func.is_definition():\n # When a function is a definition the last child is the compound statement\n # so we need to move prior to the compound statement\n children = list(func.get_children())\n body_start = children[-1].extent.start.offset\n end = cindex.SourceLocation.from_offset(func.tu, start.file, body_start - 1)\n\n extent = cindex.SourceRange.from_locations(start, end)\n non_comment_tokens = (\n t\n for t in cindex.TokenGroup.get_tokens(func.tu, extent=extent)\n if t.kind != cindex.TokenKind.COMMENT\n )\n\n # Even though this will place spaces around all the tokens, the sphinx C domain\n # will provide some formatting to make it look nicer in the final output.\n full_signature = \" \".join(t.spelling for t in non_comment_tokens)\n\n _, _, arguments = full_signature.partition(\"(\")\n arguments = arguments.rstrip(\")\")\n arguments = arguments.strip()\n\n return arguments","def _getargs(fn_sig):\n params = fn_sig.parameters\n args = []\n for k, v in params.items():\n if (v.kind & v.POSITIONAL_OR_KEYWORD) == v.POSITIONAL_OR_KEYWORD:\n args.append(k)\n else:\n msg = \"%s argument type unsupported in jitclass\" % v.kind\n raise errors.UnsupportedError(msg)\n return args","def print_args(func):\n def new_func(*args, **kwargs):\n print(args)\n print(kwargs)\n return func(*args, **kwargs)\n return new_func","def get_arguments(self, args=(), kwargs=None, onlykeys=False, onlyused=False,\n func=None):\n if func is None:\n func = self.__init__\n\n # check what parameters to add\n adds, params, kwargs = _helper_parameters(func=func, args=args, kwargs=kwargs,\n onlykeys=onlykeys, onlyused=onlyused)\n\n _map_parameters = getattr(self, \"_map_parameters\", None)\n for add, key in zip(adds, params):\n if add and key not in kwargs:\n try:\n if _map_parameters is not None and key in _map_parameters:\n mapped_key = _map_parameters[key]\n # if mapped_key is None then it means variable is not\n # assigned in the __init__ of the instance so ignore it\n if mapped_key is not None:\n kwargs[key] = getattr(self, mapped_key)\n else:\n kwargs[key] = getattr(self, key)\n except AttributeError:\n e, msg, traceback = sys.exc_info()\n msg.args = (\n msg.args[0] + \". Review @copy_support decorator or \"\n \"BaseCopySupporter class for more info.\",)\n raise_(e, msg, traceback)\n\n if onlykeys:\n return kwargs\n return args, kwargs","def __parse_function_args(self, buffer):\n\t\targs = []\n\t\ttoken = buffer.read(1)\n\t\twhile token != \"(\": # FIXME don't duplicate code with __read_block\n\t\t\ttoken = buffer.read(1)\n\t\t\tassert token\n\t\tcount = 1\n\t\t\n\t\tdef flusharg(arg, args):\n\t\t\targ = \"\".join(arg)\n\t\t\targ = SpellString(arg).format(self.obj, proxy=self.proxy)\n\t\t\targs.append(arg)\n\t\t\treturn []\n\t\t\n\t\t_arg = []\n\t\twhile count:\n\t\t\ttoken = buffer.read(1)\n\t\t\tif token == \"(\":\n\t\t\t\tcount += 1\n\t\t\telif token == \")\":\n\t\t\t\tcount -= 1\n\t\t\tif not count or not token:\n\t\t\t\t_arg = flusharg(_arg, args)\n\t\t\t\tbreak\n\t\t\t\n\t\t\tif token == \",\" and count == 1:\n\t\t\t\t_arg = flusharg(_arg, args)\n\t\t\t\tcontinue\n\t\t\t\n\t\t\t_arg.append(token)\n\t\t\n\t\treturn args","def fetch_arguments(op_def, arg, ws):\n return [fetch_argument(op_def, desc, ws) for desc in arg.strings]","def unpack_args(kwargs):\n return [v for p in zip(list(kwargs.keys()), list(kwargs.values())) for v in p]","def get_all_arguments(self):\n args, varargs, keyword, defaults = inspect.getargspec(self.exec_obj)\n if args.count('self') > 0:\n args.remove('self')\n return args","def args_extract(self, args, kwargs):\n # make popable (can't pop tuple of args)\n args = list(args)\n\n def getarg(name, num):\n if args and len(args) > num:\n return args.pop(num)\n elif kwargs.get('files'):\n return kwargs.pop('files')\n return None\n\n # First to not affect data = args.pop(0)\n files = getarg('files', 1)\n data = getarg('data', 0)\n\n # make mutable if something\n if files:\n files = MultiValueDict(files)\n if data:\n data = MultiValueDict(data)\n\n return data, files, args, kwargs","def log_kwargs(wrapped: Callable):\n\n @functools.wraps(wrapped)\n def wrapper(*args, **kwargs):\n logger.debug(f\"Keyword arguments: {kwargs}\")\n return wrapped(*args, **kwargs)\n\n return wrapper","def positional_args(func):\n def inner(s, parser, *args, **kwargs):\n clargs = parser.run()\n return func(s, clargs.posn, *args, **kwargs)\n \n if (func.__doc__ != None): inner.__doc__=func.__doc__+\"\\n\\n[decorated by @positional_arguments]\\n\"\n inner.__name__=func.__name__\n return inner","def build_arg_list(fn, env):\r\n kw = {}\r\n argspec = inspect.getargspec(fn)\r\n\r\n # if there is a **kw argument in the fn definition,\r\n # just pass along the environment\r\n if argspec[2]:\r\n kw = env\r\n #else for each entry in the arglist set the value from the environment\r\n else:\r\n #skip self\r\n argnames = argspec[0][1:]\r\n for name in argnames:\r\n if name in env:\r\n kw[name] = env[name]\r\n return kw","def get_args( self, **kwargs ):\n args = []\n for at in self.arg_types:\n args.append( kwargs[at] )\n return args","def get_args(inst):\n if is_estimator(inst):\n args = inspect.getargspec(inst.update).args\n args = [arg for arg in args if arg != 'self' and arg != 'X']\n else:\n args = inspect.getargspec(inst).args\n ignore_args = {'self', 'X', 'y', 'pattern', 'normalizer', 'coef'}\n args = [arg for arg in args if arg not in ignore_args]\n\n return args","def get_kwd_args(func):\n try:\n sig = inspect.signature(func)\n except AttributeError:\n args, _, _, defaults = inspect.getargspec(func)\n if defaults:\n kwonlyargs = args[-len(defaults):]\n else:\n kwonlyargs = []\n else:\n kwonlyargs = {p.name:p.default for p in sig.parameters.values()\n if p.default is not p.empty}\n\n return kwonlyargs","def arguments(self):\n return parse_arguments(self['data'])","def filter_kwargs(function, **kwargs):\n\n kwargs = deepcopy(kwargs)\n if sys.version_info[0] >= 3:\n args = function.__code__.co_varnames\n else:\n args = function.func_code.co_varnames\n\n args = set(kwargs.keys()) - set(args)\n for key in args:\n kwargs.pop(key)\n\n return kwargs","def log_arguments(f):\n\n if hasattr(f, '__qualname__'):\n name = f.__qualname__\n else:\n name = f.__name__\n @functools.wraps(f)\n def log_arguments_wrapper(*args, **kwargs):\n if name.endswith('__init__'):\n assert len(args) >= 1\n args_str = ', '.join(map(str, args[1:]))\n else:\n args_str = ', '.join(map(str, args))\n kwargs_str = ', '.join([f'{k} = {v}' for k, v in kwargs.items()])\n args_kwargs_str = ', '.join([s for s in [args_str, kwargs_str] if s])\n _logger.info(f'{name}({args_kwargs_str})')\n result = f(*args, **kwargs)\n return result\n return log_arguments_wrapper","def getargspec(func):\n if isinstance(func, partial):\n return inspect.getargspec(func.func)\n else:\n if isinstance(func, type):\n return inspect.getargspec(func.__init__)\n else:\n return inspect.getargspec(func)","def filter_extra_accepted_kwargs(fun, kwargs, skip_positional=0):\n sig = inspect.signature(fun)\n # the params from signature with up to skip_positional filtered out\n # (less only if there is not enough of positional args)\n params = [(name, param) for i, (name, param) in enumerate(sig.parameters.items())\n if i >= skip_positional or param.kind not in\n [inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.POSITIONAL_ONLY]]\n extra = [\n name for (name, param) in params\n if param.kind in [inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY]\n ]\n return {name: value for name, value in kwargs.items() if name in extra}","def extract_keywords(func):\n if hasattr(func, 'im_func'):\n func = func.im_func\n\n try:\n return func.func_code.co_varnames[-len(func.func_defaults):]\n except (TypeError, ValueError, IndexError):\n return tuple()","def get_partial_arguments(self):\n return (), {}","def get_kwargs():\n\treturn get_kwargs_raw(sys.argv)","def get_args(self):\r\n return self.args","def selectArgsFromDict(func, argdict):\n return dict([(i, argdict[i]) for i in getArgs(func) if i in argdict])","def get_args(self, action):\n\n def args_function(wildcards):\n return {\n \"input\": self._collect_bams(wildcards, wildcards.library_name),\n \"sample_name\": wildcards.library_name,\n \"platform\": \"EXTERNAL\",\n }\n\n assert action == \"run\", \"Unsupported actions\"\n return args_function","def get_args(self, action):\n\n def args_function(wildcards):\n result = {\n \"input\": {\n \"reads_left\": list(\n sorted(self._collect_reads(wildcards, wildcards.library_name, \"\"))\n )\n },\n \"sample_name\": wildcards.library_name,\n \"platform\": \"ILLUMINA\",\n }\n reads_right = list(\n sorted(self._collect_reads(wildcards, wildcards.library_name, \"right-\"))\n )\n if reads_right:\n result[\"input\"][\"reads_right\"] = reads_right\n return result\n\n assert action == \"run\", \"Unsupported actions\"\n return args_function","def getArgument(self, *args):\n return _libsbml.FunctionDefinition_getArgument(self, *args)","def _create_argument_generator(func: PredictorMethod) -> PredictorArgumentGenerator:\n return _InjectedParams.from_func(func).make_arguments","def get_filter_kwargs(self, *_, **__) -> Dict[str, Any]:","def parse_args():\n parser = argparse.ArgumentParser( description='Required: function-name.' )\n parser.add_argument( '--function', '-f', help='function name required', required=True )\n args_dict = vars( parser.parse_args() )\n return args_dict","def get_x_args_dict(self):\n return self.__x_args","def _get_context(argspec, kwargs):\n if argspec.has_kwargs:\n return kwargs\n return dict((arg, kwargs[arg]) for arg in argspec.args if arg in kwargs)","def arguments(args_to_pop=None) :\n posname, kwname, args = inspect.getargvalues(inspect.stack()[1][0])[-3:]\n posargs = args.pop(posname, [])\n args.update(args.pop(kwname, []))\n if args_to_pop is not None :\n for arg in args_to_pop :\n args.pop(arg)\n return args, posargs","def good_decorator_accepting_args(decorator): \n def new_decorator(*f, **k):\n g = decorator(*f, **k)\n if 1 == len(f) and isinstance(f[0], types.FunctionType):\n g.__name__ = f[0].__name__\n g.__doc__ = f[0].__doc__\n g.__dict__.update(f[0].__dict__)\n pass\n return g\n \n new_decorator.__name__ = decorator.__name__\n new_decorator.__doc__ = decorator.__doc__\n new_decorator.__dict__.update(decorator.__dict__)\n # Required for Sphinx' automodule.\n new_decorator.__module__ = decorator.__module__\n return new_decorator","def get_required_kwargs(fun, skip_positional=0):\n sig = inspect.signature(fun)\n # the params from signature with up to skip_positional filtered out\n # (less only if there is not enough of positional args)\n params = [(name, param) for i, (name, param) in enumerate(sig.parameters.items())\n if i >= skip_positional or param.kind not in\n [inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.POSITIONAL_ONLY]]\n return [\n name for name, param in params if param.default is inspect.Parameter.empty\n and param.kind in [inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY]\n ]","def get_id_args(func, arg):\n\n return \"{} {}\".format(func.__name__, arg)","def set_func_args(self, *args, **kwargs):\n self._func_args = args \n self._func_kw_args = kwargs","def get_args(self):\n rqst = self.request\n args = rqst.arguments()\n resp = {}\n for arg in args:\n resp[arg] = repr(rqst.get_all(arg))\n return resp","def register_args(op_type, args_getter=None):\n def decorated(inner_function):\n return OpSchema.register_args(op_type, inner_function)\n if args_getter is not None:\n return OpSchema.register_args(op_type, args_getter)\n return decorated","def _get_reproducing_arguments(self):\n reproducing_arguments = {\n 'include': self.include,\n 'exclude': self.exclude,\n 'copy': self.copy,\n }\n args_names = {name: getattr(self, name) for name in self.args_names}\n reproducing_arguments.update(args_names)\n return reproducing_arguments","def filter_args(func, keys):\n filtered = {}\n sign = list(signature(func).parameters.keys())\n for k, v in {**keys}.items():\n if k in sign:\n filtered[k] = v\n return filtered","def _get_mock_args(node):\n args = []\n PREFIX_LENGTH = len(\"mock_\")\n\n for arg in node.args.args:\n name = getattr(arg, \"id\", getattr(arg, \"arg\", None))\n if not name.startswith(\"mock_\"):\n continue\n args.append(name[PREFIX_LENGTH:])\n\n return args","def inspect_arg(node):\n return inspect_ann(node)","def decorator(arg):\n return lambda: list(arg)","def get_Callable_args_res(clb):\n try:\n return clb.__args__, clb.__result__\n except AttributeError:\n # Python 3.6\n return clb.__args__[:-1], clb.__args__[-1]","def wrapper_fun(*args):\n print(\"Hello Decorator\")\n return fun(*args)","def get_additional_hook_arguments(\n self,\n path_manager: PathManager,\n extra_arguments: Optional[Dict[str, str]] = None,\n ) -> List[str]:","def getPositionalArgs():","def _handle_func_args(func, *args, **kwargs):\n if not isinstance(func, (types.FunctionType, types.MethodType)):\n raise RuntimeError('fn {} is not function or method'.format(func))\n if kwargs:\n bound_arguments = inspect.signature(func).bind(*args, **kwargs)\n bound_arguments.apply_defaults()\n args = bound_arguments.args\n kwargs = bound_arguments.kwargs\n\n positional_args = 0\n default_args = 0\n has_var = False\n for value in inspect.signature(func).parameters.values():\n if value.kind is inspect.Parameter.VAR_POSITIONAL or value.kind is inspect.Parameter.VAR_KEYWORD:\n has_var = True\n if value.kind is inspect.Parameter.POSITIONAL_OR_KEYWORD:\n if value.default is inspect.Parameter.empty:\n positional_args += 1\n else:\n default_args += 1\n\n if has_var:\n return args, kwargs\n\n if len(args) < positional_args:\n raise TypeError(f\"Function {func.__name__} needs {positional_args} positional argument, but got {len(args)}.\")\n if len(args) > positional_args + default_args:\n raise TypeError(f\"Function {func.__name__} needs {positional_args} positional argument and {default_args} \"\n f\"default argument, total {positional_args + default_args}, but got {len(args)}.\")\n return args, kwargs","def expand(self) -> List[TOKEN]:\n return [self.function, *self.args]","def format_args(self, **kwargs: Any) -> str:\n decl = self.declaration\n\n # The logic allows this to be used for both function like and non\n # function like macros.\n # 'SOME_DEFINE'.partition('(')\n # >>> 'SOME_DEFINE', '', ''\n #\n # 'FUNCTION_LIKE(_a, _b)'.partition('(')\n # >>> 'FUNCTION_LIKE', '(', '_a, _b)'\n _, part, args = decl.partition(\"(\")\n return part + args","def format_arguments(self, **kwargs):\n return kwargs","def _convert_args(self, expr, args, kwargs):\n assert expr is not None\n\n if not kwargs:\n return args\n\n if kwargs and not isinstance(expr, Function):\n raise Exception(\"can only supply keyword parameters for a \"\n \"relay.Function, found {0}\".format(expr))\n\n params = expr.params\n param_names = [p.name_hint for p in params]\n num_of_args = len(args)\n\n cargs = list(args)[:]\n for i, name in enumerate(param_names):\n if i < num_of_args:\n if kwargs.get(name):\n raise Exception(\n \"duplicate argument supplied in \"\n \"both positional args (at position: {0}), \"\n \"and keyword argument (with name: {1})\".format(i, name))\n else:\n cargs.append(kwargs[name])\n\n if len(cargs) != len(params):\n raise Exception(\n \"insufficient arguments, expected \"\n \"{0}, provided {1}\".format(len(cargs), len(params)))\n\n return tuple(cargs)","def as_kwargs(self) -> Dict[str, Any]:\n ret = {}\n for arg in self.args.values():\n ret[arg.name] = arg.value\n return ret","def extend_with_args(f):\n @wraps(f)\n def wrapper(*args, **kwargs):\n if request.get_json():\n kwargs.update(request.get_json())\n\n # WARNING: This may get us into trouble when it comes to\n # list-style \"get\" args.\n kwargs.update({k: v for k, v in request.args.iteritems()})\n\n # \"auth\" is special -- it's an authentication token, not an\n # argument.\n if \"auth\" in kwargs:\n kwargs.pop(\"auth\")\n\n # This is JUST for the 1.0 sidebar app.\n if \"access_token\" in kwargs:\n kwargs.pop(\"access_token\")\n\n return f(*args, **kwargs)\n return wrapper","def filter_kwargs(dict_to_filter, function_to_call):\n\n sig = inspect.signature(function_to_call)\n filter_keys = [param.name for param in sig.parameters.values() if (param.kind == param.POSITIONAL_OR_KEYWORD)]\n valid_args = {}\n invalid_args = {}\n\n for key in dict_to_filter:\n if key in filter_keys:\n valid_args[key] = dict_to_filter[key]\n else:\n invalid_args[key] = dict_to_filter[key]\n return valid_args, invalid_args","def get_json_argument_list():\n list_of_arguments_to_get = [\"finish_time\", \"segmentation_training_samples\", \"patch_count_per_image\", \"learning_rate\", \"batch_k\",\n \"batch_p\", \"flip_augment\", \"standardize\", \"margin\", \"metric\"]\n\n return list_of_arguments_to_get"],"string":"[\n \"def extract_captured_arguments(func):\\n captured_arguments = getattr(func, ATTR_NAME)\\n if type(captured_arguments) is not _CapturedArguments: # pylint: disable=unidiomatic-typecheck\\n # The attribute was not set by tcm, so effectively it does not exist.\\n raise AttributeError\\n delattr(func, ATTR_NAME)\\n return captured_arguments\",\n \"def _extract_args(self, func):\\n sig = inspect.signature(func)\\n\\n # Backwards compatibility\\n if len(sig.parameters) == 1:\\n ((name, parameter),) = sig.parameters.items()\\n if (\\n parameter.kind is parameter.POSITIONAL_OR_KEYWORD\\n and parameter.annotation in (parameter.empty, argparse.Namespace)\\n ):\\n self._require_namespace = name\\n return\\n\\n for name, parameter in sig.parameters.items():\\n if parameter.annotation is argparse.Namespace:\\n self._require_namespace = name\\n else:\\n arg = Argument.from_parameter(name, parameter)\\n action = arg.register_with_proxy(self)\\n self._args.append((name, action.dest))\",\n \"def inspect_args_func(frame):\\n args, _, _, values = inspect.getargvalues(frame)\\n return {key: values[key] for key in args if key != 'self'}\",\n \"def arguments(*args):\\n def decorate(func):\\n func.arguments = args\\n return func\\n return decorate\",\n \"def arguments_from_call_funccode(f):\\n fc = fc_or_c(f.__call__)\\n argcount = fc.co_argcount\\n args = list(fc.co_varnames[1:argcount])\\n if not args:\\n raise RuntimeError('Function has variable number of arguments')\\n return args\",\n \"def extract_args(*args: str, **kwargs) -> Optional[AttributeExtractor]:\\n def extract(values: Dict[str, any], fn) -> Dict[Attribute, any]:\\n out = {}\\n\\n for name in args:\\n if name not in values:\\n logging.warning(\\n f\\\"@trace decorator refers to an argument '{name}' that was not found in the \\\"\\n f\\\"signature for {fn.__qualname__}! (this attribute will not be added)\\\")\\n else:\\n out[Attribute(name, register=False)] = values[name]\\n\\n for name, value in kwargs.items():\\n if name not in values:\\n logging.warning(\\n f\\\"@trace decorator refers to an argument '{name}' that was not found in the \\\"\\n f\\\"signature for {fn.__qualname__}! (this attribute will not be added)\\\")\\n else:\\n if isinstance(value, Attribute):\\n out[value] = values[name]\\n elif isinstance(value, str):\\n out[Attribute(value, register=False)] = values[name]\\n elif value == Label:\\n out[Label(name, register=False)] = values[name]\\n elif value == Attribute:\\n out[Attribute(name, register=False)] = values[name]\\n else:\\n logging.warning(\\n f\\\"@trace decorator has invalid mapping for argument '{name}'. Expected one of Label, Attribute or str but got {type(value)}\\\")\\n return out\\n return extract\",\n \"def extractArguments(frame):\\n\\n\\targuments = ([], None, None)\\n\\ttry:\\n\\t\\tsource = textwrap.dedent(str().join(inspect.getsourcelines(frame)[0]).replace(\\\"\\\\\\\\\\\\n\\\", str()))\\n\\texcept (IOError, TypeError) as error:\\n\\t\\treturn arguments\\n\\n\\ttry:\\n\\t\\tnode = ast.parse(source)\\n\\texcept:\\n\\t\\treturn arguments\\n\\n\\tif not node.body:\\n\\t\\treturn arguments\\n\\n\\tnode = node.body[0]\\n\\tif not isinstance(node, ast.FunctionDef):\\n\\t\\treturn arguments\\n\\n\\treturn [arg.id for arg in node.args.args], node.args.vararg, node.args.kwarg\",\n \"def GetFunctionParametersAndValues():\\n frame = inspect.currentframe().f_back\\n args, _, _, values = inspect.getargvalues(frame)\\n return ([(i, values[i]) for i in args])\",\n \"def arguments_from_funccode(f):\\n fc = fc_or_c(f)\\n vnames = fc.co_varnames\\n nargs = fc.co_argcount\\n # bound method and fake function will be None\\n args = vnames[1 if is_bound(f) else 0:nargs]\\n if not args:\\n raise RuntimeError('Function has variable number of arguments')\\n return list(args)\",\n \"def get_input_arguments(kwargs, function, warn=True):\\n np.set_printoptions(threshold=20)\\n print('\\\\narguments to {}:'.format(function.__qualname__))\\n params = inspect.signature(function)\\n input_kwargs = {}\\n not_arguments = {}\\n for k, v in kwargs.items():\\n if k in params.parameters:\\n input_kwargs[k] = v\\n print_item(k, v)\\n else:\\n not_arguments[k] = v\\n if warn:\\n print('\\\\nother arguments:')\\n for k, v in not_arguments.items():\\n #print('{}: {}'.format(k, v))\\n print_item(k, v)\\n print('\\\\n')\\n return input_kwargs\",\n \"def get_input_arguments(kwargs, function, warn=True):\\n np.set_printoptions(threshold=20)\\n print('\\\\narguments to {}:'.format(function.__qualname__))\\n params = inspect.signature(function)\\n input_kwargs = {}\\n not_arguments = {}\\n for k, v in kwargs.items():\\n if k in params.parameters:\\n input_kwargs[k] = v\\n print_item(k, v)\\n else:\\n not_arguments[k] = v\\n if warn:\\n print('\\\\nother arguments:')\\n for k, v in not_arguments.items():\\n #print('{}: {}'.format(k, v))\\n print_item(k, v)\\n print('\\\\n')\\n return input_kwargs\",\n \"def as_args(function):\\n return lambda x: function(*x)\",\n \"def to_args(f, *args, **kwargs):\\n kwargs = to_kwargs(f, *args, **kwargs)\\n s = inspect.getargspec(f)\\n return [kwargs[a] for a in s.args]\",\n \"def get_python_function_arguments(f):\\n # Note that we only return non-optional arguments (we assume that any optional args are not specified).\\n # This allows to, e.g., accept max(a, b, *more, name='') as a binary function\\n param_specs = inspect.getfullargspec(f)\\n annotations = param_specs.annotations\\n arg_names = param_specs.args\\n defaults = param_specs.defaults # \\\"if this tuple has n elements, they correspond to the last n elements listed\\n # in args\\\"\\n if defaults:\\n arg_names = arg_names[:-len(defaults)]\\n return (arg_names, annotations)\",\n \"def derive_args(func):\\n args = inspect.getfullargspec(func).args\\n if args and is_selfish_name(args[0]):\\n del args[0]\\n return args\",\n \"def _get_args(function, varargs=False):\\n\\n try:\\n params = signature(function).parameters\\n except ValueError:\\n # Error on builtin C function\\n return []\\n args = [\\n key\\n for key, param in params.items()\\n if param.kind not in (param.VAR_POSITIONAL, param.VAR_KEYWORD)\\n ]\\n if varargs:\\n varargs = [\\n param.name\\n for param in params.values()\\n if param.kind == param.VAR_POSITIONAL\\n ]\\n if len(varargs) == 0:\\n varargs = None\\n return args, varargs\\n else:\\n return args\",\n \"def extract_function_metadata(wrapped, instance, args, kwargs, return_value):\\n LOGGER.debug(\\n \\\"Extracting function call metadata\\\", args=args, kwargs=kwargs,\\n )\\n return {\\n \\\"metadata\\\": {\\\"args\\\": args, \\\"kwargs\\\": kwargs},\\n }\",\n \"def list_kwargs(func):\\n \\n details = inspect.getargspec(func)\\n nopt = len(details.defaults)\\n \\n return details.args[-nopt:]\",\n \"def preprocess_arguments(self, *args, **kwargs):\\n return (args, kwargs)\",\n \"def func_args(self) -> str:\\n\\n return self.call_data[10:]\",\n \"def as_kwargs(function):\\n return lambda x: function(**x)\",\n \"def extract_arguments(args, method):\\n intersection = lambda list1, list2: [x for x in list1 if x in list2]\\n filterByKey = lambda keys, data: {x: data[x] for x in keys if x in data }\\n keys = intersection(signature(method).parameters.keys(), args.keys())\\n params = filterByKey(keys, args)\\n return params\",\n \"def extracts(*extract):\\n def decorate(func):\\n function = to_function(func)\\n setattr(function, EXTRACTS, extract)\\n return function\\n return decorate\",\n \"def dump_args(func):\\n\\n def wrapper(*args, **kwargs):\\n func_args = inspect.signature(func).bind(*args, **kwargs).arguments\\n func_args_str = ', '.join('{} = {!r}'.format(*item) for item in func_args.items())\\n log(f'{func.__module__}.{func.__qualname__} ( {func_args_str} )')\\n return func(*args, **kwargs)\\n\\n return wrapper\",\n \"def get_keyword_args(function):\\n argspec = inspect.getargspec(function)\\n kwargs = argspec.args[len(argspec.args) - len(argspec.defaults):]\\n kwargs = {arg: value for arg, value in zip(kwargs, argspec.defaults)}\\n return kwargs\",\n \"def dumpArgs(func):\\n def wrapper(*args, **kwargs):\\n func_args = inspect.signature(func).bind(*args, **kwargs).arguments\\n func_args_str = ', '.join('{} = {!r}'.format(*item)\\n for item in func_args.items())\\n print(f'{func.__module__}.{func.__qualname__} ( {func_args_str} )')\\n result = func(*args, **kwargs)\\n print(f'{func.__module__}.{func.__qualname__} Return Result: \\\\n {result}')\\n return result\\n return wrapper\",\n \"def test_arguments(self):\\n calls = []\\n decorator = self.decorator()\\n\\n @decorator\\n def func(a, b, c):\\n calls.append((a, b, c))\\n\\n func(1, 2, c=3)\\n self.assertEqual(calls, [(1, 2, 3)])\",\n \"def filter_function_arguments(self, fn_node):\\n return self.filter_nodes('Argument', parent=fn_node)\",\n \"def getargvalues(frame):\\r\\n args, varargs, varkw = getargs(frame.f_code)\\r\\n return ArgInfo(args, varargs, varkw, frame.f_locals)\",\n \"def kwargsdec(f):\\n def wrapper(**kwargs):\\n args = inspect.getargspec(f).args\\n return f(**{ k: kwargs[k] for k in args})\\n return wrapper\",\n \"def dump_args(func):\\n\\n def wrapper(*args, **kwargs):\\n func_args = inspect.signature(func).bind(*args, **kwargs).arguments\\n func_args_str = ', '.join('{} = {!r}'.format(*item) for item in func_args.items())\\n print(f'{func.__module__}.{func.__qualname__} ( {func_args_str} )')\\n return func(*args, **kwargs)\\n\\n return wrapper\",\n \"def getargspec(self,obj):\\n\\n if inspect.isfunction(obj):\\n func_obj = obj\\n elif inspect.ismethod(obj):\\n func_obj = obj.im_func\\n else:\\n raise TypeError, 'arg is not a Python function'\\n args, varargs, varkw = inspect.getargs(func_obj.func_code)\\n return args, varargs, varkw, func_obj.func_defaults\",\n \"def getFunctionArguments(tokens: List[LEX_Type], last_token: LEX_Type) -> (List[AST_FunctionArgument], List[LEX_Type]):\\n if tokens[0].type == \\\"LineEnd\\\":\\n if tokens[1].type == \\\"Keyword\\\":\\n return [], tokens\\n return getFunctionArguments(tokens[1:], last_token)\\n if tokens[0].type == \\\"ItemLister\\\":\\n if tokens[1].type == \\\"Type\\\":\\n if tokens[2].type == \\\"Identifier\\\":\\n arguments: List[AST_FunctionArgument]\\n last: List[LEX_Type]\\n arguments, last = getFunctionArguments(tokens[3:], last_token)\\n return [AST_FunctionArgument(tokens[1].value, tokens[2].value)] + arguments, last\",\n \"def filter_args(fn, args_tuple):\\n sig = inspect.signature(fn)\\n flag_var_positional = any([\\n inspect.Parameter.VAR_POSITIONAL == value.kind for\\n value in sig.parameters.values()])\\n if flag_var_positional:\\n return args_tuple\\n else:\\n num_args = len(sig.parameters.items())\\n return args_tuple[:num_args]\",\n \"def get_kwargs_applicable_to_function(function, kwargs):\\n return {\\n key: value\\n for key, value in kwargs.items()\\n if key in inspect.getfullargspec(function).args\\n }\",\n \"def request_args(args):\\n\\n def _decorator(fn):\\n fn.args = args\\n return fn\\n\\n return _decorator\",\n \"def create_args(func):\\n # Get a dictionary of the params of the function\\n params = dict(inspect.signature(func).parameters)\\n # We will always use z for the vector input so delete that from the dict\\n del params['z']\\n return {k: peturb(v) for k, v in params.items()}\",\n \"def getArgs(func):\\n # exclude the defaults at the end (hence the [:-1])\\n args = list(utils.flatten(inspect.getargspec(func)[:-1]))\\n return set(args).difference(set([None]))\",\n \"def params(funcarglist):\\n def wrapper(function):\\n function.funcarglist = funcarglist\\n return function\\n return wrapper\",\n \"def register_args(f):\\n\\n @wraps(f)\\n def inner(*_args, **_kwargs):\\n self = _args[0]\\n args, kwargs = args_kwargs(f)\\n args = dict(zip(args[1::], _args[1::]))\\n kwargs.update(_kwargs)\\n self.args = args\\n self.kwargs = kwargs\\n return f(self, *args.values(), **kwargs)\\n\\n return inner\",\n \"def get_fn_arg_contexts(cls, ctx: AntlrTelParser.FnContext) -> List[Any]:\\n if len(ctx.children) <= 3:\\n # [fn_name,(,)] => 3 children means no args, return empty array\\n return []\\n else:\\n # Skip fnname and '(', step 2 to skip ','\\n return ctx.children[2::2]\",\n \"def _get_required_args(func):\\n module_logger.debug(f\\\"_get_required_args: func={func}\\\")\\n fas = inspect.getfullargspec(func)\\n module_logger.debug(f\\\"_get_required_args: fas={fas}\\\")\\n len_args = len(fas.args)\\n len_args += len(fas.kwonlyargs)\\n if fas.kwonlydefaults is not None:\\n len_args -= len(fas.kwonlydefaults)\\n if fas.defaults is not None:\\n len_args -= len(fas.defaults)\\n return len_args\",\n \"def get_arguments(callable, exclude):\\n info = arginfo(callable)\\n defaults = info.defaults or []\\n defaults = [None] * (len(info.args) - len(defaults)) + list(defaults)\\n return {name: default for (name, default) in zip(info.args, defaults)\\n if name not in exclude}\",\n \"def _get_arguments(self) -> str:\\n func = self.node\\n\\n # Early logic used to iterate over, `func.get_arguments()`, however when there\\n # is an unknown type clang will sometimes fail to provide tokens for that\\n # argument. For example in \\\"unknown_type foo[]\\\" the brackets will cause clang\\n # to return back no tokens for the argument.\\n start = func.location\\n end = func.extent.end\\n if func.is_definition():\\n # When a function is a definition the last child is the compound statement\\n # so we need to move prior to the compound statement\\n children = list(func.get_children())\\n body_start = children[-1].extent.start.offset\\n end = cindex.SourceLocation.from_offset(func.tu, start.file, body_start - 1)\\n\\n extent = cindex.SourceRange.from_locations(start, end)\\n non_comment_tokens = (\\n t\\n for t in cindex.TokenGroup.get_tokens(func.tu, extent=extent)\\n if t.kind != cindex.TokenKind.COMMENT\\n )\\n\\n # Even though this will place spaces around all the tokens, the sphinx C domain\\n # will provide some formatting to make it look nicer in the final output.\\n full_signature = \\\" \\\".join(t.spelling for t in non_comment_tokens)\\n\\n _, _, arguments = full_signature.partition(\\\"(\\\")\\n arguments = arguments.rstrip(\\\")\\\")\\n arguments = arguments.strip()\\n\\n return arguments\",\n \"def _getargs(fn_sig):\\n params = fn_sig.parameters\\n args = []\\n for k, v in params.items():\\n if (v.kind & v.POSITIONAL_OR_KEYWORD) == v.POSITIONAL_OR_KEYWORD:\\n args.append(k)\\n else:\\n msg = \\\"%s argument type unsupported in jitclass\\\" % v.kind\\n raise errors.UnsupportedError(msg)\\n return args\",\n \"def print_args(func):\\n def new_func(*args, **kwargs):\\n print(args)\\n print(kwargs)\\n return func(*args, **kwargs)\\n return new_func\",\n \"def get_arguments(self, args=(), kwargs=None, onlykeys=False, onlyused=False,\\n func=None):\\n if func is None:\\n func = self.__init__\\n\\n # check what parameters to add\\n adds, params, kwargs = _helper_parameters(func=func, args=args, kwargs=kwargs,\\n onlykeys=onlykeys, onlyused=onlyused)\\n\\n _map_parameters = getattr(self, \\\"_map_parameters\\\", None)\\n for add, key in zip(adds, params):\\n if add and key not in kwargs:\\n try:\\n if _map_parameters is not None and key in _map_parameters:\\n mapped_key = _map_parameters[key]\\n # if mapped_key is None then it means variable is not\\n # assigned in the __init__ of the instance so ignore it\\n if mapped_key is not None:\\n kwargs[key] = getattr(self, mapped_key)\\n else:\\n kwargs[key] = getattr(self, key)\\n except AttributeError:\\n e, msg, traceback = sys.exc_info()\\n msg.args = (\\n msg.args[0] + \\\". Review @copy_support decorator or \\\"\\n \\\"BaseCopySupporter class for more info.\\\",)\\n raise_(e, msg, traceback)\\n\\n if onlykeys:\\n return kwargs\\n return args, kwargs\",\n \"def __parse_function_args(self, buffer):\\n\\t\\targs = []\\n\\t\\ttoken = buffer.read(1)\\n\\t\\twhile token != \\\"(\\\": # FIXME don't duplicate code with __read_block\\n\\t\\t\\ttoken = buffer.read(1)\\n\\t\\t\\tassert token\\n\\t\\tcount = 1\\n\\t\\t\\n\\t\\tdef flusharg(arg, args):\\n\\t\\t\\targ = \\\"\\\".join(arg)\\n\\t\\t\\targ = SpellString(arg).format(self.obj, proxy=self.proxy)\\n\\t\\t\\targs.append(arg)\\n\\t\\t\\treturn []\\n\\t\\t\\n\\t\\t_arg = []\\n\\t\\twhile count:\\n\\t\\t\\ttoken = buffer.read(1)\\n\\t\\t\\tif token == \\\"(\\\":\\n\\t\\t\\t\\tcount += 1\\n\\t\\t\\telif token == \\\")\\\":\\n\\t\\t\\t\\tcount -= 1\\n\\t\\t\\tif not count or not token:\\n\\t\\t\\t\\t_arg = flusharg(_arg, args)\\n\\t\\t\\t\\tbreak\\n\\t\\t\\t\\n\\t\\t\\tif token == \\\",\\\" and count == 1:\\n\\t\\t\\t\\t_arg = flusharg(_arg, args)\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\n\\t\\t\\t_arg.append(token)\\n\\t\\t\\n\\t\\treturn args\",\n \"def fetch_arguments(op_def, arg, ws):\\n return [fetch_argument(op_def, desc, ws) for desc in arg.strings]\",\n \"def unpack_args(kwargs):\\n return [v for p in zip(list(kwargs.keys()), list(kwargs.values())) for v in p]\",\n \"def get_all_arguments(self):\\n args, varargs, keyword, defaults = inspect.getargspec(self.exec_obj)\\n if args.count('self') > 0:\\n args.remove('self')\\n return args\",\n \"def args_extract(self, args, kwargs):\\n # make popable (can't pop tuple of args)\\n args = list(args)\\n\\n def getarg(name, num):\\n if args and len(args) > num:\\n return args.pop(num)\\n elif kwargs.get('files'):\\n return kwargs.pop('files')\\n return None\\n\\n # First to not affect data = args.pop(0)\\n files = getarg('files', 1)\\n data = getarg('data', 0)\\n\\n # make mutable if something\\n if files:\\n files = MultiValueDict(files)\\n if data:\\n data = MultiValueDict(data)\\n\\n return data, files, args, kwargs\",\n \"def log_kwargs(wrapped: Callable):\\n\\n @functools.wraps(wrapped)\\n def wrapper(*args, **kwargs):\\n logger.debug(f\\\"Keyword arguments: {kwargs}\\\")\\n return wrapped(*args, **kwargs)\\n\\n return wrapper\",\n \"def positional_args(func):\\n def inner(s, parser, *args, **kwargs):\\n clargs = parser.run()\\n return func(s, clargs.posn, *args, **kwargs)\\n \\n if (func.__doc__ != None): inner.__doc__=func.__doc__+\\\"\\\\n\\\\n[decorated by @positional_arguments]\\\\n\\\"\\n inner.__name__=func.__name__\\n return inner\",\n \"def build_arg_list(fn, env):\\r\\n kw = {}\\r\\n argspec = inspect.getargspec(fn)\\r\\n\\r\\n # if there is a **kw argument in the fn definition,\\r\\n # just pass along the environment\\r\\n if argspec[2]:\\r\\n kw = env\\r\\n #else for each entry in the arglist set the value from the environment\\r\\n else:\\r\\n #skip self\\r\\n argnames = argspec[0][1:]\\r\\n for name in argnames:\\r\\n if name in env:\\r\\n kw[name] = env[name]\\r\\n return kw\",\n \"def get_args( self, **kwargs ):\\n args = []\\n for at in self.arg_types:\\n args.append( kwargs[at] )\\n return args\",\n \"def get_args(inst):\\n if is_estimator(inst):\\n args = inspect.getargspec(inst.update).args\\n args = [arg for arg in args if arg != 'self' and arg != 'X']\\n else:\\n args = inspect.getargspec(inst).args\\n ignore_args = {'self', 'X', 'y', 'pattern', 'normalizer', 'coef'}\\n args = [arg for arg in args if arg not in ignore_args]\\n\\n return args\",\n \"def get_kwd_args(func):\\n try:\\n sig = inspect.signature(func)\\n except AttributeError:\\n args, _, _, defaults = inspect.getargspec(func)\\n if defaults:\\n kwonlyargs = args[-len(defaults):]\\n else:\\n kwonlyargs = []\\n else:\\n kwonlyargs = {p.name:p.default for p in sig.parameters.values()\\n if p.default is not p.empty}\\n\\n return kwonlyargs\",\n \"def arguments(self):\\n return parse_arguments(self['data'])\",\n \"def filter_kwargs(function, **kwargs):\\n\\n kwargs = deepcopy(kwargs)\\n if sys.version_info[0] >= 3:\\n args = function.__code__.co_varnames\\n else:\\n args = function.func_code.co_varnames\\n\\n args = set(kwargs.keys()) - set(args)\\n for key in args:\\n kwargs.pop(key)\\n\\n return kwargs\",\n \"def log_arguments(f):\\n\\n if hasattr(f, '__qualname__'):\\n name = f.__qualname__\\n else:\\n name = f.__name__\\n @functools.wraps(f)\\n def log_arguments_wrapper(*args, **kwargs):\\n if name.endswith('__init__'):\\n assert len(args) >= 1\\n args_str = ', '.join(map(str, args[1:]))\\n else:\\n args_str = ', '.join(map(str, args))\\n kwargs_str = ', '.join([f'{k} = {v}' for k, v in kwargs.items()])\\n args_kwargs_str = ', '.join([s for s in [args_str, kwargs_str] if s])\\n _logger.info(f'{name}({args_kwargs_str})')\\n result = f(*args, **kwargs)\\n return result\\n return log_arguments_wrapper\",\n \"def getargspec(func):\\n if isinstance(func, partial):\\n return inspect.getargspec(func.func)\\n else:\\n if isinstance(func, type):\\n return inspect.getargspec(func.__init__)\\n else:\\n return inspect.getargspec(func)\",\n \"def filter_extra_accepted_kwargs(fun, kwargs, skip_positional=0):\\n sig = inspect.signature(fun)\\n # the params from signature with up to skip_positional filtered out\\n # (less only if there is not enough of positional args)\\n params = [(name, param) for i, (name, param) in enumerate(sig.parameters.items())\\n if i >= skip_positional or param.kind not in\\n [inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.POSITIONAL_ONLY]]\\n extra = [\\n name for (name, param) in params\\n if param.kind in [inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY]\\n ]\\n return {name: value for name, value in kwargs.items() if name in extra}\",\n \"def extract_keywords(func):\\n if hasattr(func, 'im_func'):\\n func = func.im_func\\n\\n try:\\n return func.func_code.co_varnames[-len(func.func_defaults):]\\n except (TypeError, ValueError, IndexError):\\n return tuple()\",\n \"def get_partial_arguments(self):\\n return (), {}\",\n \"def get_kwargs():\\n\\treturn get_kwargs_raw(sys.argv)\",\n \"def get_args(self):\\r\\n return self.args\",\n \"def selectArgsFromDict(func, argdict):\\n return dict([(i, argdict[i]) for i in getArgs(func) if i in argdict])\",\n \"def get_args(self, action):\\n\\n def args_function(wildcards):\\n return {\\n \\\"input\\\": self._collect_bams(wildcards, wildcards.library_name),\\n \\\"sample_name\\\": wildcards.library_name,\\n \\\"platform\\\": \\\"EXTERNAL\\\",\\n }\\n\\n assert action == \\\"run\\\", \\\"Unsupported actions\\\"\\n return args_function\",\n \"def get_args(self, action):\\n\\n def args_function(wildcards):\\n result = {\\n \\\"input\\\": {\\n \\\"reads_left\\\": list(\\n sorted(self._collect_reads(wildcards, wildcards.library_name, \\\"\\\"))\\n )\\n },\\n \\\"sample_name\\\": wildcards.library_name,\\n \\\"platform\\\": \\\"ILLUMINA\\\",\\n }\\n reads_right = list(\\n sorted(self._collect_reads(wildcards, wildcards.library_name, \\\"right-\\\"))\\n )\\n if reads_right:\\n result[\\\"input\\\"][\\\"reads_right\\\"] = reads_right\\n return result\\n\\n assert action == \\\"run\\\", \\\"Unsupported actions\\\"\\n return args_function\",\n \"def getArgument(self, *args):\\n return _libsbml.FunctionDefinition_getArgument(self, *args)\",\n \"def _create_argument_generator(func: PredictorMethod) -> PredictorArgumentGenerator:\\n return _InjectedParams.from_func(func).make_arguments\",\n \"def get_filter_kwargs(self, *_, **__) -> Dict[str, Any]:\",\n \"def parse_args():\\n parser = argparse.ArgumentParser( description='Required: function-name.' )\\n parser.add_argument( '--function', '-f', help='function name required', required=True )\\n args_dict = vars( parser.parse_args() )\\n return args_dict\",\n \"def get_x_args_dict(self):\\n return self.__x_args\",\n \"def _get_context(argspec, kwargs):\\n if argspec.has_kwargs:\\n return kwargs\\n return dict((arg, kwargs[arg]) for arg in argspec.args if arg in kwargs)\",\n \"def arguments(args_to_pop=None) :\\n posname, kwname, args = inspect.getargvalues(inspect.stack()[1][0])[-3:]\\n posargs = args.pop(posname, [])\\n args.update(args.pop(kwname, []))\\n if args_to_pop is not None :\\n for arg in args_to_pop :\\n args.pop(arg)\\n return args, posargs\",\n \"def good_decorator_accepting_args(decorator): \\n def new_decorator(*f, **k):\\n g = decorator(*f, **k)\\n if 1 == len(f) and isinstance(f[0], types.FunctionType):\\n g.__name__ = f[0].__name__\\n g.__doc__ = f[0].__doc__\\n g.__dict__.update(f[0].__dict__)\\n pass\\n return g\\n \\n new_decorator.__name__ = decorator.__name__\\n new_decorator.__doc__ = decorator.__doc__\\n new_decorator.__dict__.update(decorator.__dict__)\\n # Required for Sphinx' automodule.\\n new_decorator.__module__ = decorator.__module__\\n return new_decorator\",\n \"def get_required_kwargs(fun, skip_positional=0):\\n sig = inspect.signature(fun)\\n # the params from signature with up to skip_positional filtered out\\n # (less only if there is not enough of positional args)\\n params = [(name, param) for i, (name, param) in enumerate(sig.parameters.items())\\n if i >= skip_positional or param.kind not in\\n [inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.POSITIONAL_ONLY]]\\n return [\\n name for name, param in params if param.default is inspect.Parameter.empty\\n and param.kind in [inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY]\\n ]\",\n \"def get_id_args(func, arg):\\n\\n return \\\"{} {}\\\".format(func.__name__, arg)\",\n \"def set_func_args(self, *args, **kwargs):\\n self._func_args = args \\n self._func_kw_args = kwargs\",\n \"def get_args(self):\\n rqst = self.request\\n args = rqst.arguments()\\n resp = {}\\n for arg in args:\\n resp[arg] = repr(rqst.get_all(arg))\\n return resp\",\n \"def register_args(op_type, args_getter=None):\\n def decorated(inner_function):\\n return OpSchema.register_args(op_type, inner_function)\\n if args_getter is not None:\\n return OpSchema.register_args(op_type, args_getter)\\n return decorated\",\n \"def _get_reproducing_arguments(self):\\n reproducing_arguments = {\\n 'include': self.include,\\n 'exclude': self.exclude,\\n 'copy': self.copy,\\n }\\n args_names = {name: getattr(self, name) for name in self.args_names}\\n reproducing_arguments.update(args_names)\\n return reproducing_arguments\",\n \"def filter_args(func, keys):\\n filtered = {}\\n sign = list(signature(func).parameters.keys())\\n for k, v in {**keys}.items():\\n if k in sign:\\n filtered[k] = v\\n return filtered\",\n \"def _get_mock_args(node):\\n args = []\\n PREFIX_LENGTH = len(\\\"mock_\\\")\\n\\n for arg in node.args.args:\\n name = getattr(arg, \\\"id\\\", getattr(arg, \\\"arg\\\", None))\\n if not name.startswith(\\\"mock_\\\"):\\n continue\\n args.append(name[PREFIX_LENGTH:])\\n\\n return args\",\n \"def inspect_arg(node):\\n return inspect_ann(node)\",\n \"def decorator(arg):\\n return lambda: list(arg)\",\n \"def get_Callable_args_res(clb):\\n try:\\n return clb.__args__, clb.__result__\\n except AttributeError:\\n # Python 3.6\\n return clb.__args__[:-1], clb.__args__[-1]\",\n \"def wrapper_fun(*args):\\n print(\\\"Hello Decorator\\\")\\n return fun(*args)\",\n \"def get_additional_hook_arguments(\\n self,\\n path_manager: PathManager,\\n extra_arguments: Optional[Dict[str, str]] = None,\\n ) -> List[str]:\",\n \"def getPositionalArgs():\",\n \"def _handle_func_args(func, *args, **kwargs):\\n if not isinstance(func, (types.FunctionType, types.MethodType)):\\n raise RuntimeError('fn {} is not function or method'.format(func))\\n if kwargs:\\n bound_arguments = inspect.signature(func).bind(*args, **kwargs)\\n bound_arguments.apply_defaults()\\n args = bound_arguments.args\\n kwargs = bound_arguments.kwargs\\n\\n positional_args = 0\\n default_args = 0\\n has_var = False\\n for value in inspect.signature(func).parameters.values():\\n if value.kind is inspect.Parameter.VAR_POSITIONAL or value.kind is inspect.Parameter.VAR_KEYWORD:\\n has_var = True\\n if value.kind is inspect.Parameter.POSITIONAL_OR_KEYWORD:\\n if value.default is inspect.Parameter.empty:\\n positional_args += 1\\n else:\\n default_args += 1\\n\\n if has_var:\\n return args, kwargs\\n\\n if len(args) < positional_args:\\n raise TypeError(f\\\"Function {func.__name__} needs {positional_args} positional argument, but got {len(args)}.\\\")\\n if len(args) > positional_args + default_args:\\n raise TypeError(f\\\"Function {func.__name__} needs {positional_args} positional argument and {default_args} \\\"\\n f\\\"default argument, total {positional_args + default_args}, but got {len(args)}.\\\")\\n return args, kwargs\",\n \"def expand(self) -> List[TOKEN]:\\n return [self.function, *self.args]\",\n \"def format_args(self, **kwargs: Any) -> str:\\n decl = self.declaration\\n\\n # The logic allows this to be used for both function like and non\\n # function like macros.\\n # 'SOME_DEFINE'.partition('(')\\n # >>> 'SOME_DEFINE', '', ''\\n #\\n # 'FUNCTION_LIKE(_a, _b)'.partition('(')\\n # >>> 'FUNCTION_LIKE', '(', '_a, _b)'\\n _, part, args = decl.partition(\\\"(\\\")\\n return part + args\",\n \"def format_arguments(self, **kwargs):\\n return kwargs\",\n \"def _convert_args(self, expr, args, kwargs):\\n assert expr is not None\\n\\n if not kwargs:\\n return args\\n\\n if kwargs and not isinstance(expr, Function):\\n raise Exception(\\\"can only supply keyword parameters for a \\\"\\n \\\"relay.Function, found {0}\\\".format(expr))\\n\\n params = expr.params\\n param_names = [p.name_hint for p in params]\\n num_of_args = len(args)\\n\\n cargs = list(args)[:]\\n for i, name in enumerate(param_names):\\n if i < num_of_args:\\n if kwargs.get(name):\\n raise Exception(\\n \\\"duplicate argument supplied in \\\"\\n \\\"both positional args (at position: {0}), \\\"\\n \\\"and keyword argument (with name: {1})\\\".format(i, name))\\n else:\\n cargs.append(kwargs[name])\\n\\n if len(cargs) != len(params):\\n raise Exception(\\n \\\"insufficient arguments, expected \\\"\\n \\\"{0}, provided {1}\\\".format(len(cargs), len(params)))\\n\\n return tuple(cargs)\",\n \"def as_kwargs(self) -> Dict[str, Any]:\\n ret = {}\\n for arg in self.args.values():\\n ret[arg.name] = arg.value\\n return ret\",\n \"def extend_with_args(f):\\n @wraps(f)\\n def wrapper(*args, **kwargs):\\n if request.get_json():\\n kwargs.update(request.get_json())\\n\\n # WARNING: This may get us into trouble when it comes to\\n # list-style \\\"get\\\" args.\\n kwargs.update({k: v for k, v in request.args.iteritems()})\\n\\n # \\\"auth\\\" is special -- it's an authentication token, not an\\n # argument.\\n if \\\"auth\\\" in kwargs:\\n kwargs.pop(\\\"auth\\\")\\n\\n # This is JUST for the 1.0 sidebar app.\\n if \\\"access_token\\\" in kwargs:\\n kwargs.pop(\\\"access_token\\\")\\n\\n return f(*args, **kwargs)\\n return wrapper\",\n \"def filter_kwargs(dict_to_filter, function_to_call):\\n\\n sig = inspect.signature(function_to_call)\\n filter_keys = [param.name for param in sig.parameters.values() if (param.kind == param.POSITIONAL_OR_KEYWORD)]\\n valid_args = {}\\n invalid_args = {}\\n\\n for key in dict_to_filter:\\n if key in filter_keys:\\n valid_args[key] = dict_to_filter[key]\\n else:\\n invalid_args[key] = dict_to_filter[key]\\n return valid_args, invalid_args\",\n \"def get_json_argument_list():\\n list_of_arguments_to_get = [\\\"finish_time\\\", \\\"segmentation_training_samples\\\", \\\"patch_count_per_image\\\", \\\"learning_rate\\\", \\\"batch_k\\\",\\n \\\"batch_p\\\", \\\"flip_augment\\\", \\\"standardize\\\", \\\"margin\\\", \\\"metric\\\"]\\n\\n return list_of_arguments_to_get\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73196673","0.72977483","0.70101774","0.69297165","0.67886466","0.6777163","0.66621184","0.66599494","0.6646892","0.6559392","0.6559392","0.6526404","0.6525048","0.6484637","0.6477483","0.63901955","0.6309247","0.6304008","0.6285241","0.6279031","0.62567276","0.621607","0.62098473","0.62020326","0.61953586","0.61158305","0.6105116","0.6095368","0.6094999","0.6067567","0.6049048","0.60332817","0.6026479","0.6019232","0.6018263","0.6003445","0.5995536","0.5985236","0.5939428","0.5934477","0.59226364","0.59124327","0.588432","0.5875205","0.5873027","0.5867631","0.5810621","0.57894284","0.5778229","0.5766073","0.5724669","0.5719134","0.5718195","0.5716646","0.5683957","0.56715655","0.56572706","0.56542236","0.56482315","0.56428885","0.56397045","0.56241876","0.56067866","0.56052744","0.55989003","0.5596854","0.557872","0.55626893","0.5544393","0.55346817","0.55298376","0.552657","0.5524341","0.5523359","0.5521927","0.55144507","0.5509959","0.5504894","0.550289","0.5495836","0.5484896","0.54782164","0.54756504","0.54729974","0.5463715","0.54617685","0.54606265","0.54422706","0.5442181","0.54380006","0.5437035","0.5433753","0.5416578","0.54160243","0.541252","0.54091555","0.540913","0.5403992","0.5402226","0.53892833","0.53885156"],"string":"[\n \"0.73196673\",\n \"0.72977483\",\n \"0.70101774\",\n \"0.69297165\",\n \"0.67886466\",\n \"0.6777163\",\n \"0.66621184\",\n \"0.66599494\",\n \"0.6646892\",\n \"0.6559392\",\n \"0.6559392\",\n \"0.6526404\",\n \"0.6525048\",\n \"0.6484637\",\n \"0.6477483\",\n \"0.63901955\",\n \"0.6309247\",\n \"0.6304008\",\n \"0.6285241\",\n \"0.6279031\",\n \"0.62567276\",\n \"0.621607\",\n \"0.62098473\",\n \"0.62020326\",\n \"0.61953586\",\n \"0.61158305\",\n \"0.6105116\",\n \"0.6095368\",\n \"0.6094999\",\n \"0.6067567\",\n \"0.6049048\",\n \"0.60332817\",\n \"0.6026479\",\n \"0.6019232\",\n \"0.6018263\",\n \"0.6003445\",\n \"0.5995536\",\n \"0.5985236\",\n \"0.5939428\",\n \"0.5934477\",\n \"0.59226364\",\n \"0.59124327\",\n \"0.588432\",\n \"0.5875205\",\n \"0.5873027\",\n \"0.5867631\",\n \"0.5810621\",\n \"0.57894284\",\n \"0.5778229\",\n \"0.5766073\",\n \"0.5724669\",\n \"0.5719134\",\n \"0.5718195\",\n \"0.5716646\",\n \"0.5683957\",\n \"0.56715655\",\n \"0.56572706\",\n \"0.56542236\",\n \"0.56482315\",\n \"0.56428885\",\n \"0.56397045\",\n \"0.56241876\",\n \"0.56067866\",\n \"0.56052744\",\n \"0.55989003\",\n \"0.5596854\",\n \"0.557872\",\n \"0.55626893\",\n \"0.5544393\",\n \"0.55346817\",\n \"0.55298376\",\n \"0.552657\",\n \"0.5524341\",\n \"0.5523359\",\n \"0.5521927\",\n \"0.55144507\",\n \"0.5509959\",\n \"0.5504894\",\n \"0.550289\",\n \"0.5495836\",\n \"0.5484896\",\n \"0.54782164\",\n \"0.54756504\",\n \"0.54729974\",\n \"0.5463715\",\n \"0.54617685\",\n \"0.54606265\",\n \"0.54422706\",\n \"0.5442181\",\n \"0.54380006\",\n \"0.5437035\",\n \"0.5433753\",\n \"0.5416578\",\n \"0.54160243\",\n \"0.541252\",\n \"0.54091555\",\n \"0.540913\",\n \"0.5403992\",\n \"0.5402226\",\n \"0.53892833\",\n \"0.53885156\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":9093,"cells":{"query":{"kind":"string","value":"Validates and assigns the outputs to the output_dict."},"document":{"kind":"string","value":"def _assign_returned_values(\n function,\n outputs: Dict[str, Any],\n returned_values: Dict[str, Any],\n output_dict: Dict[str, List[tfx_types.Artifact]],\n json_typehints: Dict[str, Type], # pylint: disable=g-bare-generic\n) -> Dict[str, List[tfx_types.Artifact]]:\n result = copy.deepcopy(output_dict)\n if not isinstance(outputs, dict):\n raise ValueError(\n ('Expected component executor function %s to return a dict of '\n 'outputs (got %r instead).') % (function, outputs))\n\n # Assign returned ValueArtifact values.\n for name, is_optional in returned_values.items():\n if name not in outputs:\n raise ValueError(\n 'Did not receive expected output %r as return value from '\n 'component executor function %s.' % (name, function))\n if not is_optional and outputs[name] is None:\n raise ValueError('Non-nullable output %r received None return value from '\n 'component executor function %s.' % (name, function))\n try:\n result[name][0].value = outputs[name]\n except TypeError as e:\n raise TypeError(\n ('Return value %r for output %r is incompatible with output type '\n '%r.') %\n (outputs[name], name, result[name][0].__class__)) from e\n # Handle JsonValue runtime type check.\n if name in json_typehints:\n ret = function_parser.check_strict_json_compat(outputs[name],\n json_typehints[name])\n if not ret:\n raise TypeError(\n ('Return value %r for output %r is incompatible with output type '\n '%r.') % (outputs[name], name, json_typehints[name]))\n return result"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _get_output_dictionary(self):\n\n return_dictionary = {}\n\n for output_path in self.provided_outputs:\n return_dictionary[output_path.full_path] = self.get_value(output_path)\n\n return return_dictionary","def _check_output_observable_dict(\n self, output_observable_dict, outputs, observables):\n if output_observable_dict is None:\n if (len(outputs) == 1) and (len(observables) == 1):\n # Create map of single output to single observable\n output_observable_dict = {outputs[0]: observables[0]}\n else:\n # Assume trivial map\n output_observable_dict = {output: output for output in outputs}\n\n # Check that output-observable map is valid\n for output in outputs:\n if output not in list(output_observable_dict.keys()):\n raise ValueError(\n 'The output <' + str(output) + '> could not be identified '\n 'in the output-observable map.')\n\n observable = output_observable_dict[output]\n if observable not in observables:\n raise ValueError(\n 'The observable <' + str(observable) + '> could not be '\n 'identified in the dataframe.')\n\n return output_observable_dict","def init_output_dict(self):\n return {\n \"outputs\": torch.FloatTensor(),\n \"pred_probs\": torch.FloatTensor(),\n \"labels\": torch.LongTensor(),\n }","def finalize_output_dict(self):\n self.output_dict = {\n key: torch.cat(value).numpy() for key, value in self.output_dict.items()\n }","def finalize_output_dict(self, output_dict):\n return {key: output_dict[key].cpu().numpy() for key in output_dict.keys()}","def _transform_outputs(self) -> None:\n self.outputs = None if self.outputs == {} else self.outputs","def _populate_output(self):\n pass","def collect_output(workdir_path, outputs):\n output_dict = {}\n for output_parameter in outputs:\n if 'id' not in output_parameter:\n exit_validation(\"Error: output without id member\")\n if 'type' not in output_parameter:\n exit_validation(\"Error: output without type member\")\n if output_parameter['type'] != 'File':\n exit_system_error(\"Sorry, I only know about File outputs\")\n if 'outputBinding' in output_parameter:\n binding = output_parameter['outputBinding']\n paths = []\n if 'glob' in binding:\n paths = glob.glob(os.path.join(workdir_path, binding['glob']))\n log(\"Paths after globbing: \" + str(paths))\n if paths != []:\n output_dict[output_parameter['id']] = {\n 'class': 'File',\n 'location': 'file:///' + paths[0]\n }\n return output_dict","def update_outputs(self, outnames):\n for cname, vnames in partition_names_by_comp(outnames).items():\n if cname is None: # boundary outputs\n self.update_inputs(None, vnames)\n else:\n getattr(self, cname).update_outputs(vnames)\n self.set_valid(vnames, True)","def _ParseOutputs(self, output_data, output_parameters=None):\n\n try:\n\n output_data.iteritems()\n\n except AttributeError, e:\n\n raise errors.ScheduleError(\"Error parsing outputs, %s\" % e)\n\n\n for output_type, data in output_data.iteritems():\n\n output_name = \"\"\n \n if output_data.has_key('name'):\n\n output_name = data['name']\n\n else:\n \n output_name = \"%s (%s)\" % (self.name, output_type)\n\n\n if self.verbose:\n\n print \"Loading Output '%s' of type '%s'\" % (output_name, output_type)\n\n output = self._output_registry.Create(output_name, output_type, output_data)\n\n\n # After giving initializing data, we give the output parameters\n #\n if output_parameters is not None:\n\n for o in output_parameters:\n\n self.AddOutput(path=o['component_name'],\n parameter=o['field'],\n output_type=o['outputclass'],)\n\n self._outputs.append(output)","def validate_output_values(self, source, **kwargs):\n return self._validate_values(\"output_values\", source, **kwargs)","def __set_outputs__(self):\n self.__set_in_out_var__(None, 1)","def get_output_data(\n self,\n inputs: Dict[str, Any]) -> Any:\n return inputs","def outputs_prepare_hook(\n self,\n outputs: Any,\n ) -> Any:\n return outputs","def initialize_output_dict(self, label: Optional[str] = None):\n if label is not None or not self._does_output_dict_contain_info():\n for species in self.species_list:\n if label is None or species.label == label:\n if species.label not in self.output:\n self.output[species.label] = dict()\n if 'paths' not in self.output[species.label]:\n self.output[species.label]['paths'] = dict()\n path_keys = ['geo', 'freq', 'sp', 'composite']\n for key in path_keys:\n if key not in self.output[species.label]['paths']:\n self.output[species.label]['paths'][key] = ''\n if 'irc' not in self.output[species.label]['paths'] and species.is_ts:\n self.output[species.label]['paths']['irc'] = list()\n if 'job_types' not in self.output[species.label]:\n self.output[species.label]['job_types'] = dict()\n for job_type in list(set(self.job_types.keys())) + ['opt', 'freq', 'sp', 'composite', 'onedmin']:\n if job_type in ['rotors', 'bde']:\n # rotors could be invalidated due to many reasons,\n # also could be falsely identified in a species that has no torsional modes.\n self.output[species.label]['job_types'][job_type] = True\n else:\n self.output[species.label]['job_types'][job_type] = False\n keys = ['conformers', 'isomorphism', 'convergence', 'restart', 'errors', 'warnings', 'info']\n for key in keys:\n if key not in self.output[species.label]:\n if key == 'convergence':\n self.output[species.label][key] = None\n else:\n self.output[species.label][key] = ''","def solid_output_values(self) -> Mapping[str, Union[Any, Mapping[str, Any]]]:\n results: Dict[str, Union[Any, Dict[str, Any]]] = {}\n captured = self._step_execution_context.step_output_capture\n\n if captured is None:\n check.failed(\"Outputs were unexpectedly not captured for hook\")\n\n # make the returned values more user-friendly\n for step_output_handle, value in captured.items():\n if step_output_handle.mapping_key:\n if results.get(step_output_handle.output_name) is None:\n results[step_output_handle.output_name] = {\n step_output_handle.mapping_key: value\n }\n else:\n results[step_output_handle.output_name][step_output_handle.mapping_key] = value\n else:\n results[step_output_handle.output_name] = value\n\n return results","def _output_update(self):\n self._outputtype = self.inputs.outputtype","def validate(self):\n self.__log('Validating whether all conditions are met.')\n if not self.config['OUT_FOLDER'] or not self.config['OUTPUT_FOLDER']:\n self.__log('The path to the output folder cannot be found.', 'error')\n raise FileNotFoundError\n\n try:\n if '.' in self.output_filename:\n self.__log('The output filename should not contain an extension.', 'error')\n raise ValueError\n except TypeError:\n pass\n\n if not self.output_filename:\n self.__log('The output filename has not been specified.', 'warning')\n self.output_filename = self.hash_time()\n i = 0\n while self.output_file_exists():\n self.__log('Adding a unique identifier to current filename.', 'warning')\n self.output_filename = self.output_filename + '-' + i\n i += 1\n self.__log(f'Continuing with file: \"{self.output_filename}\"', 'success')\n\n # Iterate over options to check for required parameters, as to not waste requests\n self.__log('Starting to check if all required parameters are set')\n for key, value in self.options.items():\n if key in self.config['REQUIRED_PARAMETERS'] and not value:\n self.__log(f'Missing a required parameter: {key}', 'error')\n raise MissingRequiredParameterError(key)\n\n self.__log('All validation successful.', 'success')","def _translate_outputs(self, outputs):\n HOT_TO_CFN_ATTRS = {'description': 'Description',\n 'value': 'Value'}\n\n cfn_outputs = {}\n\n for output_name, attrs in six.iteritems(outputs):\n cfn_output = {}\n\n for attr, attr_value in six.iteritems(attrs):\n cfn_attr = self._translate(attr, HOT_TO_CFN_ATTRS,\n _('\"%s\" is not a valid keyword '\n 'inside an output definition'))\n cfn_output[cfn_attr] = attr_value\n\n cfn_outputs[output_name] = cfn_output\n\n return cfn_outputs","def get_outputs(self, input_dict: Dict) -> Dict[str, np.ndarray]:\n activation_values = self.session.run(self.activation_names, input_dict)\n return dict(zip(self.sanitized_activation_names, activation_values))","def set_outputs(self, outputs):\n self.attributes[\"outputs\"] = outputs","def _parse_output_variables(self):\n self._output_variables_by_name = {}\n self._output_variables_by_type = {}\n for ov in self._output_variables:\n # parse the variable to get individual parts\n parsed_variable = self.parse_variable(ov)\n variable_name = parsed_variable.get('name')\n variable_type = parsed_variable.get('type')\n\n # store the variables in dict by name (e.g. \"status_code\")\n self._output_variables_by_name[variable_name] = {'variable': ov}\n\n # store the variables in dict by name-type (e.g. \"status_code-String\")\n self._output_variables_by_type[f'{variable_name}-{variable_type}'] = {'variable': ov}","def __generate_output_data(self):\n if not len(self.output_data) == 0:\n return\n try:\n self.output_data = s.load(open('output/output_data.p', 'rb'))\n self.class_indices = s.load(open('output/class_indices.p', 'rb'))\n if not self.classes_to_visualise == None:\n self.__filter_output_data(self.classes_to_visualise)\n except:\n self.output_data = generate_output_for_test_data(image_data=self.image_data,\n binary_output=self.binary_output) if self.testing else generate_output_for_train_data(\n image_data=self.image_data, binary_output=self.binary_output)\n self.class_indices = get_all_class_indices(training=False) if self.testing else get_all_class_indices()\n if not self.classes_to_visualise == None:\n self.__filter_output_data(self.classes_to_visualise)\n s.dump([out.tolist() for out in self.output_data], open('output/output_data.p', 'wb'))\n s.dump(self.class_indices, open('output/class_indices.p', 'wb'))\n\n self.legend = get_class_names_for_class_indices(list(set(sorted(self.class_indices))))","def prepare_multiple_out_parsers(run_dict):\n output_parser_dict = {}\n for run_label, run_name in run_dict.items():\n output_parser_dict[run_label] = OutputParser(run_name, use_most_recent=False)\n return output_parser_dict","def output_definition(self):\n return {\n 'error': [0.0, 10.0]\n }","def _format_calc(self, outputs: Dict[str, np.array], system: System):\n results = {p: [] for p in self.required_properties}\n\n for output in outputs:\n for p in self.required_properties:\n # Check for convergence\n if output[p] is None:\n raise QMCalculatorError(\"Errors encountered during computation.\")\n\n results[p].append(torch.from_numpy(output[p]))\n\n for p in self.required_properties:\n results[p] = torch.stack(results[p]).to(system.device, system.dtype)\n\n return results","def decode_results(self, outputs):\n ...","def outputs(self):\n pass","def _create_output_alternatives(self, predictions):\n return {self.head_name: (self._problem_type, predictions)}","def outputs(self):\n return {\"path_to_validation_pdf\": File_IO(\n self.node.outputs[0])}","def get_outputs():\n outputs = {}\n for obj in vars(acsploit.output).values():\n if hasattr(obj, 'OUTPUT_NAME'):\n outputs[obj.OUTPUT_NAME] = obj\n\n return outputs","def postprocess_model_outputs(self, predictions, expected):\n\n for key, val in predictions.items():\n predictions[key] = val.numpy()\n\n for key, val in expected.items():\n expected[key] = val.numpy()\n\n return predictions, expected","def collect_outputs(self, output_lookup=None):\n\n if output_lookup is None:\n output_lookup = {'cf_mean': self.cf_mean,\n 'cf_mean_ac': self.cf_mean_ac,\n 'cf_profile': self.cf_profile,\n 'cf_profile_ac': self.cf_profile_ac,\n 'annual_energy': self.annual_energy,\n 'energy_yield': self.energy_yield,\n 'gen_profile': self.gen_profile,\n 'ac': self.ac,\n 'dc': self.dc,\n 'clipped_power': self.clipped_power,\n 'system_capacity_ac': self.system_capacity_ac,\n }\n\n super().collect_outputs(output_lookup=output_lookup)","def postprocess_model_outputs(self, predictions, expected):\n\n predictions = {k: t.numpy() for k, t in predictions.items()}\n\n return predictions, expected","def build_outputs(self, **inputs):\n print(\"Building all outputs, \", self.name)\n# invscale, _ = self.build_output('invscale', **inputs)\n# loc, _ = self.build_output('loc', invscale=invscale, **inputs)\n# samp, _ = self.build_output('main', invscale=invscale, loc=loc)\n self.build_output('invscale', **inputs)\n self.build_output('loc', **inputs)\n self.build_output('main', **inputs)","def build_outputs(self):\n with tf.variable_scope(\"build_outputs\"):\n\n self.optical_flow = self.__optical_flow_src2_tgt\n self.disp = self.baselineNet.disp_tgt\n self.semantic = self.__semantic\n self.motion_mask = self.prepare_final_motion_mask()","def collect_outputs(self, output_lookup=None):\n\n if output_lookup is None:\n output_lookup = {'cf_mean': self.cf_mean,\n 'cf_profile': self.cf_profile,\n 'annual_energy': self.annual_energy,\n 'energy_yield': self.energy_yield,\n 'gen_profile': self.gen_profile,\n }\n\n super().collect_outputs(output_lookup=output_lookup)","def _validate_results(self, task, result):\n assert isinstance(result, dict), \\\n f\"{task} returned a {type(result)} rather than a dict\"\n for k in result:\n assert k in self.provides, \\\n f\"{task} provided unwanted output {k}\"\n for k in self.provides:\n assert k in result, \\\n f\"{task} failed to provide needed output {k}\"","def validate(cls, output_destination):\n # nothing to check :)\n pass","def validate(cls, output_destination):\n # nothing to check :)\n pass","def compute_metrics(self):\n self.finalize_output_dict()\n self.metric_dict = {\n key: value(self.output_dict[\"labels\"], self.output_dict[\"pred_probs\"])\n for key, value in self.metric_fns.items()\n }","def validation_epoch_end(self, outputs):\n avg_loss = torch.stack([x['val_loss'] for x in outputs]).mean()\n val_acc = sum([x['n_correct_pred'] for x in outputs]) / sum(x['n_pred'] for x in outputs)\n tensorboard_logs = {'val_loss': avg_loss, 'val_acc': val_acc}\n return {'val_loss': avg_loss, 'log': tensorboard_logs}","def _process_convert_output_(self, output_data, **kwargs):\n accept_input, current_state, output = output_data\n return (accept_input, current_state, output)","def _load_results(self, filename):\n cr = CaseReader(filename)\n case = cr.system_cases.get_case(-1)\n loaded_outputs = cr.list_outputs(case=case, explicit=True, implicit=True, values=True,\n units=True, shape=True, out_stream=None)\n\n self.outputs = {'indep': {}, 'states': {}, 'controls': {}, 'control_rates': {},\n 'design_parameters': {}, 'input_parameters': {}, 'ode': {}}\n\n for output_name, options in loaded_outputs:\n\n if output_name.startswith('inputs.'):\n output_name = output_name.replace('inputs.', '')\n\n if output_name == 'time':\n var_type = 'indep'\n var_name = 'time'\n if output_name.startswith('states:'):\n var_type = 'states'\n var_name = output_name.replace('states:', '', 1)\n elif output_name.startswith('controls:'):\n var_type = 'controls'\n var_name = output_name.replace('controls:', '', 1)\n elif output_name.startswith('control_rates:'):\n var_type = 'control_rates'\n var_name = output_name.replace('control_rates:', '', 1)\n elif output_name.startswith('design_parameters:'):\n var_type = 'design_parameters'\n var_name = output_name.replace('design_parameters:', '', 1)\n # elif output_name.startswith('traj_design_parameters:'):\n # var_type = 'traj_design_parameters'\n # var_name = output_name.replace('traj_design_parameters:', '', 1)\n\n val = options['value']\n\n elif output_name.startswith('ode.'):\n var_type = 'ode'\n var_name = output_name.replace('ode.', '')\n\n if len(options['value'].shape) == 1:\n val = options['value'][:, np.newaxis]\n else:\n val = options['value']\n else:\n raise RuntimeError('unexpected output in file {1}: {0}'.format(output_name,\n filename))\n\n self.outputs[var_type][var_name] = {}\n self.outputs[var_type][var_name]['value'] = val\n self.outputs[var_type][var_name]['units'] = convert_to_ascii(options['units'])\n self.outputs[var_type][var_name]['shape'] = tuple(val.shape[1:])","def solid_output_values(self) -> Mapping[str, Union[Any, Mapping[str, Any]]]:\n raise DagsterInvalidPropertyError(_property_msg(\"solid_output_values\", \"method\"))","def solid_output_values(self) -> Mapping[str, Union[Any, Mapping[str, Any]]]:\n raise DagsterInvalidPropertyError(_property_msg(\"solid_output_values\", \"method\"))","def _assign_output_states(self):\n for mech in self.terminalMechanisms.mechanisms:\n self.outputStates[mech.name] = mech.outputStates","def setOutputs(self, output_list):\n self.output_list = output_list","def fixupProcess(self):\n # Make sure that for each output module the following parameters exist\n # in the PSet returned from the framework:\n # fileName\n # logicalFileName\n # dataset.dataTier\n # dataset.filterName\n if hasattr(self.process, \"outputModules\"):\n outputModuleNames = self.process.outputModules.keys()\n else:\n outputModuleNames = self.process.outputModules_()\n for outMod in outputModuleNames:\n outModRef = getattr(self.process, outMod)\n if not hasattr(outModRef, \"dataset\"):\n outModRef.dataset = cms.untracked.PSet()\n if not hasattr(outModRef.dataset, \"dataTier\"):\n outModRef.dataset.dataTier = cms.untracked.string(\"\")\n if not hasattr(outModRef.dataset, \"filterName\"):\n outModRef.dataset.filterName = cms.untracked.string(\"\")\n if not hasattr(outModRef, \"fileName\"):\n outModRef.fileName = cms.untracked.string(\"\")\n if not hasattr(outModRef, \"logicalFileName\"):\n outModRef.logicalFileName = cms.untracked.string(\"\")\n return","def outputs(self):\n return super().outputs","def outputs(self):\n return super().outputs","def outputs(self):\n return super().outputs","def outputs(self):\n return super().outputs","def convert_outputs(self):\n self.out('relaxed_structure', self.ctx.workchain.outputs.output_structure)\n self.out('total_energy', get_total_energy(self.ctx.workchain.outputs.output_parameters))\n self.out('forces', get_forces_from_trajectory(self.ctx.workchain.outputs.output_trajectory))\n self.out('stress', get_stress_from_trajectory(self.ctx.workchain.outputs.output_trajectory))","def output_from_json(self, output: Dict[str, Any]) -> OutputInfo:","def evaluate_outputs(self):\n raise NotImplementedError(\n 'evaluate_outputs called but not implemented in the derived class.'\n )","def _update_output_after_create_node(self):\n # Constants and parameter should not exist for input and output.\n filtered_node = {NodeTypeEnum.CONST.value, NodeTypeEnum.PARAMETER.value}\n for node in self._normal_node_map.values():\n for src_name, input_attr in node.inputs.items():\n src_node = self._get_normal_node(node_name=src_name)\n if src_node.type in filtered_node:\n continue\n\n src_node.add_outputs(node.name, input_attr)","def validation_epoch_end(self, outputs):\n # outputs contain data for 2 dataloaders - val and test\n for out_idx, outputs_i in enumerate(outputs):\n # validation loss\n val_loss_mean = torch.stack([x['val_loss_b'] for x in outputs_i]).mean()\n\n # predicts\n logits = np.concatenate([x['logits_b'] for x in outputs_i], axis=0)\n labels = np.concatenate([x['labels_b'] for x in outputs_i], axis=0)\n emph_probs = np.concatenate([x['emph_probs_b'] for x in outputs_i], axis=0)\n probs = np.exp(logits) / np.sum(np.exp(logits), axis=2, keepdims=True)\n preds = np.argmax(logits, axis=2)\n\n label_map = {i: label for i, label in enumerate(self.labels)}\n out_label_list = [[] for _ in range(labels.shape[0])]\n preds_list = [[] for _ in range(labels.shape[0])]\n probs_list = [[] for _ in range(labels.shape[0])]\n emph_probs_list = [[] for _ in range(labels.shape[0])]\n\n for i in range(labels.shape[0]):\n for j in range(labels.shape[1]):\n if labels[i, j] != self.pad_token_label_id:\n out_label_list[i].append(label_map[labels[i][j]])\n preds_list[i].append(label_map[preds[i][j]])\n probs_list[i].append(probs[i][j][1])\n emph_probs_list[i].append(emph_probs[i][j])\n\n # for validation\n if out_idx == 0:\n # show random example\n rand_idx = np.random.randint(0, len(out_label_list))\n logger.info('True: %s', out_label_list[rand_idx])\n logger.info('Pred: %s', preds_list[rand_idx])\n logger.info('Emph: %s', emph_probs_list[rand_idx])\n logger.info('Prob: %s', probs_list[rand_idx])\n\n # validation score\n val_score = match_m(probs_list, emph_probs_list)\n val_score_mean = np.mean(list(val_score.values()))\n\n # validation accuracy\n val_acc = accuracy_score(out_label_list, preds_list)\n\n # validation f1 score\n val_f1 = f1_score(out_label_list, preds_list)\n\n # score_logs\n score_logs = {\n 'val_score1': val_score[1],\n 'val_score2': val_score[2],\n 'val_score3': val_score[3],\n 'val_score4': val_score[4],\n 'val_score_mean': val_score_mean,\n }\n\n # logs\n logs = {\n 'val_loss': val_loss_mean.detach().numpy(),\n 'val_acc': val_acc,\n 'val_f1': val_f1,\n 'val_score_mean': val_score_mean,\n }\n\n # output dict\n output = {\n 'val_loss': val_loss_mean,\n 'val_f1': val_f1,\n 'val_acc': val_acc,\n 'progress_bar': logs,\n 'log': {**logs, **score_logs},\n }\n\n # write validation results to csv\n csv_dict = {k: v for k, v in vars(self.hparams).items() if k in FIELDNAMES}\n csv_dict.update(score_logs)\n csv_dict.update(logs)\n\n csv_dict['current_epoch'] = self.current_epoch\n csv_dict['global_step'] = self.global_step\n\n write_csv('results.csv', csv_dict)\n self.preds['val'][self.current_epoch][self.global_step] = probs_list\n\n # save prediction for test\n if out_idx == 1:\n self.preds['test'][self.current_epoch][self.global_step] = probs_list\n\n # write to file all val and test predictions\n with open('predicts/' + self.model_id_name + '.pkl', 'wb') as f:\n pickle.dump(self.preds, f)\n\n return output","def prepare_results(self) -> dict:\n if not hasattr(self, \"results\"):\n raise AttributeError(\n \"Results have not been finalized. Please call \"\n \"finalize_results() before saving output.\"\n )\n\n output = {\n \"armory_version\": armory.__version__,\n \"config\": self.config,\n \"results\": self.results,\n \"timestamp\": int(self.time_stamp),\n }\n return output","def outputs(self, inputs):\n return inputs","def _map_output_parameters(self, results, algorithm):\n if results is not None:\n\n # update python data objects\n for result_name in results:\n result_type = algorithm.get_type_from_output_name(result_name)\n if result_type is None:\n raise exceptions.PacmanTypeError(\n \"Unrecognised result name {} for algorithm {} with \"\n \"outputs {}\".format(\n result_name, algorithm.algorithm_id,\n algorithm.outputs))\n self._internal_type_mapping[result_type] = results[result_name]\n elif len(algorithm.outputs) != 0:\n raise exceptions.PacmanAlgorithmFailedToGenerateOutputsException(\n \"Algorithm {} did not generate any outputs\".format(\n algorithm.algorithm_id))","def _compute_outputs(self, *args, **kwargs):\n pass\n # self.outputs = self.model(input_ids=self.input_ids, masked_lm_labels=self.input_ids)\n # self.logits = self.outputs[0][0]\n # self.probs = torch.softmax(self.logits, 1)","async def collect_final_outputs(self) -> None: # pylint: disable=too-many-branches\n self._become_current()\n\n missing_outputs = False\n assert self.step is not None\n\n did_sleep = False\n\n for pattern in sorted(self.step.output): # pylint: disable=too-many-nested-blocks\n formatted_pattern = fmt_capture(self.kwargs, pattern)\n if is_phony(pattern):\n Invocation.up_to_date[formatted_pattern] = UpToDate(self.name, self.newest_input_mtime_ns + 1)\n continue\n\n try:\n paths = glob_paths(formatted_pattern)\n if not paths:\n Logger.debug(f\"Did not make the optional output(s): {pattern}\")\n else:\n for path in paths:\n self.built_outputs.append(path)\n\n global touch_success_outputs # pylint: disable=invalid-name\n if touch_success_outputs.value:\n if not did_sleep:\n await self.done(asyncio.sleep(1.0))\n did_sleep = True\n Logger.file(f\"Touch the output: {path}\")\n Stat.touch(path)\n\n mtime_ns = Stat.stat(path).st_mtime_ns\n Invocation.up_to_date[path] = UpToDate(self.name, mtime_ns)\n\n if Logger.isEnabledFor(logging.DEBUG):\n if path == formatted_pattern:\n Logger.debug(f\"Has the output: {path} \" f\"time: {_datetime_from_nanoseconds(mtime_ns)}\")\n else:\n Logger.debug(\n f\"Has the output: {pattern} -> {path} \"\n f\"time: {_datetime_from_nanoseconds(mtime_ns)}\"\n )\n\n except NonOptionalException:\n self._become_current()\n Logger.error(f\"Missing the output(s): {pattern}\")\n missing_outputs = True\n break\n\n if missing_outputs:\n self.abort(\"Missing some output(s)\")","def postprocess(self, inputs: Dict[str, Any], **kwargs) -> Dict[str, Any]:\n return inputs","def output_data_definitions(self):\n return {\n self.key_outputs: DataDefinition([-1, self.output_size], [torch.Tensor], \"Batch of outputs [BATCH_SIZE x OUTPUT_SIZE]\")\n }","def _parse_outputs(self, outputs, calculate_confusion_matrix):\n epoch_loss = []\n epoch_accuracy = []\n if calculate_confusion_matrix:\n y_true = []\n y_pred = []\n for step in outputs:\n epoch_loss.append(step['loss'].item())\n epoch_accuracy.append(step['accuracy'].item())\n if calculate_confusion_matrix:\n y_pred.append(step['y_hat'])\n y_true.append(step['y'])\n if calculate_confusion_matrix:\n y_pred = torch.cat(y_pred, 0)\n y_true = torch.cat(y_true, 0)\n confmat = pd.DataFrame(self.confusion_matrix(y_pred, y_true).tolist(\n ), columns=self.project_parameters.classes, index=self.project_parameters.classes).astype(int)\n return epoch_loss, epoch_accuracy, confmat\n else:\n return epoch_loss, epoch_accuracy","def with_output(self, output, output_format):\n\t\tself.variables['output'] = output\n\t\tself.variables['output_format'] = output_format\n\t\treturn self","def compute_metrics(self, outputs: List[Dict[str, torch.Tensor]]) -> dict:\n distance_pos, distance_neg = [], []\n for minibatch in outputs:\n minibatch = minibatch[\"val_prediction\"]\n src_embedding = minibatch[\"src_sentemb\"]\n ref_embedding = minibatch[\"ref_sentemb\"]\n pos_embedding = minibatch[\"pos_sentemb\"]\n neg_embedding = minibatch[\"neg_sentemb\"]\n\n distance_src_pos = F.pairwise_distance(pos_embedding, src_embedding)\n distance_ref_pos = F.pairwise_distance(pos_embedding, ref_embedding)\n harmonic_distance_pos = (2 * distance_src_pos * distance_ref_pos) / (\n distance_src_pos + distance_ref_pos\n )\n distance_pos.append(harmonic_distance_pos)\n\n distance_src_neg = F.pairwise_distance(neg_embedding, src_embedding)\n distance_ref_neg = F.pairwise_distance(neg_embedding, ref_embedding)\n harmonic_distance_neg = (2 * distance_src_neg * distance_ref_neg) / (\n distance_src_neg + distance_ref_neg\n )\n distance_neg.append(harmonic_distance_neg)\n\n return {\n \"kendall\": self.metrics.compute(\n torch.cat(distance_pos), torch.cat(distance_neg)\n )\n }","def get_new_input_output_maps(self, mapped_input_output_maps={}):\n inputs = self.get_input_contents()\n mapped_inputs = self.get_mapped_inputs(mapped_input_output_maps)\n mapped_inputs_scope_name = [ip['scope'] + \":\" + ip['name'] for ip in mapped_inputs]\n\n new_inputs = []\n new_input_output_maps = {}\n for ip in inputs:\n ip_scope_name = ip['scope'] + \":\" + ip['name']\n if ip_scope_name not in mapped_inputs_scope_name:\n new_inputs.append(ip)\n\n # to avoid cheking new inputs if there are no new inputs anymore\n if (not new_inputs and 'status' in self.collections[self._primary_input_collection]\n and self.collections[self._primary_input_collection]['status'] in [CollectionStatus.Closed]): # noqa: W503\n self.set_has_new_inputs(False)\n else:\n mapped_keys = mapped_input_output_maps.keys()\n if mapped_keys:\n next_key = max(mapped_keys) + 1\n else:\n next_key = 1\n for ip in new_inputs:\n out_ip = copy.deepcopy(ip)\n out_ip['coll_id'] = self.collections[self._primary_output_collection]['coll_id']\n new_input_output_maps[next_key] = {'inputs': [ip],\n 'outputs': [out_ip]}\n next_key += 1\n\n self.unfinished_points = 1\n\n return new_input_output_maps","def generate_output_data(self):\n for socket_name, c in self.__taskobject.outputs.items():\n data = Data(self.__project, type=c['type'])\n if c['optional']:\n data.enable(False)\n self.__outputs[socket_name] = {'data': data, 'enable': False}\n else:\n data.enable(True)\n self.__outputs[socket_name] = {'data': data, 'enable': True}","def process_output(self, state: str, data: SimData, tb_manager: TestbenchManager\n ) -> Tuple[bool, str, Dict[str, Any]]:\n return False, '', {}","def prep_outputs(self):\n return self._prep_outputs","def interpret_output(self, batch_output):\n raise NotImplementedError","def parsed_output(output_elements):\n parsed_output = {}\n for stanza, stanza_value in output_elements.items():\n fake_section = MagicMock()\n fake_section.options = {}\n fake_section.name = stanza\n parsed_output.update({stanza: fake_section})\n for option, value in stanza_value.items():\n fake_setting = MagicMock()\n fake_setting.name = option\n fake_setting.value = value\n parsed_output[stanza].options.update({option: fake_setting})\n return parsed_output","def update_output(self, ):\n input_ids, outputs, grads, adv_tokens = self.batch_output\n\n probs = softmax(outputs, dim=-1)\n probs, labels = torch.max(probs, dim=-1)\n\n tokens = [\n self.tokenizer.convert_ids_to_tokens(input_ids_)\n for input_ids_ in input_ids\n ]\n\n embedding_grads = grads.sum(dim=2)\n \n # norm for each sequence\n norms = torch.norm(embedding_grads, dim=1, p=2) # need check hyperparameter\n \n # normalizing\n for i, norm in enumerate(norms):\n embedding_grads[i] = torch.abs(embedding_grads[i]) / norm\n\n batch_output = []\n \n # check probs, labels shape\n labels = torch.reshape(labels, (1, -1))\n probs = torch.reshape(probs, (1, -1))\n iterator = zip(tokens, probs, embedding_grads, labels)\n\n for example_tokens, example_prob, example_grad, example_label in iterator:\n example_dict = dict()\n # as we do it by batches we has a padding so we need to remove it\n \n example_tokens = [t for t in example_tokens if t != self.tokenizer.pad_token]\n example_dict['tokens'] = example_tokens\n example_dict['grad'] = example_grad.cpu().tolist()[:len(example_tokens)]\n example_dict['label'] = example_label.cpu().tolist()[:len(example_tokens)] # example_label.item()\n example_dict['prob'] = example_prob.cpu().tolist()[:len(example_tokens)] # example_prob.item() \n\n batch_output.append(example_dict)\n\n return batch_output","def outputs(self):\n\t\treturn {k: v * self.throughput for k, v in self.per_process_outputs.items()}","def _convert_outputs(outputs, reduction_factor, batch_size):\n\n with tf.variable_scope(\"output_converter\"):\n for key in [\"spec\", \"post_net_spec\", \"stop_token_logits\", \"mag_spec\"]:\n outputs[key] = CentaurDecoder._expand(outputs[key], reduction_factor)\n\n alignments = []\n for sample in range(batch_size):\n alignments.append([outputs[\"alignments\"][0][:, sample, :, :, :]])\n mel_spec = outputs[\"spec\"]\n post_net_spec = outputs[\"post_net_spec\"]\n alignments = alignments\n stop_token_logits = tf.sigmoid(outputs[\"stop_token_logits\"])\n sequence_lengths = outputs[\"lengths\"]\n mag_spec = outputs[\"mag_spec\"]\n stop_token_prediction = outputs[\"stop_token_logits\"]\n return mel_spec, post_net_spec, alignments, stop_token_logits, sequence_lengths, mag_spec, stop_token_prediction","def calculate(self, assignments):\n # Build a tuple of the relevant input states from the set of\n # assignments given.\n states = tuple([assignments[v] for v in self.inputs])\n\n # Look them up\n try:\n results = self.lookup[states]\n except KeyError:\n raise RuntimeError(\"Error in {} with key {}\".format(self, states))\n\n # Now, construct a mapping over th output variables and return that.\n return dict(zip(self.outputs, results))","def _postprocess(self, output: Dict[str, np.ndarray]):\n # Slice to remove padding, omitting initial [CLS] and final [SEP]\n slicer = slice(1, output.pop(\"ntok\") - 1)\n output[\"tokens\"] = self.tokenizer.convert_ids_to_tokens(\n output.pop(\"input_ids\")[slicer])\n probas = output.pop(\"probas\")\n\n # Predictions at every position, regardless of masking.\n output[\"pred_tokens\"] = self._get_topk_tokens(probas[slicer]) # pytype: disable=container-type-mismatch\n\n return output","def _populate_output(self):\n self._store_atomic_queries_table()\n self._store_composite_queries_table()","def parse_output(param_names, params):\n\tif not os.path.isfile(params.output_file):\n\t\tprint(\"output file does not exist! ({})\".format(params.output_file))\n\t\tsys.exit(NO_OUTPUT)\n\n\tresults = {}\n\n\twith open(params.output_file, 'r') as out:\n\t\titeration_matches = re.findall(params.iteration_regex, out.read())\n\t\tfor iteration_match in iteration_matches:\n\t\t\titeration = int(iteration_match[0])\n\t\t\tresults[iteration] = [float(iteration_match[m]) for m in range(1,len(iteration_match))]\n\n\treturn results","def process(self):\n self.output_info = self.attributes.copy()","def validate_output(self):\n if self.dimension == 2:\n required = SEGMENT_GEO_SIG | self.output_signature\n for rays in [\n self.active_rays,\n self.finished_rays,\n self.stopped_rays,\n self.dead_rays\n ]:\n if bool(rays):\n sig = set(rays.keys())\n if not (sig >= required):\n raise RuntimeError(\n f\"Optical engine failed output signature check. System \" \n f\"signature is {sig}, but needed {required}.\"\n )","def _init_results(self) -> None:\n pt_bond_dimensions = {}\n for site, pt in enumerate(self._process_tensors):\n if pt is not None:\n pt_bond_dimensions[site] = pt.get_bond_dimensions()\n\n self._results = {\n 'time':[],\n 'norm': [],\n 'bond_dimensions': [],\n 'dynamics': {},\n 'pt_bond_dimensions': pt_bond_dimensions,\n }\n for sites in self._dynamics_sites:\n self._results['dynamics'][sites] = Dynamics(name=f\"site{sites}\")","def _generate_output(self):\n raise NotImplementedError()","def organize_outputs(\n command_outputs: list,\n prefix: str,\n multiple_prefixes: bool = False,\n file_output: bool = False,\n ) -> List[dict]:\n organized_outputs = []\n if file_output:\n command_outputs = command_outputs + [\n OutputArgument(\n name=\"EntryID\",\n prefix=\"InfoFile\",\n output_type=dict,\n description=\"The EntryID of the report file.\",\n ),\n OutputArgument(\n name=\"Extension\",\n prefix=\"InfoFile\",\n output_type=str,\n description=\"The extension of the report file.\",\n ),\n OutputArgument(\n name=\"Name\",\n prefix=\"InfoFile\",\n output_type=str,\n description=\"The name of the report file.\",\n ),\n OutputArgument(\n name=\"Info\",\n prefix=\"InfoFile\",\n output_type=str,\n description=\"The info of the report file.\",\n ),\n OutputArgument(\n name=\"Size\",\n prefix=\"InfoFile\",\n output_type=int,\n description=\"The size of the report file.\",\n ),\n OutputArgument(\n name=\"Type\",\n prefix=\"InfoFile\",\n output_type=str,\n description=\"The type of the report file.\",\n ),\n ]\n for output_key in command_outputs:\n context_path = output_key.name\n if prefix:\n context_path = f\"{prefix}.{output_key.name}\"\n if multiple_prefixes:\n if output_key.prefix:\n context_path = f\"{output_key.prefix}.{output_key.name}\"\n elif \".\" in output_key.name:\n context_path = output_key.name\n\n if output_key:\n organized_outputs.append(\n {\n \"contextPath\": context_path,\n \"description\": output_key.description,\n \"type\": MetadataToDict.get_metadata_type(\n output_key.output_type\n ),\n }\n )\n\n return organized_outputs","def output_data_definitions(self):\n return {\n self.key_outputs: DataDefinition(\n [-1]*(self.num_inputs_dims-1) + [self.input_size],\n [torch.Tensor],\n \"Batch of outputs [DIM 1 x DIM 2 x ... x INPUT_SIZE]\")\n }","def _process_convert_output_(self, output_data, **kwargs):\n if kwargs['always_include_output']:\n return super(Automaton, self)._process_convert_output_(\n output_data, **kwargs)\n accept_input, current_state, output = output_data\n if kwargs['full_output']:\n return (accept_input, current_state)\n else:\n return accept_input","def check(self):\n self.init()\n self.calculate_output()\n self.compare_outputs_with_expects()","def load_outputs(self):\n\n # Get all the data series from the CSV files (for every input of the model)\n LoadedOutputs = True\n for o in self.outputs:\n if o.is_measured_output():\n LoadedOutputs = LoadedOutputs and o.read_data_series()\n \n if not LoadedOutputs:\n logger.error(\"An error occurred while loading the outputs\")\n else:\n logger.debug(\"Outputs loaded correctly\")\n \n return LoadedOutputs","def collectOutput(self, finishedJob, output):\n evaluation = finishedJob.getEvaluation()\n outputDict = evaluation[1]\n # FIXED: writing directly to file is no longer an option!\n #if isinstance(output, Files.File):\n # availExtens = ['xml']\n # outputExtension = output.getExt().lower()\n # if outputExtension not in availExtens:\n # self.raiseAMessage('Metric postprocessor did not recognize extension \".', str(outputExtension), '\". The output will be dumped to a text file')\n # output.setPath(self._workingDir)\n # self.raiseADebug('Write Metric prostprocessor output in file with name: ', output.getAbsFile())\n # self._writeXML(output, outputDict)\n if output.type in ['PointSet', 'HistorySet']:\n self.raiseADebug('Adding output in data object named', output.name)\n rlz = {}\n for key, val in outputDict.items():\n newKey = key.replace(\"|\",\"_\")\n rlz[newKey] = val\n if self.dynamic:\n rlz[self.pivotParameter] = np.atleast_1d(self.pivotValues)\n output.addRealization(rlz)\n # add metadata\n xml = self._writeXML(output, outputDict)\n output._meta['MetricPP'] = xml\n elif output.type == 'HDF5':\n self.raiseAnError(IOError, 'Output type', str(output.type), 'is not yet implemented. Skip it')\n else:\n self.raiseAnError(IOError, 'Output type ', str(output.type), ' can not be used for postprocessor', self.name)","def build(self):\r\n self.dirty = 0\r\n \r\n # Files first\r\n for output in self.files.keys():\r\n params = self.files[output]\r\n if (params[1] != -1):\r\n filename = params[0]\r\n freq = params[1]\r\n if (output == 'energies'):\r\n self.myOutputs.append(OutputEnergies.OutputEnergies(filename, freq, 1,0,1.0,0))\r\n elif (output == 'dcdtrajpos'):\r\n if (os.path.exists(filename)): # Continue\r\n self.myOutputs.append(OutputDCDTrajectory.OutputDCDTrajectory(filename, freq, 1, 1))\r\n else: # Overwrite\r\n self.myOutputs.append(OutputDCDTrajectory.OutputDCDTrajectory(filename, freq, 1, 0))\r\n elif (output == 'dcdtrajvel'):\r\n if (os.path.exists(filename)):\r\n self.myOutputs.append(OutputDCDTrajectoryVel.OutputDCDTrajectoryVel(filename, freq, 1, 1))\r\n else:\r\n self.myOutputs.append(OutputDCDTrajectoryVel.OutputDCDTrajectoryVel(filename, freq, 1, 0))\r\n elif (output == 'xyztrajforce'):\r\n self.myOutputs.append(OutputXYZTrajectoryForce.OutputXYZTrajectoryForce(filename, freq))\r\n elif (output == 'xyztrajpos'):\r\n self.myOutputs.append(OutputXYZTrajectoryPos.OutputXYZTrajectoryPos(filename, freq, 1))\r\n elif (output == 'xyztrajvel'):\r\n self.myOutputs.append(OutputXYZTrajectoryVel.OutputXYZTrajectoryVel(filename, freq))\r\n elif (output == 'gui'):\r\n self.myOutputs.append(OutputFAHGUI.OutputFAHGUI(filename, freq, 52753, 1, \"MDL_3.0\", 0.0, 0))\r\n\r\n if (self.screen != -1):\r\n self.myOutputs.append(OutputScreen.OutputScreen(self.screen))\r\n\r\n\r\n # Now plots\r\n for plot in self.plots.keys():\r\n freq = self.plots[plot]\r\n if (freq != -1):\r\n\r\n # Initialize a plot\r\n if (not self.doMPL): # Gnuplot\r\n self.xyData[plot] = []\r\n self.graphs[plot] = Gnuplot(debug=0)\r\n else: # Matplotlib\r\n self.xData[plot] = []\r\n self.yData[plot] = []\r\n self.figures[plot] = 0\r\n\r\n # Add the function to plot the data,\r\n # and the frequency at which to execute it\r\n self.myPlots.append([self.plotFunctions[plot], freq])","def add_warnings_and_errors(self, output_data):\n # add the dictionary with warnings and errors\n warnings = self.retrieved.get_object_content(self.node.get_option(\"scheduler_stderr\"))\n # for some reason, errors may be in the stdout, but not the log.lammps\n stdout = self.retrieved.get_object_content(self.node.get_option(\"scheduler_stdout\"))\n errors = [line for line in stdout.splitlines() if line.startswith(\"ERROR\")]\n\n for error in errors:\n self.logger.error(error)\n\n output_data.update({'warnings': warnings})\n output_data.update({'errors': errors})","def parse_output(self, outputfile, directory):\n out_dictionary = {}\n if os.path.exists(outputfile) and \\\n os.path.getsize(outputfile) > 600: # make sure exists and not empty.\n f = open(outputfile)\n file = f.readlines()\n try:\n rating = float(file[-2].split(\" \")[6].split(\"/\")[0])\n out_dictionary[\"pylint_rating\"] = rating\n f.close()\n except:\n print(\"something went wrong when parsing pylint\")\n\n return out_dictionary","def calculate_output(self):","def outputs(self):\n return {\"path_to_dtb_evaluation_result\": File_IO(\n self.node.outputs[0])}","def _process_output(self, driver_output):\n fs = self._port._filesystem\n failures = self._handle_error(driver_output)\n expected_driver_output = self._expected_driver_output()\n\n # Check the output and save the results.\n start_time = time.time()\n time_for_diffs = {}\n for test_type in self._test_types:\n start_diff_time = time.time()\n new_failures = test_type.compare_output(\n self._port, self._filename, self._options, driver_output,\n expected_driver_output)\n # Don't add any more failures if we already have a crash, so we don't\n # double-report those tests. We do double-report for timeouts since\n # we still want to see the text and image output.\n if not driver_output.crash:\n failures.extend(new_failures)\n test_result_writer.write_test_result(\n self._port, self._options.results_directory, self._filename,\n driver_output, expected_driver_output, new_failures)\n time_for_diffs[test_type.__class__.__name__] = (\n time.time() - start_diff_time)\n\n total_time_for_all_diffs = time.time() - start_diff_time\n return TestResult(self._filename, failures, driver_output.test_time,\n total_time_for_all_diffs, time_for_diffs)","def validation_epoch_end(self, outputs):\n avg_loss = torch.stack([x[\"val_loss\"] for x in outputs]).mean()\n tensorboard_logs = {\"val_loss\": avg_loss}\n return {\"avg_val_loss\": avg_loss, \"log\": tensorboard_logs}","def validation_epoch_end(self, outputs):\n avg_loss = torch.stack([x[\"val_loss\"] for x in outputs]).mean()\n tensorboard_logs = {\"val_loss\": avg_loss}\n return {\"avg_val_loss\": avg_loss, \"log\": tensorboard_logs}","def get_outputs(self, inputs):\n \n # Paths\n input_path = self.input_path\n output_path = self.output_path\n\n # Filename changes\n output_extension = stringify(self.executor.output_extension)\n output_prefix = stringify(self.executor.output_prefix) or ''\n\n if self.output:\n # Combine all inputs into one output\n output = output_prefix + change_extension(self.output, output_extension)\n output = join_path(output_path, output)\n \n if self.output_transform:\n output = self.output_transform(output)\n \n if self.run_output:\n if self.run_command:\n verify_type(self.run_command, list)\n run_command = [stringify(v).format(output=output) for v in self.run_command]\n else:\n run_command = [output]\n with current_context() as ctx:\n ctx.current.project.run[self.run_output] = run_command\n \n return True, [Output(output_path, output)]\n elif inputs:\n # Each input matches an output\n \n # Strip prefix\n if self.output_strip_prefix_from:\n with current_context() as ctx:\n _, p = ctx.current.project.get_phase_for(self.output_strip_prefix_from,\n 'output_strip_prefix_from')\n if p:\n output_strip_prefix = p.output_path\n else:\n output_strip_prefix = None\n else:\n output_strip_prefix = stringify(self.output_strip_prefix)\n if output_strip_prefix is None:\n output_strip_prefix = input_path\n if not output_strip_prefix.endswith(os.sep):\n output_strip_prefix += os.sep\n output_strip_prefix_length = len(output_strip_prefix)\n \n outputs = [] \n for the_input in inputs:\n output = the_input\n \n # Strip prefix\n if output.startswith(output_strip_prefix):\n output = output[output_strip_prefix_length:]\n\n # Filename changes\n if output_prefix:\n p, f = os.path.split(output)\n output = join_path(p, output_prefix + f)\n output = change_extension(output, output_extension)\n \n output = join_path(output_path, output)\n\n if self.output_transform:\n output = self.output_transform(output)\n\n outputs.append(Output(output_path, output))\n \n return False, outputs\n else:\n return False, []"],"string":"[\n \"def _get_output_dictionary(self):\\n\\n return_dictionary = {}\\n\\n for output_path in self.provided_outputs:\\n return_dictionary[output_path.full_path] = self.get_value(output_path)\\n\\n return return_dictionary\",\n \"def _check_output_observable_dict(\\n self, output_observable_dict, outputs, observables):\\n if output_observable_dict is None:\\n if (len(outputs) == 1) and (len(observables) == 1):\\n # Create map of single output to single observable\\n output_observable_dict = {outputs[0]: observables[0]}\\n else:\\n # Assume trivial map\\n output_observable_dict = {output: output for output in outputs}\\n\\n # Check that output-observable map is valid\\n for output in outputs:\\n if output not in list(output_observable_dict.keys()):\\n raise ValueError(\\n 'The output <' + str(output) + '> could not be identified '\\n 'in the output-observable map.')\\n\\n observable = output_observable_dict[output]\\n if observable not in observables:\\n raise ValueError(\\n 'The observable <' + str(observable) + '> could not be '\\n 'identified in the dataframe.')\\n\\n return output_observable_dict\",\n \"def init_output_dict(self):\\n return {\\n \\\"outputs\\\": torch.FloatTensor(),\\n \\\"pred_probs\\\": torch.FloatTensor(),\\n \\\"labels\\\": torch.LongTensor(),\\n }\",\n \"def finalize_output_dict(self):\\n self.output_dict = {\\n key: torch.cat(value).numpy() for key, value in self.output_dict.items()\\n }\",\n \"def finalize_output_dict(self, output_dict):\\n return {key: output_dict[key].cpu().numpy() for key in output_dict.keys()}\",\n \"def _transform_outputs(self) -> None:\\n self.outputs = None if self.outputs == {} else self.outputs\",\n \"def _populate_output(self):\\n pass\",\n \"def collect_output(workdir_path, outputs):\\n output_dict = {}\\n for output_parameter in outputs:\\n if 'id' not in output_parameter:\\n exit_validation(\\\"Error: output without id member\\\")\\n if 'type' not in output_parameter:\\n exit_validation(\\\"Error: output without type member\\\")\\n if output_parameter['type'] != 'File':\\n exit_system_error(\\\"Sorry, I only know about File outputs\\\")\\n if 'outputBinding' in output_parameter:\\n binding = output_parameter['outputBinding']\\n paths = []\\n if 'glob' in binding:\\n paths = glob.glob(os.path.join(workdir_path, binding['glob']))\\n log(\\\"Paths after globbing: \\\" + str(paths))\\n if paths != []:\\n output_dict[output_parameter['id']] = {\\n 'class': 'File',\\n 'location': 'file:///' + paths[0]\\n }\\n return output_dict\",\n \"def update_outputs(self, outnames):\\n for cname, vnames in partition_names_by_comp(outnames).items():\\n if cname is None: # boundary outputs\\n self.update_inputs(None, vnames)\\n else:\\n getattr(self, cname).update_outputs(vnames)\\n self.set_valid(vnames, True)\",\n \"def _ParseOutputs(self, output_data, output_parameters=None):\\n\\n try:\\n\\n output_data.iteritems()\\n\\n except AttributeError, e:\\n\\n raise errors.ScheduleError(\\\"Error parsing outputs, %s\\\" % e)\\n\\n\\n for output_type, data in output_data.iteritems():\\n\\n output_name = \\\"\\\"\\n \\n if output_data.has_key('name'):\\n\\n output_name = data['name']\\n\\n else:\\n \\n output_name = \\\"%s (%s)\\\" % (self.name, output_type)\\n\\n\\n if self.verbose:\\n\\n print \\\"Loading Output '%s' of type '%s'\\\" % (output_name, output_type)\\n\\n output = self._output_registry.Create(output_name, output_type, output_data)\\n\\n\\n # After giving initializing data, we give the output parameters\\n #\\n if output_parameters is not None:\\n\\n for o in output_parameters:\\n\\n self.AddOutput(path=o['component_name'],\\n parameter=o['field'],\\n output_type=o['outputclass'],)\\n\\n self._outputs.append(output)\",\n \"def validate_output_values(self, source, **kwargs):\\n return self._validate_values(\\\"output_values\\\", source, **kwargs)\",\n \"def __set_outputs__(self):\\n self.__set_in_out_var__(None, 1)\",\n \"def get_output_data(\\n self,\\n inputs: Dict[str, Any]) -> Any:\\n return inputs\",\n \"def outputs_prepare_hook(\\n self,\\n outputs: Any,\\n ) -> Any:\\n return outputs\",\n \"def initialize_output_dict(self, label: Optional[str] = None):\\n if label is not None or not self._does_output_dict_contain_info():\\n for species in self.species_list:\\n if label is None or species.label == label:\\n if species.label not in self.output:\\n self.output[species.label] = dict()\\n if 'paths' not in self.output[species.label]:\\n self.output[species.label]['paths'] = dict()\\n path_keys = ['geo', 'freq', 'sp', 'composite']\\n for key in path_keys:\\n if key not in self.output[species.label]['paths']:\\n self.output[species.label]['paths'][key] = ''\\n if 'irc' not in self.output[species.label]['paths'] and species.is_ts:\\n self.output[species.label]['paths']['irc'] = list()\\n if 'job_types' not in self.output[species.label]:\\n self.output[species.label]['job_types'] = dict()\\n for job_type in list(set(self.job_types.keys())) + ['opt', 'freq', 'sp', 'composite', 'onedmin']:\\n if job_type in ['rotors', 'bde']:\\n # rotors could be invalidated due to many reasons,\\n # also could be falsely identified in a species that has no torsional modes.\\n self.output[species.label]['job_types'][job_type] = True\\n else:\\n self.output[species.label]['job_types'][job_type] = False\\n keys = ['conformers', 'isomorphism', 'convergence', 'restart', 'errors', 'warnings', 'info']\\n for key in keys:\\n if key not in self.output[species.label]:\\n if key == 'convergence':\\n self.output[species.label][key] = None\\n else:\\n self.output[species.label][key] = ''\",\n \"def solid_output_values(self) -> Mapping[str, Union[Any, Mapping[str, Any]]]:\\n results: Dict[str, Union[Any, Dict[str, Any]]] = {}\\n captured = self._step_execution_context.step_output_capture\\n\\n if captured is None:\\n check.failed(\\\"Outputs were unexpectedly not captured for hook\\\")\\n\\n # make the returned values more user-friendly\\n for step_output_handle, value in captured.items():\\n if step_output_handle.mapping_key:\\n if results.get(step_output_handle.output_name) is None:\\n results[step_output_handle.output_name] = {\\n step_output_handle.mapping_key: value\\n }\\n else:\\n results[step_output_handle.output_name][step_output_handle.mapping_key] = value\\n else:\\n results[step_output_handle.output_name] = value\\n\\n return results\",\n \"def _output_update(self):\\n self._outputtype = self.inputs.outputtype\",\n \"def validate(self):\\n self.__log('Validating whether all conditions are met.')\\n if not self.config['OUT_FOLDER'] or not self.config['OUTPUT_FOLDER']:\\n self.__log('The path to the output folder cannot be found.', 'error')\\n raise FileNotFoundError\\n\\n try:\\n if '.' in self.output_filename:\\n self.__log('The output filename should not contain an extension.', 'error')\\n raise ValueError\\n except TypeError:\\n pass\\n\\n if not self.output_filename:\\n self.__log('The output filename has not been specified.', 'warning')\\n self.output_filename = self.hash_time()\\n i = 0\\n while self.output_file_exists():\\n self.__log('Adding a unique identifier to current filename.', 'warning')\\n self.output_filename = self.output_filename + '-' + i\\n i += 1\\n self.__log(f'Continuing with file: \\\"{self.output_filename}\\\"', 'success')\\n\\n # Iterate over options to check for required parameters, as to not waste requests\\n self.__log('Starting to check if all required parameters are set')\\n for key, value in self.options.items():\\n if key in self.config['REQUIRED_PARAMETERS'] and not value:\\n self.__log(f'Missing a required parameter: {key}', 'error')\\n raise MissingRequiredParameterError(key)\\n\\n self.__log('All validation successful.', 'success')\",\n \"def _translate_outputs(self, outputs):\\n HOT_TO_CFN_ATTRS = {'description': 'Description',\\n 'value': 'Value'}\\n\\n cfn_outputs = {}\\n\\n for output_name, attrs in six.iteritems(outputs):\\n cfn_output = {}\\n\\n for attr, attr_value in six.iteritems(attrs):\\n cfn_attr = self._translate(attr, HOT_TO_CFN_ATTRS,\\n _('\\\"%s\\\" is not a valid keyword '\\n 'inside an output definition'))\\n cfn_output[cfn_attr] = attr_value\\n\\n cfn_outputs[output_name] = cfn_output\\n\\n return cfn_outputs\",\n \"def get_outputs(self, input_dict: Dict) -> Dict[str, np.ndarray]:\\n activation_values = self.session.run(self.activation_names, input_dict)\\n return dict(zip(self.sanitized_activation_names, activation_values))\",\n \"def set_outputs(self, outputs):\\n self.attributes[\\\"outputs\\\"] = outputs\",\n \"def _parse_output_variables(self):\\n self._output_variables_by_name = {}\\n self._output_variables_by_type = {}\\n for ov in self._output_variables:\\n # parse the variable to get individual parts\\n parsed_variable = self.parse_variable(ov)\\n variable_name = parsed_variable.get('name')\\n variable_type = parsed_variable.get('type')\\n\\n # store the variables in dict by name (e.g. \\\"status_code\\\")\\n self._output_variables_by_name[variable_name] = {'variable': ov}\\n\\n # store the variables in dict by name-type (e.g. \\\"status_code-String\\\")\\n self._output_variables_by_type[f'{variable_name}-{variable_type}'] = {'variable': ov}\",\n \"def __generate_output_data(self):\\n if not len(self.output_data) == 0:\\n return\\n try:\\n self.output_data = s.load(open('output/output_data.p', 'rb'))\\n self.class_indices = s.load(open('output/class_indices.p', 'rb'))\\n if not self.classes_to_visualise == None:\\n self.__filter_output_data(self.classes_to_visualise)\\n except:\\n self.output_data = generate_output_for_test_data(image_data=self.image_data,\\n binary_output=self.binary_output) if self.testing else generate_output_for_train_data(\\n image_data=self.image_data, binary_output=self.binary_output)\\n self.class_indices = get_all_class_indices(training=False) if self.testing else get_all_class_indices()\\n if not self.classes_to_visualise == None:\\n self.__filter_output_data(self.classes_to_visualise)\\n s.dump([out.tolist() for out in self.output_data], open('output/output_data.p', 'wb'))\\n s.dump(self.class_indices, open('output/class_indices.p', 'wb'))\\n\\n self.legend = get_class_names_for_class_indices(list(set(sorted(self.class_indices))))\",\n \"def prepare_multiple_out_parsers(run_dict):\\n output_parser_dict = {}\\n for run_label, run_name in run_dict.items():\\n output_parser_dict[run_label] = OutputParser(run_name, use_most_recent=False)\\n return output_parser_dict\",\n \"def output_definition(self):\\n return {\\n 'error': [0.0, 10.0]\\n }\",\n \"def _format_calc(self, outputs: Dict[str, np.array], system: System):\\n results = {p: [] for p in self.required_properties}\\n\\n for output in outputs:\\n for p in self.required_properties:\\n # Check for convergence\\n if output[p] is None:\\n raise QMCalculatorError(\\\"Errors encountered during computation.\\\")\\n\\n results[p].append(torch.from_numpy(output[p]))\\n\\n for p in self.required_properties:\\n results[p] = torch.stack(results[p]).to(system.device, system.dtype)\\n\\n return results\",\n \"def decode_results(self, outputs):\\n ...\",\n \"def outputs(self):\\n pass\",\n \"def _create_output_alternatives(self, predictions):\\n return {self.head_name: (self._problem_type, predictions)}\",\n \"def outputs(self):\\n return {\\\"path_to_validation_pdf\\\": File_IO(\\n self.node.outputs[0])}\",\n \"def get_outputs():\\n outputs = {}\\n for obj in vars(acsploit.output).values():\\n if hasattr(obj, 'OUTPUT_NAME'):\\n outputs[obj.OUTPUT_NAME] = obj\\n\\n return outputs\",\n \"def postprocess_model_outputs(self, predictions, expected):\\n\\n for key, val in predictions.items():\\n predictions[key] = val.numpy()\\n\\n for key, val in expected.items():\\n expected[key] = val.numpy()\\n\\n return predictions, expected\",\n \"def collect_outputs(self, output_lookup=None):\\n\\n if output_lookup is None:\\n output_lookup = {'cf_mean': self.cf_mean,\\n 'cf_mean_ac': self.cf_mean_ac,\\n 'cf_profile': self.cf_profile,\\n 'cf_profile_ac': self.cf_profile_ac,\\n 'annual_energy': self.annual_energy,\\n 'energy_yield': self.energy_yield,\\n 'gen_profile': self.gen_profile,\\n 'ac': self.ac,\\n 'dc': self.dc,\\n 'clipped_power': self.clipped_power,\\n 'system_capacity_ac': self.system_capacity_ac,\\n }\\n\\n super().collect_outputs(output_lookup=output_lookup)\",\n \"def postprocess_model_outputs(self, predictions, expected):\\n\\n predictions = {k: t.numpy() for k, t in predictions.items()}\\n\\n return predictions, expected\",\n \"def build_outputs(self, **inputs):\\n print(\\\"Building all outputs, \\\", self.name)\\n# invscale, _ = self.build_output('invscale', **inputs)\\n# loc, _ = self.build_output('loc', invscale=invscale, **inputs)\\n# samp, _ = self.build_output('main', invscale=invscale, loc=loc)\\n self.build_output('invscale', **inputs)\\n self.build_output('loc', **inputs)\\n self.build_output('main', **inputs)\",\n \"def build_outputs(self):\\n with tf.variable_scope(\\\"build_outputs\\\"):\\n\\n self.optical_flow = self.__optical_flow_src2_tgt\\n self.disp = self.baselineNet.disp_tgt\\n self.semantic = self.__semantic\\n self.motion_mask = self.prepare_final_motion_mask()\",\n \"def collect_outputs(self, output_lookup=None):\\n\\n if output_lookup is None:\\n output_lookup = {'cf_mean': self.cf_mean,\\n 'cf_profile': self.cf_profile,\\n 'annual_energy': self.annual_energy,\\n 'energy_yield': self.energy_yield,\\n 'gen_profile': self.gen_profile,\\n }\\n\\n super().collect_outputs(output_lookup=output_lookup)\",\n \"def _validate_results(self, task, result):\\n assert isinstance(result, dict), \\\\\\n f\\\"{task} returned a {type(result)} rather than a dict\\\"\\n for k in result:\\n assert k in self.provides, \\\\\\n f\\\"{task} provided unwanted output {k}\\\"\\n for k in self.provides:\\n assert k in result, \\\\\\n f\\\"{task} failed to provide needed output {k}\\\"\",\n \"def validate(cls, output_destination):\\n # nothing to check :)\\n pass\",\n \"def validate(cls, output_destination):\\n # nothing to check :)\\n pass\",\n \"def compute_metrics(self):\\n self.finalize_output_dict()\\n self.metric_dict = {\\n key: value(self.output_dict[\\\"labels\\\"], self.output_dict[\\\"pred_probs\\\"])\\n for key, value in self.metric_fns.items()\\n }\",\n \"def validation_epoch_end(self, outputs):\\n avg_loss = torch.stack([x['val_loss'] for x in outputs]).mean()\\n val_acc = sum([x['n_correct_pred'] for x in outputs]) / sum(x['n_pred'] for x in outputs)\\n tensorboard_logs = {'val_loss': avg_loss, 'val_acc': val_acc}\\n return {'val_loss': avg_loss, 'log': tensorboard_logs}\",\n \"def _process_convert_output_(self, output_data, **kwargs):\\n accept_input, current_state, output = output_data\\n return (accept_input, current_state, output)\",\n \"def _load_results(self, filename):\\n cr = CaseReader(filename)\\n case = cr.system_cases.get_case(-1)\\n loaded_outputs = cr.list_outputs(case=case, explicit=True, implicit=True, values=True,\\n units=True, shape=True, out_stream=None)\\n\\n self.outputs = {'indep': {}, 'states': {}, 'controls': {}, 'control_rates': {},\\n 'design_parameters': {}, 'input_parameters': {}, 'ode': {}}\\n\\n for output_name, options in loaded_outputs:\\n\\n if output_name.startswith('inputs.'):\\n output_name = output_name.replace('inputs.', '')\\n\\n if output_name == 'time':\\n var_type = 'indep'\\n var_name = 'time'\\n if output_name.startswith('states:'):\\n var_type = 'states'\\n var_name = output_name.replace('states:', '', 1)\\n elif output_name.startswith('controls:'):\\n var_type = 'controls'\\n var_name = output_name.replace('controls:', '', 1)\\n elif output_name.startswith('control_rates:'):\\n var_type = 'control_rates'\\n var_name = output_name.replace('control_rates:', '', 1)\\n elif output_name.startswith('design_parameters:'):\\n var_type = 'design_parameters'\\n var_name = output_name.replace('design_parameters:', '', 1)\\n # elif output_name.startswith('traj_design_parameters:'):\\n # var_type = 'traj_design_parameters'\\n # var_name = output_name.replace('traj_design_parameters:', '', 1)\\n\\n val = options['value']\\n\\n elif output_name.startswith('ode.'):\\n var_type = 'ode'\\n var_name = output_name.replace('ode.', '')\\n\\n if len(options['value'].shape) == 1:\\n val = options['value'][:, np.newaxis]\\n else:\\n val = options['value']\\n else:\\n raise RuntimeError('unexpected output in file {1}: {0}'.format(output_name,\\n filename))\\n\\n self.outputs[var_type][var_name] = {}\\n self.outputs[var_type][var_name]['value'] = val\\n self.outputs[var_type][var_name]['units'] = convert_to_ascii(options['units'])\\n self.outputs[var_type][var_name]['shape'] = tuple(val.shape[1:])\",\n \"def solid_output_values(self) -> Mapping[str, Union[Any, Mapping[str, Any]]]:\\n raise DagsterInvalidPropertyError(_property_msg(\\\"solid_output_values\\\", \\\"method\\\"))\",\n \"def solid_output_values(self) -> Mapping[str, Union[Any, Mapping[str, Any]]]:\\n raise DagsterInvalidPropertyError(_property_msg(\\\"solid_output_values\\\", \\\"method\\\"))\",\n \"def _assign_output_states(self):\\n for mech in self.terminalMechanisms.mechanisms:\\n self.outputStates[mech.name] = mech.outputStates\",\n \"def setOutputs(self, output_list):\\n self.output_list = output_list\",\n \"def fixupProcess(self):\\n # Make sure that for each output module the following parameters exist\\n # in the PSet returned from the framework:\\n # fileName\\n # logicalFileName\\n # dataset.dataTier\\n # dataset.filterName\\n if hasattr(self.process, \\\"outputModules\\\"):\\n outputModuleNames = self.process.outputModules.keys()\\n else:\\n outputModuleNames = self.process.outputModules_()\\n for outMod in outputModuleNames:\\n outModRef = getattr(self.process, outMod)\\n if not hasattr(outModRef, \\\"dataset\\\"):\\n outModRef.dataset = cms.untracked.PSet()\\n if not hasattr(outModRef.dataset, \\\"dataTier\\\"):\\n outModRef.dataset.dataTier = cms.untracked.string(\\\"\\\")\\n if not hasattr(outModRef.dataset, \\\"filterName\\\"):\\n outModRef.dataset.filterName = cms.untracked.string(\\\"\\\")\\n if not hasattr(outModRef, \\\"fileName\\\"):\\n outModRef.fileName = cms.untracked.string(\\\"\\\")\\n if not hasattr(outModRef, \\\"logicalFileName\\\"):\\n outModRef.logicalFileName = cms.untracked.string(\\\"\\\")\\n return\",\n \"def outputs(self):\\n return super().outputs\",\n \"def outputs(self):\\n return super().outputs\",\n \"def outputs(self):\\n return super().outputs\",\n \"def outputs(self):\\n return super().outputs\",\n \"def convert_outputs(self):\\n self.out('relaxed_structure', self.ctx.workchain.outputs.output_structure)\\n self.out('total_energy', get_total_energy(self.ctx.workchain.outputs.output_parameters))\\n self.out('forces', get_forces_from_trajectory(self.ctx.workchain.outputs.output_trajectory))\\n self.out('stress', get_stress_from_trajectory(self.ctx.workchain.outputs.output_trajectory))\",\n \"def output_from_json(self, output: Dict[str, Any]) -> OutputInfo:\",\n \"def evaluate_outputs(self):\\n raise NotImplementedError(\\n 'evaluate_outputs called but not implemented in the derived class.'\\n )\",\n \"def _update_output_after_create_node(self):\\n # Constants and parameter should not exist for input and output.\\n filtered_node = {NodeTypeEnum.CONST.value, NodeTypeEnum.PARAMETER.value}\\n for node in self._normal_node_map.values():\\n for src_name, input_attr in node.inputs.items():\\n src_node = self._get_normal_node(node_name=src_name)\\n if src_node.type in filtered_node:\\n continue\\n\\n src_node.add_outputs(node.name, input_attr)\",\n \"def validation_epoch_end(self, outputs):\\n # outputs contain data for 2 dataloaders - val and test\\n for out_idx, outputs_i in enumerate(outputs):\\n # validation loss\\n val_loss_mean = torch.stack([x['val_loss_b'] for x in outputs_i]).mean()\\n\\n # predicts\\n logits = np.concatenate([x['logits_b'] for x in outputs_i], axis=0)\\n labels = np.concatenate([x['labels_b'] for x in outputs_i], axis=0)\\n emph_probs = np.concatenate([x['emph_probs_b'] for x in outputs_i], axis=0)\\n probs = np.exp(logits) / np.sum(np.exp(logits), axis=2, keepdims=True)\\n preds = np.argmax(logits, axis=2)\\n\\n label_map = {i: label for i, label in enumerate(self.labels)}\\n out_label_list = [[] for _ in range(labels.shape[0])]\\n preds_list = [[] for _ in range(labels.shape[0])]\\n probs_list = [[] for _ in range(labels.shape[0])]\\n emph_probs_list = [[] for _ in range(labels.shape[0])]\\n\\n for i in range(labels.shape[0]):\\n for j in range(labels.shape[1]):\\n if labels[i, j] != self.pad_token_label_id:\\n out_label_list[i].append(label_map[labels[i][j]])\\n preds_list[i].append(label_map[preds[i][j]])\\n probs_list[i].append(probs[i][j][1])\\n emph_probs_list[i].append(emph_probs[i][j])\\n\\n # for validation\\n if out_idx == 0:\\n # show random example\\n rand_idx = np.random.randint(0, len(out_label_list))\\n logger.info('True: %s', out_label_list[rand_idx])\\n logger.info('Pred: %s', preds_list[rand_idx])\\n logger.info('Emph: %s', emph_probs_list[rand_idx])\\n logger.info('Prob: %s', probs_list[rand_idx])\\n\\n # validation score\\n val_score = match_m(probs_list, emph_probs_list)\\n val_score_mean = np.mean(list(val_score.values()))\\n\\n # validation accuracy\\n val_acc = accuracy_score(out_label_list, preds_list)\\n\\n # validation f1 score\\n val_f1 = f1_score(out_label_list, preds_list)\\n\\n # score_logs\\n score_logs = {\\n 'val_score1': val_score[1],\\n 'val_score2': val_score[2],\\n 'val_score3': val_score[3],\\n 'val_score4': val_score[4],\\n 'val_score_mean': val_score_mean,\\n }\\n\\n # logs\\n logs = {\\n 'val_loss': val_loss_mean.detach().numpy(),\\n 'val_acc': val_acc,\\n 'val_f1': val_f1,\\n 'val_score_mean': val_score_mean,\\n }\\n\\n # output dict\\n output = {\\n 'val_loss': val_loss_mean,\\n 'val_f1': val_f1,\\n 'val_acc': val_acc,\\n 'progress_bar': logs,\\n 'log': {**logs, **score_logs},\\n }\\n\\n # write validation results to csv\\n csv_dict = {k: v for k, v in vars(self.hparams).items() if k in FIELDNAMES}\\n csv_dict.update(score_logs)\\n csv_dict.update(logs)\\n\\n csv_dict['current_epoch'] = self.current_epoch\\n csv_dict['global_step'] = self.global_step\\n\\n write_csv('results.csv', csv_dict)\\n self.preds['val'][self.current_epoch][self.global_step] = probs_list\\n\\n # save prediction for test\\n if out_idx == 1:\\n self.preds['test'][self.current_epoch][self.global_step] = probs_list\\n\\n # write to file all val and test predictions\\n with open('predicts/' + self.model_id_name + '.pkl', 'wb') as f:\\n pickle.dump(self.preds, f)\\n\\n return output\",\n \"def prepare_results(self) -> dict:\\n if not hasattr(self, \\\"results\\\"):\\n raise AttributeError(\\n \\\"Results have not been finalized. Please call \\\"\\n \\\"finalize_results() before saving output.\\\"\\n )\\n\\n output = {\\n \\\"armory_version\\\": armory.__version__,\\n \\\"config\\\": self.config,\\n \\\"results\\\": self.results,\\n \\\"timestamp\\\": int(self.time_stamp),\\n }\\n return output\",\n \"def outputs(self, inputs):\\n return inputs\",\n \"def _map_output_parameters(self, results, algorithm):\\n if results is not None:\\n\\n # update python data objects\\n for result_name in results:\\n result_type = algorithm.get_type_from_output_name(result_name)\\n if result_type is None:\\n raise exceptions.PacmanTypeError(\\n \\\"Unrecognised result name {} for algorithm {} with \\\"\\n \\\"outputs {}\\\".format(\\n result_name, algorithm.algorithm_id,\\n algorithm.outputs))\\n self._internal_type_mapping[result_type] = results[result_name]\\n elif len(algorithm.outputs) != 0:\\n raise exceptions.PacmanAlgorithmFailedToGenerateOutputsException(\\n \\\"Algorithm {} did not generate any outputs\\\".format(\\n algorithm.algorithm_id))\",\n \"def _compute_outputs(self, *args, **kwargs):\\n pass\\n # self.outputs = self.model(input_ids=self.input_ids, masked_lm_labels=self.input_ids)\\n # self.logits = self.outputs[0][0]\\n # self.probs = torch.softmax(self.logits, 1)\",\n \"async def collect_final_outputs(self) -> None: # pylint: disable=too-many-branches\\n self._become_current()\\n\\n missing_outputs = False\\n assert self.step is not None\\n\\n did_sleep = False\\n\\n for pattern in sorted(self.step.output): # pylint: disable=too-many-nested-blocks\\n formatted_pattern = fmt_capture(self.kwargs, pattern)\\n if is_phony(pattern):\\n Invocation.up_to_date[formatted_pattern] = UpToDate(self.name, self.newest_input_mtime_ns + 1)\\n continue\\n\\n try:\\n paths = glob_paths(formatted_pattern)\\n if not paths:\\n Logger.debug(f\\\"Did not make the optional output(s): {pattern}\\\")\\n else:\\n for path in paths:\\n self.built_outputs.append(path)\\n\\n global touch_success_outputs # pylint: disable=invalid-name\\n if touch_success_outputs.value:\\n if not did_sleep:\\n await self.done(asyncio.sleep(1.0))\\n did_sleep = True\\n Logger.file(f\\\"Touch the output: {path}\\\")\\n Stat.touch(path)\\n\\n mtime_ns = Stat.stat(path).st_mtime_ns\\n Invocation.up_to_date[path] = UpToDate(self.name, mtime_ns)\\n\\n if Logger.isEnabledFor(logging.DEBUG):\\n if path == formatted_pattern:\\n Logger.debug(f\\\"Has the output: {path} \\\" f\\\"time: {_datetime_from_nanoseconds(mtime_ns)}\\\")\\n else:\\n Logger.debug(\\n f\\\"Has the output: {pattern} -> {path} \\\"\\n f\\\"time: {_datetime_from_nanoseconds(mtime_ns)}\\\"\\n )\\n\\n except NonOptionalException:\\n self._become_current()\\n Logger.error(f\\\"Missing the output(s): {pattern}\\\")\\n missing_outputs = True\\n break\\n\\n if missing_outputs:\\n self.abort(\\\"Missing some output(s)\\\")\",\n \"def postprocess(self, inputs: Dict[str, Any], **kwargs) -> Dict[str, Any]:\\n return inputs\",\n \"def output_data_definitions(self):\\n return {\\n self.key_outputs: DataDefinition([-1, self.output_size], [torch.Tensor], \\\"Batch of outputs [BATCH_SIZE x OUTPUT_SIZE]\\\")\\n }\",\n \"def _parse_outputs(self, outputs, calculate_confusion_matrix):\\n epoch_loss = []\\n epoch_accuracy = []\\n if calculate_confusion_matrix:\\n y_true = []\\n y_pred = []\\n for step in outputs:\\n epoch_loss.append(step['loss'].item())\\n epoch_accuracy.append(step['accuracy'].item())\\n if calculate_confusion_matrix:\\n y_pred.append(step['y_hat'])\\n y_true.append(step['y'])\\n if calculate_confusion_matrix:\\n y_pred = torch.cat(y_pred, 0)\\n y_true = torch.cat(y_true, 0)\\n confmat = pd.DataFrame(self.confusion_matrix(y_pred, y_true).tolist(\\n ), columns=self.project_parameters.classes, index=self.project_parameters.classes).astype(int)\\n return epoch_loss, epoch_accuracy, confmat\\n else:\\n return epoch_loss, epoch_accuracy\",\n \"def with_output(self, output, output_format):\\n\\t\\tself.variables['output'] = output\\n\\t\\tself.variables['output_format'] = output_format\\n\\t\\treturn self\",\n \"def compute_metrics(self, outputs: List[Dict[str, torch.Tensor]]) -> dict:\\n distance_pos, distance_neg = [], []\\n for minibatch in outputs:\\n minibatch = minibatch[\\\"val_prediction\\\"]\\n src_embedding = minibatch[\\\"src_sentemb\\\"]\\n ref_embedding = minibatch[\\\"ref_sentemb\\\"]\\n pos_embedding = minibatch[\\\"pos_sentemb\\\"]\\n neg_embedding = minibatch[\\\"neg_sentemb\\\"]\\n\\n distance_src_pos = F.pairwise_distance(pos_embedding, src_embedding)\\n distance_ref_pos = F.pairwise_distance(pos_embedding, ref_embedding)\\n harmonic_distance_pos = (2 * distance_src_pos * distance_ref_pos) / (\\n distance_src_pos + distance_ref_pos\\n )\\n distance_pos.append(harmonic_distance_pos)\\n\\n distance_src_neg = F.pairwise_distance(neg_embedding, src_embedding)\\n distance_ref_neg = F.pairwise_distance(neg_embedding, ref_embedding)\\n harmonic_distance_neg = (2 * distance_src_neg * distance_ref_neg) / (\\n distance_src_neg + distance_ref_neg\\n )\\n distance_neg.append(harmonic_distance_neg)\\n\\n return {\\n \\\"kendall\\\": self.metrics.compute(\\n torch.cat(distance_pos), torch.cat(distance_neg)\\n )\\n }\",\n \"def get_new_input_output_maps(self, mapped_input_output_maps={}):\\n inputs = self.get_input_contents()\\n mapped_inputs = self.get_mapped_inputs(mapped_input_output_maps)\\n mapped_inputs_scope_name = [ip['scope'] + \\\":\\\" + ip['name'] for ip in mapped_inputs]\\n\\n new_inputs = []\\n new_input_output_maps = {}\\n for ip in inputs:\\n ip_scope_name = ip['scope'] + \\\":\\\" + ip['name']\\n if ip_scope_name not in mapped_inputs_scope_name:\\n new_inputs.append(ip)\\n\\n # to avoid cheking new inputs if there are no new inputs anymore\\n if (not new_inputs and 'status' in self.collections[self._primary_input_collection]\\n and self.collections[self._primary_input_collection]['status'] in [CollectionStatus.Closed]): # noqa: W503\\n self.set_has_new_inputs(False)\\n else:\\n mapped_keys = mapped_input_output_maps.keys()\\n if mapped_keys:\\n next_key = max(mapped_keys) + 1\\n else:\\n next_key = 1\\n for ip in new_inputs:\\n out_ip = copy.deepcopy(ip)\\n out_ip['coll_id'] = self.collections[self._primary_output_collection]['coll_id']\\n new_input_output_maps[next_key] = {'inputs': [ip],\\n 'outputs': [out_ip]}\\n next_key += 1\\n\\n self.unfinished_points = 1\\n\\n return new_input_output_maps\",\n \"def generate_output_data(self):\\n for socket_name, c in self.__taskobject.outputs.items():\\n data = Data(self.__project, type=c['type'])\\n if c['optional']:\\n data.enable(False)\\n self.__outputs[socket_name] = {'data': data, 'enable': False}\\n else:\\n data.enable(True)\\n self.__outputs[socket_name] = {'data': data, 'enable': True}\",\n \"def process_output(self, state: str, data: SimData, tb_manager: TestbenchManager\\n ) -> Tuple[bool, str, Dict[str, Any]]:\\n return False, '', {}\",\n \"def prep_outputs(self):\\n return self._prep_outputs\",\n \"def interpret_output(self, batch_output):\\n raise NotImplementedError\",\n \"def parsed_output(output_elements):\\n parsed_output = {}\\n for stanza, stanza_value in output_elements.items():\\n fake_section = MagicMock()\\n fake_section.options = {}\\n fake_section.name = stanza\\n parsed_output.update({stanza: fake_section})\\n for option, value in stanza_value.items():\\n fake_setting = MagicMock()\\n fake_setting.name = option\\n fake_setting.value = value\\n parsed_output[stanza].options.update({option: fake_setting})\\n return parsed_output\",\n \"def update_output(self, ):\\n input_ids, outputs, grads, adv_tokens = self.batch_output\\n\\n probs = softmax(outputs, dim=-1)\\n probs, labels = torch.max(probs, dim=-1)\\n\\n tokens = [\\n self.tokenizer.convert_ids_to_tokens(input_ids_)\\n for input_ids_ in input_ids\\n ]\\n\\n embedding_grads = grads.sum(dim=2)\\n \\n # norm for each sequence\\n norms = torch.norm(embedding_grads, dim=1, p=2) # need check hyperparameter\\n \\n # normalizing\\n for i, norm in enumerate(norms):\\n embedding_grads[i] = torch.abs(embedding_grads[i]) / norm\\n\\n batch_output = []\\n \\n # check probs, labels shape\\n labels = torch.reshape(labels, (1, -1))\\n probs = torch.reshape(probs, (1, -1))\\n iterator = zip(tokens, probs, embedding_grads, labels)\\n\\n for example_tokens, example_prob, example_grad, example_label in iterator:\\n example_dict = dict()\\n # as we do it by batches we has a padding so we need to remove it\\n \\n example_tokens = [t for t in example_tokens if t != self.tokenizer.pad_token]\\n example_dict['tokens'] = example_tokens\\n example_dict['grad'] = example_grad.cpu().tolist()[:len(example_tokens)]\\n example_dict['label'] = example_label.cpu().tolist()[:len(example_tokens)] # example_label.item()\\n example_dict['prob'] = example_prob.cpu().tolist()[:len(example_tokens)] # example_prob.item() \\n\\n batch_output.append(example_dict)\\n\\n return batch_output\",\n \"def outputs(self):\\n\\t\\treturn {k: v * self.throughput for k, v in self.per_process_outputs.items()}\",\n \"def _convert_outputs(outputs, reduction_factor, batch_size):\\n\\n with tf.variable_scope(\\\"output_converter\\\"):\\n for key in [\\\"spec\\\", \\\"post_net_spec\\\", \\\"stop_token_logits\\\", \\\"mag_spec\\\"]:\\n outputs[key] = CentaurDecoder._expand(outputs[key], reduction_factor)\\n\\n alignments = []\\n for sample in range(batch_size):\\n alignments.append([outputs[\\\"alignments\\\"][0][:, sample, :, :, :]])\\n mel_spec = outputs[\\\"spec\\\"]\\n post_net_spec = outputs[\\\"post_net_spec\\\"]\\n alignments = alignments\\n stop_token_logits = tf.sigmoid(outputs[\\\"stop_token_logits\\\"])\\n sequence_lengths = outputs[\\\"lengths\\\"]\\n mag_spec = outputs[\\\"mag_spec\\\"]\\n stop_token_prediction = outputs[\\\"stop_token_logits\\\"]\\n return mel_spec, post_net_spec, alignments, stop_token_logits, sequence_lengths, mag_spec, stop_token_prediction\",\n \"def calculate(self, assignments):\\n # Build a tuple of the relevant input states from the set of\\n # assignments given.\\n states = tuple([assignments[v] for v in self.inputs])\\n\\n # Look them up\\n try:\\n results = self.lookup[states]\\n except KeyError:\\n raise RuntimeError(\\\"Error in {} with key {}\\\".format(self, states))\\n\\n # Now, construct a mapping over th output variables and return that.\\n return dict(zip(self.outputs, results))\",\n \"def _postprocess(self, output: Dict[str, np.ndarray]):\\n # Slice to remove padding, omitting initial [CLS] and final [SEP]\\n slicer = slice(1, output.pop(\\\"ntok\\\") - 1)\\n output[\\\"tokens\\\"] = self.tokenizer.convert_ids_to_tokens(\\n output.pop(\\\"input_ids\\\")[slicer])\\n probas = output.pop(\\\"probas\\\")\\n\\n # Predictions at every position, regardless of masking.\\n output[\\\"pred_tokens\\\"] = self._get_topk_tokens(probas[slicer]) # pytype: disable=container-type-mismatch\\n\\n return output\",\n \"def _populate_output(self):\\n self._store_atomic_queries_table()\\n self._store_composite_queries_table()\",\n \"def parse_output(param_names, params):\\n\\tif not os.path.isfile(params.output_file):\\n\\t\\tprint(\\\"output file does not exist! ({})\\\".format(params.output_file))\\n\\t\\tsys.exit(NO_OUTPUT)\\n\\n\\tresults = {}\\n\\n\\twith open(params.output_file, 'r') as out:\\n\\t\\titeration_matches = re.findall(params.iteration_regex, out.read())\\n\\t\\tfor iteration_match in iteration_matches:\\n\\t\\t\\titeration = int(iteration_match[0])\\n\\t\\t\\tresults[iteration] = [float(iteration_match[m]) for m in range(1,len(iteration_match))]\\n\\n\\treturn results\",\n \"def process(self):\\n self.output_info = self.attributes.copy()\",\n \"def validate_output(self):\\n if self.dimension == 2:\\n required = SEGMENT_GEO_SIG | self.output_signature\\n for rays in [\\n self.active_rays,\\n self.finished_rays,\\n self.stopped_rays,\\n self.dead_rays\\n ]:\\n if bool(rays):\\n sig = set(rays.keys())\\n if not (sig >= required):\\n raise RuntimeError(\\n f\\\"Optical engine failed output signature check. System \\\" \\n f\\\"signature is {sig}, but needed {required}.\\\"\\n )\",\n \"def _init_results(self) -> None:\\n pt_bond_dimensions = {}\\n for site, pt in enumerate(self._process_tensors):\\n if pt is not None:\\n pt_bond_dimensions[site] = pt.get_bond_dimensions()\\n\\n self._results = {\\n 'time':[],\\n 'norm': [],\\n 'bond_dimensions': [],\\n 'dynamics': {},\\n 'pt_bond_dimensions': pt_bond_dimensions,\\n }\\n for sites in self._dynamics_sites:\\n self._results['dynamics'][sites] = Dynamics(name=f\\\"site{sites}\\\")\",\n \"def _generate_output(self):\\n raise NotImplementedError()\",\n \"def organize_outputs(\\n command_outputs: list,\\n prefix: str,\\n multiple_prefixes: bool = False,\\n file_output: bool = False,\\n ) -> List[dict]:\\n organized_outputs = []\\n if file_output:\\n command_outputs = command_outputs + [\\n OutputArgument(\\n name=\\\"EntryID\\\",\\n prefix=\\\"InfoFile\\\",\\n output_type=dict,\\n description=\\\"The EntryID of the report file.\\\",\\n ),\\n OutputArgument(\\n name=\\\"Extension\\\",\\n prefix=\\\"InfoFile\\\",\\n output_type=str,\\n description=\\\"The extension of the report file.\\\",\\n ),\\n OutputArgument(\\n name=\\\"Name\\\",\\n prefix=\\\"InfoFile\\\",\\n output_type=str,\\n description=\\\"The name of the report file.\\\",\\n ),\\n OutputArgument(\\n name=\\\"Info\\\",\\n prefix=\\\"InfoFile\\\",\\n output_type=str,\\n description=\\\"The info of the report file.\\\",\\n ),\\n OutputArgument(\\n name=\\\"Size\\\",\\n prefix=\\\"InfoFile\\\",\\n output_type=int,\\n description=\\\"The size of the report file.\\\",\\n ),\\n OutputArgument(\\n name=\\\"Type\\\",\\n prefix=\\\"InfoFile\\\",\\n output_type=str,\\n description=\\\"The type of the report file.\\\",\\n ),\\n ]\\n for output_key in command_outputs:\\n context_path = output_key.name\\n if prefix:\\n context_path = f\\\"{prefix}.{output_key.name}\\\"\\n if multiple_prefixes:\\n if output_key.prefix:\\n context_path = f\\\"{output_key.prefix}.{output_key.name}\\\"\\n elif \\\".\\\" in output_key.name:\\n context_path = output_key.name\\n\\n if output_key:\\n organized_outputs.append(\\n {\\n \\\"contextPath\\\": context_path,\\n \\\"description\\\": output_key.description,\\n \\\"type\\\": MetadataToDict.get_metadata_type(\\n output_key.output_type\\n ),\\n }\\n )\\n\\n return organized_outputs\",\n \"def output_data_definitions(self):\\n return {\\n self.key_outputs: DataDefinition(\\n [-1]*(self.num_inputs_dims-1) + [self.input_size],\\n [torch.Tensor],\\n \\\"Batch of outputs [DIM 1 x DIM 2 x ... x INPUT_SIZE]\\\")\\n }\",\n \"def _process_convert_output_(self, output_data, **kwargs):\\n if kwargs['always_include_output']:\\n return super(Automaton, self)._process_convert_output_(\\n output_data, **kwargs)\\n accept_input, current_state, output = output_data\\n if kwargs['full_output']:\\n return (accept_input, current_state)\\n else:\\n return accept_input\",\n \"def check(self):\\n self.init()\\n self.calculate_output()\\n self.compare_outputs_with_expects()\",\n \"def load_outputs(self):\\n\\n # Get all the data series from the CSV files (for every input of the model)\\n LoadedOutputs = True\\n for o in self.outputs:\\n if o.is_measured_output():\\n LoadedOutputs = LoadedOutputs and o.read_data_series()\\n \\n if not LoadedOutputs:\\n logger.error(\\\"An error occurred while loading the outputs\\\")\\n else:\\n logger.debug(\\\"Outputs loaded correctly\\\")\\n \\n return LoadedOutputs\",\n \"def collectOutput(self, finishedJob, output):\\n evaluation = finishedJob.getEvaluation()\\n outputDict = evaluation[1]\\n # FIXED: writing directly to file is no longer an option!\\n #if isinstance(output, Files.File):\\n # availExtens = ['xml']\\n # outputExtension = output.getExt().lower()\\n # if outputExtension not in availExtens:\\n # self.raiseAMessage('Metric postprocessor did not recognize extension \\\".', str(outputExtension), '\\\". The output will be dumped to a text file')\\n # output.setPath(self._workingDir)\\n # self.raiseADebug('Write Metric prostprocessor output in file with name: ', output.getAbsFile())\\n # self._writeXML(output, outputDict)\\n if output.type in ['PointSet', 'HistorySet']:\\n self.raiseADebug('Adding output in data object named', output.name)\\n rlz = {}\\n for key, val in outputDict.items():\\n newKey = key.replace(\\\"|\\\",\\\"_\\\")\\n rlz[newKey] = val\\n if self.dynamic:\\n rlz[self.pivotParameter] = np.atleast_1d(self.pivotValues)\\n output.addRealization(rlz)\\n # add metadata\\n xml = self._writeXML(output, outputDict)\\n output._meta['MetricPP'] = xml\\n elif output.type == 'HDF5':\\n self.raiseAnError(IOError, 'Output type', str(output.type), 'is not yet implemented. Skip it')\\n else:\\n self.raiseAnError(IOError, 'Output type ', str(output.type), ' can not be used for postprocessor', self.name)\",\n \"def build(self):\\r\\n self.dirty = 0\\r\\n \\r\\n # Files first\\r\\n for output in self.files.keys():\\r\\n params = self.files[output]\\r\\n if (params[1] != -1):\\r\\n filename = params[0]\\r\\n freq = params[1]\\r\\n if (output == 'energies'):\\r\\n self.myOutputs.append(OutputEnergies.OutputEnergies(filename, freq, 1,0,1.0,0))\\r\\n elif (output == 'dcdtrajpos'):\\r\\n if (os.path.exists(filename)): # Continue\\r\\n self.myOutputs.append(OutputDCDTrajectory.OutputDCDTrajectory(filename, freq, 1, 1))\\r\\n else: # Overwrite\\r\\n self.myOutputs.append(OutputDCDTrajectory.OutputDCDTrajectory(filename, freq, 1, 0))\\r\\n elif (output == 'dcdtrajvel'):\\r\\n if (os.path.exists(filename)):\\r\\n self.myOutputs.append(OutputDCDTrajectoryVel.OutputDCDTrajectoryVel(filename, freq, 1, 1))\\r\\n else:\\r\\n self.myOutputs.append(OutputDCDTrajectoryVel.OutputDCDTrajectoryVel(filename, freq, 1, 0))\\r\\n elif (output == 'xyztrajforce'):\\r\\n self.myOutputs.append(OutputXYZTrajectoryForce.OutputXYZTrajectoryForce(filename, freq))\\r\\n elif (output == 'xyztrajpos'):\\r\\n self.myOutputs.append(OutputXYZTrajectoryPos.OutputXYZTrajectoryPos(filename, freq, 1))\\r\\n elif (output == 'xyztrajvel'):\\r\\n self.myOutputs.append(OutputXYZTrajectoryVel.OutputXYZTrajectoryVel(filename, freq))\\r\\n elif (output == 'gui'):\\r\\n self.myOutputs.append(OutputFAHGUI.OutputFAHGUI(filename, freq, 52753, 1, \\\"MDL_3.0\\\", 0.0, 0))\\r\\n\\r\\n if (self.screen != -1):\\r\\n self.myOutputs.append(OutputScreen.OutputScreen(self.screen))\\r\\n\\r\\n\\r\\n # Now plots\\r\\n for plot in self.plots.keys():\\r\\n freq = self.plots[plot]\\r\\n if (freq != -1):\\r\\n\\r\\n # Initialize a plot\\r\\n if (not self.doMPL): # Gnuplot\\r\\n self.xyData[plot] = []\\r\\n self.graphs[plot] = Gnuplot(debug=0)\\r\\n else: # Matplotlib\\r\\n self.xData[plot] = []\\r\\n self.yData[plot] = []\\r\\n self.figures[plot] = 0\\r\\n\\r\\n # Add the function to plot the data,\\r\\n # and the frequency at which to execute it\\r\\n self.myPlots.append([self.plotFunctions[plot], freq])\",\n \"def add_warnings_and_errors(self, output_data):\\n # add the dictionary with warnings and errors\\n warnings = self.retrieved.get_object_content(self.node.get_option(\\\"scheduler_stderr\\\"))\\n # for some reason, errors may be in the stdout, but not the log.lammps\\n stdout = self.retrieved.get_object_content(self.node.get_option(\\\"scheduler_stdout\\\"))\\n errors = [line for line in stdout.splitlines() if line.startswith(\\\"ERROR\\\")]\\n\\n for error in errors:\\n self.logger.error(error)\\n\\n output_data.update({'warnings': warnings})\\n output_data.update({'errors': errors})\",\n \"def parse_output(self, outputfile, directory):\\n out_dictionary = {}\\n if os.path.exists(outputfile) and \\\\\\n os.path.getsize(outputfile) > 600: # make sure exists and not empty.\\n f = open(outputfile)\\n file = f.readlines()\\n try:\\n rating = float(file[-2].split(\\\" \\\")[6].split(\\\"/\\\")[0])\\n out_dictionary[\\\"pylint_rating\\\"] = rating\\n f.close()\\n except:\\n print(\\\"something went wrong when parsing pylint\\\")\\n\\n return out_dictionary\",\n \"def calculate_output(self):\",\n \"def outputs(self):\\n return {\\\"path_to_dtb_evaluation_result\\\": File_IO(\\n self.node.outputs[0])}\",\n \"def _process_output(self, driver_output):\\n fs = self._port._filesystem\\n failures = self._handle_error(driver_output)\\n expected_driver_output = self._expected_driver_output()\\n\\n # Check the output and save the results.\\n start_time = time.time()\\n time_for_diffs = {}\\n for test_type in self._test_types:\\n start_diff_time = time.time()\\n new_failures = test_type.compare_output(\\n self._port, self._filename, self._options, driver_output,\\n expected_driver_output)\\n # Don't add any more failures if we already have a crash, so we don't\\n # double-report those tests. We do double-report for timeouts since\\n # we still want to see the text and image output.\\n if not driver_output.crash:\\n failures.extend(new_failures)\\n test_result_writer.write_test_result(\\n self._port, self._options.results_directory, self._filename,\\n driver_output, expected_driver_output, new_failures)\\n time_for_diffs[test_type.__class__.__name__] = (\\n time.time() - start_diff_time)\\n\\n total_time_for_all_diffs = time.time() - start_diff_time\\n return TestResult(self._filename, failures, driver_output.test_time,\\n total_time_for_all_diffs, time_for_diffs)\",\n \"def validation_epoch_end(self, outputs):\\n avg_loss = torch.stack([x[\\\"val_loss\\\"] for x in outputs]).mean()\\n tensorboard_logs = {\\\"val_loss\\\": avg_loss}\\n return {\\\"avg_val_loss\\\": avg_loss, \\\"log\\\": tensorboard_logs}\",\n \"def validation_epoch_end(self, outputs):\\n avg_loss = torch.stack([x[\\\"val_loss\\\"] for x in outputs]).mean()\\n tensorboard_logs = {\\\"val_loss\\\": avg_loss}\\n return {\\\"avg_val_loss\\\": avg_loss, \\\"log\\\": tensorboard_logs}\",\n \"def get_outputs(self, inputs):\\n \\n # Paths\\n input_path = self.input_path\\n output_path = self.output_path\\n\\n # Filename changes\\n output_extension = stringify(self.executor.output_extension)\\n output_prefix = stringify(self.executor.output_prefix) or ''\\n\\n if self.output:\\n # Combine all inputs into one output\\n output = output_prefix + change_extension(self.output, output_extension)\\n output = join_path(output_path, output)\\n \\n if self.output_transform:\\n output = self.output_transform(output)\\n \\n if self.run_output:\\n if self.run_command:\\n verify_type(self.run_command, list)\\n run_command = [stringify(v).format(output=output) for v in self.run_command]\\n else:\\n run_command = [output]\\n with current_context() as ctx:\\n ctx.current.project.run[self.run_output] = run_command\\n \\n return True, [Output(output_path, output)]\\n elif inputs:\\n # Each input matches an output\\n \\n # Strip prefix\\n if self.output_strip_prefix_from:\\n with current_context() as ctx:\\n _, p = ctx.current.project.get_phase_for(self.output_strip_prefix_from,\\n 'output_strip_prefix_from')\\n if p:\\n output_strip_prefix = p.output_path\\n else:\\n output_strip_prefix = None\\n else:\\n output_strip_prefix = stringify(self.output_strip_prefix)\\n if output_strip_prefix is None:\\n output_strip_prefix = input_path\\n if not output_strip_prefix.endswith(os.sep):\\n output_strip_prefix += os.sep\\n output_strip_prefix_length = len(output_strip_prefix)\\n \\n outputs = [] \\n for the_input in inputs:\\n output = the_input\\n \\n # Strip prefix\\n if output.startswith(output_strip_prefix):\\n output = output[output_strip_prefix_length:]\\n\\n # Filename changes\\n if output_prefix:\\n p, f = os.path.split(output)\\n output = join_path(p, output_prefix + f)\\n output = change_extension(output, output_extension)\\n \\n output = join_path(output_path, output)\\n\\n if self.output_transform:\\n output = self.output_transform(output)\\n\\n outputs.append(Output(output_path, output))\\n \\n return False, outputs\\n else:\\n return False, []\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6837641","0.67924696","0.6737341","0.6717199","0.65907484","0.64653313","0.64050525","0.6332762","0.6276232","0.62465364","0.62231946","0.61539495","0.6134005","0.61062723","0.6100173","0.60465825","0.60387117","0.6037164","0.60108835","0.60005236","0.59186393","0.59162885","0.5847018","0.5843437","0.5810045","0.5800307","0.57823455","0.57765514","0.5774133","0.5768928","0.5762034","0.5756177","0.57544506","0.57348514","0.57251865","0.57113135","0.5708255","0.5698998","0.568852","0.568852","0.56721234","0.56593335","0.56531864","0.56427693","0.56383","0.56383","0.5631596","0.5615691","0.561284","0.5609294","0.5609294","0.5609294","0.5609294","0.5600891","0.55810225","0.5575506","0.5570602","0.5568907","0.55381984","0.5536898","0.553552","0.55287206","0.5503354","0.5502427","0.55021334","0.5489169","0.5487788","0.5486073","0.5481114","0.5468121","0.5458374","0.5455963","0.54531276","0.5451641","0.5451387","0.5450865","0.5444401","0.54337955","0.542382","0.54232025","0.5420143","0.5413334","0.5404052","0.54022545","0.5401567","0.54004276","0.53998077","0.53991646","0.53884923","0.53881484","0.5383326","0.53778356","0.53735495","0.53701454","0.5365872","0.53606904","0.53561497","0.53515947","0.53515947","0.5349471"],"string":"[\n \"0.6837641\",\n \"0.67924696\",\n \"0.6737341\",\n \"0.6717199\",\n \"0.65907484\",\n \"0.64653313\",\n \"0.64050525\",\n \"0.6332762\",\n \"0.6276232\",\n \"0.62465364\",\n \"0.62231946\",\n \"0.61539495\",\n \"0.6134005\",\n \"0.61062723\",\n \"0.6100173\",\n \"0.60465825\",\n \"0.60387117\",\n \"0.6037164\",\n \"0.60108835\",\n \"0.60005236\",\n \"0.59186393\",\n \"0.59162885\",\n \"0.5847018\",\n \"0.5843437\",\n \"0.5810045\",\n \"0.5800307\",\n \"0.57823455\",\n \"0.57765514\",\n \"0.5774133\",\n \"0.5768928\",\n \"0.5762034\",\n \"0.5756177\",\n \"0.57544506\",\n \"0.57348514\",\n \"0.57251865\",\n \"0.57113135\",\n \"0.5708255\",\n \"0.5698998\",\n \"0.568852\",\n \"0.568852\",\n \"0.56721234\",\n \"0.56593335\",\n \"0.56531864\",\n \"0.56427693\",\n \"0.56383\",\n \"0.56383\",\n \"0.5631596\",\n \"0.5615691\",\n \"0.561284\",\n \"0.5609294\",\n \"0.5609294\",\n \"0.5609294\",\n \"0.5609294\",\n \"0.5600891\",\n \"0.55810225\",\n \"0.5575506\",\n \"0.5570602\",\n \"0.5568907\",\n \"0.55381984\",\n \"0.5536898\",\n \"0.553552\",\n \"0.55287206\",\n \"0.5503354\",\n \"0.5502427\",\n \"0.55021334\",\n \"0.5489169\",\n \"0.5487788\",\n \"0.5486073\",\n \"0.5481114\",\n \"0.5468121\",\n \"0.5458374\",\n \"0.5455963\",\n \"0.54531276\",\n \"0.5451641\",\n \"0.5451387\",\n \"0.5450865\",\n \"0.5444401\",\n \"0.54337955\",\n \"0.542382\",\n \"0.54232025\",\n \"0.5420143\",\n \"0.5413334\",\n \"0.5404052\",\n \"0.54022545\",\n \"0.5401567\",\n \"0.54004276\",\n \"0.53998077\",\n \"0.53991646\",\n \"0.53884923\",\n \"0.53881484\",\n \"0.5383326\",\n \"0.53778356\",\n \"0.53735495\",\n \"0.53701454\",\n \"0.5365872\",\n \"0.53606904\",\n \"0.53561497\",\n \"0.53515947\",\n \"0.53515947\",\n \"0.5349471\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5601338"},"document_rank":{"kind":"string","value":"53"}}},{"rowIdx":9094,"cells":{"query":{"kind":"string","value":"View all the images in the dataset, on a 3 by X grid size."},"document":{"kind":"string","value":"def view_images(dataset, size):\n images, labels = dataset\n assert images.shape[0] == labels.shape[0]\n\n num_images = images.shape[0]\n num_cols = 3\n num_rows = np.ceil(num_images / num_cols).astype(\"int\")\n plt.figure(figsize=size)\n for i in range(num_images):\n image = images[i]\n label = labels[i]\n ax = plt.subplot(num_rows, num_cols, i + 1)\n plt.imshow(np.array(image, dtype=\"float\"))\n plt.title(\"Number: \" + str(label))\n plt.axis(\"off\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def show_imgs(dataset, n_imgs, plot_size=(15, 15), cmap=None):\n n_cols = int(np.sqrt(n_imgs))\n n_rows = int(np.ceil(np.sqrt(n_imgs)))\n class_idx = dataset.class_to_idx\n idx_class = idx_to_class(class_idx)\n\n fig, axes = plt.subplots(n_rows, n_cols, figsize=plot_size)\n for i, ax in enumerate(axes.flatten()):\n ax.axis('off')\n title = f'Class : {idx_class[dataset.targets[i]]}'\n ax.imshow(dataset.data[i], cmap=cmap)\n ax.set_title(title)\n fig.tight_layout()","def display_sample_images(self):\n if self.train_dataset is None:\n self.init_datasets()\n\n images, labels = next(self.train_dataset)\n plt.figure(figsize=(5,5))\n for n in range(min(25, images.shape[0])):\n ax = plt.subplot(5,5,n+1)\n plt.imshow(images[n])\n if len(labels.shape) == 1:\n plt.title(self.class_names[int(labels[n])].title())\n else:\n m = np.argmax(labels[n])\n plt.title(self.class_names[int(labels[n, m])].title())\n plt.axis('off')\n\n plt.tight_layout()\n plt.show()","def PlotImages(x):\r\n # 5.1 Create figure-window and axes\r\n _, ax = plt.subplots(nrows = 2, ncols= 3)\r\n # 5.2\r\n ax[0,0].imshow(x[0, :].reshape(75,75))\r\n ax[0,1].imshow(x[1, :].reshape(75,75))\r\n ax[0,2].imshow(x[2, :].reshape(75,75))\r\n ax[1,0].imshow(x[3, :].reshape(75,75))\r\n ax[1,1].imshow(x[4, :].reshape(75,75))\r\n ax[1,2].imshow(x[5, :].reshape(75,75))\r\n plt.show()","def show_imagegrid_dataset(dataset,\n num=10,\n shuffle=True,\n classes='auto',\n figsize=None,\n fontsize=20,\n image_attr={'cmap': plt.cm.Greys_r}):\n sample = dataset[0]\n if isinstance(sample, tuple) and len(sample) == 2:\n images_per_class = get_labeled_imagegrid(dataset,\n num=num,\n shuffle=shuffle,\n classes=classes)\n num = min(num, max(map(len, images_per_class.values())))\n classes = list(images_per_class.keys())\n\n if figsize is None:\n figsize = (2 * num, 2 * len(classes))\n fig, axs = plt.subplots(figsize=figsize, nrows=len(classes), ncols=num)\n if len(classes) == 1:\n axs = np.expand_dims(axs, 0)\n if num == 1:\n axs = np.expand_dims(axs, -1)\n for i, (class_name, class_images) in enumerate(images_per_class.items()):\n for j, img in enumerate(class_images):\n show_image(img, axs[i][j], image_attr)\n axs[i][0].set_ylabel(str(class_name), fontsize=fontsize)\n elif isinstance(sample, (Image, torch.Tensor, np.ndarray)):\n image_list = get_imagegrid(dataset,\n num=num,\n shuffle=shuffle)\n num = min(len(image_list), num)\n nrows = math.ceil(math.sqrt(num))\n ncols = math.ceil(num / nrows)\n if figsize is None:\n figsize = (2 * nrows, 2 * ncols)\n fig, axs = plt.subplots(figsize=figsize, nrows=nrows, ncols=ncols)\n axs = axs.flatten()\n for i, img in enumerate(image_list):\n show_image(img, axs[i], image_attr)","def show_images(images, save=None, size=None):\n assert len(images) > 0, \"images should contain at least 1 element\"\n assert len(images[0].shape) == 3, \"each image should contain 3 elements (c, w,h)\"\n \n fig, ax = plt.subplots(nrows=images[0].shape[0], ncols=len(images))\n \n for i in range(len(images)): \n for j in range(images[0].shape[0]):\n ax[i,j].imshow(images[i][j,:,:], cmap='gray')\n \n plt.show()","def show_images(imgs, nrows, ncols, figsize=None):\n figsize = (ncols, nrows)\n _, figs = plt.subplots(nrows, ncols, figsize=figsize)\n for i in range(nrows):\n for j in range(ncols):\n figs[i][j].imshow(imgs[i*ncols+j].asnumpy())\n figs[i][j].axes.get_xaxis().set_visible(False)\n figs[i][j].axes.get_yaxis().set_visible(False)\n plt.show()","def view_image(train_dataloader):\n for (x, target) in train_dataloader:\n np.save(\"img.npy\", x)\n print(x.shape)\n exit(0)","def display_images_in_grid(imgs, row, col):\n if len(imgs) != (row * col):\n raise ValueError(f\"Invalid imgs len:{len(imgs)} col:{row} row:{col}\")\n\n for i, img in enumerate(imgs):\n plot_num = i + 1\n plt.subplot(row, col, plot_num)\n plt.tick_params(labelbottom=False) # remove x axis\n plt.tick_params(labelleft=False) # remove y axis\n plt.imshow(img)\n plt.show()","def grid(images, cols = 2, save = False, filename = \"\", show = False):\n \n rows = ceil(len(images) / cols)\n \n fig, ax = plt.subplots(rows, 1)\n\n index = 0\n element = []\n for row in range(rows):\n for col in range(cols): \n if index < len(images):\n element.append(images[index])\n index += 1\n \n stack = np.hstack(tuple(element))\n ax[row].axis('off')\n ax[row].imshow(stack)\n element = []\n \n plt.tight_layout()\n \n if save:\n fig.savefig(filename)\n\n if show:\n plt.show(fig)\n \n return 0","def display_images(digits_im):\n i = 0\n\n for img in digits_im:\n if i < N_NEIGHBOURS:\n # Visualize your data\n im_max = np.max(img)\n img = PIXELS * (np.abs(im_max - img) / im_max)\n res = cv2.resize(img, (DIM, DIM), interpolation=cv2.INTER_CUBIC)\n cv2.imwrite('digit ' + str(i) + '.png', res)\n i += 1\n else:\n break","def visulize_5(X):\n fig, axes1 = plt.subplots(5,5,figsize=(3,3))\n for j in range(5):\n for k in range(5):\n i = np.random.choice(range(len(X)))\n axes1[j][k].set_axis_off()\n axes1[j][k].imshow(X[:,i].reshape(32, 32, 3))\n plt.show()","def img_viewer_examples(images, labels, prediction = None, size=0, greyscale=False):\n batchSize = min(size, images.shape[0])\n \n if size == 0:\n batchSize = images.shape[0]\n\n # I CAN TAKE THE BATCH_SIZE from the images size/shape according the sent data type\n no_of_columns = round(math.sqrt(batchSize))\n no_of_rows = math.ceil(batchSize / no_of_columns)\n print(\"batch size {}, no_of_rows {}, no_of_columns {}\".format(batchSize, no_of_rows, no_of_columns))\n fig = plt.figure(figsize=(no_of_columns*1.25, no_of_rows*1.5))\n # (width, height)\n for idx in np.arange(batchSize):\n ax = fig.add_subplot(no_of_rows, no_of_columns,\n idx+1, xticks=[], yticks=[])\n if greyscale:\n ax.imshow(np.squeeze(images[idx]), cmap='gray')\n else:\n ax.imshow(np.squeeze(images[idx]))\n # print out the correct label for each image\n # .item() gets the value contained in a Tensor\n # WAIT FOR TASNEEM TO SEE THE RETURNED DATA TYPE\n if not prediction is None:\n ax.set_title(\"{} ({})\".format(str(prediction[idx]), str(labels[idx])),\n color=(\"green\" if prediction[idx] == labels[idx] else \"red\"))\n else:\n ax.set_title(str(labels[idx]))","def show_images(imgs, num_rows, num_cols, scale=2):\n figsize = (num_cols * scale, num_rows * scale)\n _, axes = plt.subplots(num_rows, num_cols, figsize=figsize)\n for i in range(num_rows):\n for j in range(num_cols):\n axes[i][j].imshow(imgs[i * num_cols + j].asnumpy())\n axes[i][j].axes.get_xaxis().set_visible(False)\n axes[i][j].axes.get_yaxis().set_visible(False)\n return axes","def imshow_grid(images, shape=[2, 8]):\n fig = plt.figure(1)\n grid = ImageGrid(fig, 111, nrows_ncols=shape, axes_pad=0.05)\n\n size = shape[0] * shape[1]\n for i in range(size):\n grid[i].axis('off')\n grid[i].imshow(images[i]) # The AxesGrid object work as a list of axes.\n\n plt.show()","def imshow_grid(images, shape=[2, 8]):\n fig = plt.figure(1)\n grid = ImageGrid(fig, 111, nrows_ncols=shape, axes_pad=0.05)\n\n size = shape[0] * shape[1]\n for i in range(size):\n grid[i].axis('off')\n grid[i].imshow(images[i]) # The AxesGrid object work as a list of axes.\n\n plt.show()","def imshow_grid(images, shape=[2, 2], name='default', save=False):\n fig = plt.figure()\n grid = ImageGrid(fig, 111, nrows_ncols=shape, axes_pad=0.05)\n\n size = shape[0] * shape[1]\n for i in range(size):\n grid[i].axis('off')\n img = images[i]\n if img.shape[0]==3:\n img = img.transpose(1, 2, 0)\n img = (img - img.min())/(img.max() - img.min())\n grid[i].imshow(img, vmin=-132, vmax = 164) # The AxesGrid object work as a list of axes.\n\n plt.show()","def show_imgs(imgs, row, col):\n if len(imgs) != (row * col):\n raise ValueError(\n \"Invalid imgs len:{} col:{} row:{}\".format(len(imgs), row, col))\n\n for i, img in enumerate(imgs):\n plot_num = i+1\n plt.subplot(row, col, plot_num)\n plt.tick_params(labelbottom=False) # x軸の削除\n plt.tick_params(labelleft=False) # y軸の削除\n plt.imshow(img)\n plt.show()","def show_images(imgs, num_rows, num_cols, scale=2):\n figsize = (num_cols*scale, num_rows*scale)\n _, axes = plt.subplots(num_rows, num_cols, figsize=figsize)\n for i in range(num_rows):\n for j in range(num_cols):\n # show the target image\n axes[i][j].imshow(imgs[i*num_cols+j])\n # set the sub-axis to be invisible\n axes[i][j].axes.get_xaxis().set_visible(False)\n axes[i][j].axes.get_yaxis().set_visible(False)\n # remember to show figure at last\n plt.show()\n return axes","def show_train_images(train_data, train_labels):\n plt.figure(1, figsize=(8, 8))\n n = 0\n\n for i in range(16):\n n += 1\n # each time random images are loaded\n # r = np.random.randint(0, train_data.shape[0], 1)\n plt.subplot(4, 4, n)\n plt.subplots_adjust(hspace=0.5, wspace=0.5)\n plt.imshow(train_data[i] / 255.)\n plt.title('{}'.format(train_labels[i]))\n plt.xticks([]), plt.yticks([])\n plt.show()","def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5): #@save\n figsize = (num_cols * scale, num_rows * scale)\n _, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)\n axes = axes.flatten()\n for i, (ax, img) in enumerate(zip(axes, imgs)):\n ax.imshow(d2l.numpy(img))\n ax.axes.get_xaxis().set_visible(False)\n ax.axes.get_yaxis().set_visible(False)\n if titles:\n ax.set_title(titles[i])\n return axes","def show_images(images, db):\n images = [int(image) for image in images]\n files = get_img_files(images, db)\n show_files(files)","def plot_100_images(X, indices=None):\n width, height = IMAGE_WIDTH, IMAGE_HEIGHT\n nrows, ncols = 10, 10\n if indices is None:\n indices = range(X.shape[0])\n indices_to_display = np.random.choice(indices, nrows * ncols)\n\n big_picture = np.zeros((height * nrows, width * ncols))\n\n irow, icol = 0, 0\n for idx in indices_to_display:\n if icol == ncols:\n irow += 1\n icol = 0\n iimg = X[idx].reshape(width, height).T # transpose the data set\n big_picture[irow * height:irow * height + iimg.shape[0],\n icol * width:icol * width + iimg.shape[1]] = iimg\n icol += 1\n plt.imshow(big_picture, cmap=matplotlib.cm.Greys_r)\n\n plt.show()","def display_data():\n data = read_data_from_file()\n data_size = len(data)\n print('Data size - ' + str(data_size))\n\n\n for i in range(data_size-1, 0, -1):\n image = data[i]\n cv2.imshow('window', image[0])\n print(str(image[1]))\n cv2.waitKey(50)","def show_image_grid(imgs):\n grd = make_grid(imgs)\n npimg = grd.numpy()\n plt.imshow(np.transpose(npimg, (1,2,0)), interpolation='nearest')\n plt.ion()\n plt.show()","def plot_n_image(X, n):\n pic_size = int(np.sqrt(X.shape[1]))\n grid_size = int(np.sqrt(n))\n\n first_n_images = X[:n, :]\n\n fig, ax_array = plt.subplots(nrows=grid_size, ncols=grid_size,sharey=True, sharex=True, figsize=(8, 8))\n\n for r in range(grid_size):\n for c in range(grid_size):\n ax_array[r, c].imshow(first_n_images[grid_size * r + c].reshape((pic_size, pic_size)))\n plt.xticks(np.array([]))\n plt.yticks(np.array([]))","def show_torch_imgs(imgs, nrow=8, figsize=(8, 5), axis_off=True , **opt):\n import torchvision\n import torch\n if not torch.is_tensor(imgs):\n # Not a torch tensor. Assume that it is torch.autograd.Variable\n # Try to get the tensor inside the Variable.\n try:\n imgs = imgs.data\n except:\n raise ValueError('Expect input imgs to be a torch Tensor or torch.autograd.Variable.')\n # https://gist.github.com/anonymous/bf16430f7750c023141c562f3e9f2a91\n img = torchvision.utils.make_grid(imgs, nrow=nrow, **opt)\n npimg = img.cpu().numpy()\n # make it height x width x channels\n npimg = np.transpose(npimg, (1, 2, 0))\n\n plt.figure(figsize=figsize)\n plt.imshow(npimg, interpolation='nearest')\n if axis_off:\n plt.axis('off')","def display_imgs(img_dir,img_list):\n for img in img_list:\n display_img(img_dir, img)","def plot_many_images(images, titles, rows=1, columns=2):\n for i, image in enumerate(images):\n plt.subplot(rows, columns, i + 1)\n plt.imshow(image, \"gray\")\n plt.title(titles[i])\n plt.xticks([]), plt.yticks([]) # Hide tick marks\n plt.show()","def show_images(images):\n for name, img in images:\n cv2.imshow(name, img)\n\n cv2.waitKey(0)","def three_sample_images():\n samples = samples_path()\n _truck = np.array(Image.open(os.path.join(samples, \"truck.png\")))\n _deer = np.array(Image.open(os.path.join(samples, \"deer.png\")))\n _frog = np.array(Image.open(os.path.join(samples, \"frog.png\")))\n truck = transforms.ToTensor()(_truck)\n deer = transforms.ToTensor()(_deer)\n frog = transforms.ToTensor()(_frog)\n return torch.stack([truck, deer, frog])","def displayData(indices_to_display = None):\n width, height = 20, 20\n nrows, ncols = 10, 10\n if not indices_to_display:\n indices_to_display = random.sample(range(X.shape[0]), nrows*ncols)\n \n big_picture = np.zeros((height*nrows,width*ncols))\n \n irow, icol = 0, 0\n for idx in indices_to_display:\n if icol == ncols:\n irow += 1\n icol = 0\n iimg = getDatumImg(X[idx])\n big_picture[irow*height:irow*height+iimg.shape[0], icol*width:icol*width+iimg.shape[1]] = iimg\n icol += 1\n fig = plt.figure(figsize=(6,6))\n\n big_picture = (big_picture * 255).astype(np.int8)\n img = Image.fromarray(big_picture, mode='L')\n plt.imshow(img, cmap = cm.Greys)","def grid_image(output):\n grid = []\n for data in output:\n grid += [make_grid(data, nrow=5, normalize=True)]\n return grid","def print_images(i, df):\n \n images_folder_path = \"dataset/petfinder-adoption-prediction/train_images/\"\n plt.imshow(cv2.cvtColor(cv2.imread(images_folder_path+df.filename[i]), cv2.COLOR_BGR2RGB),);\n plt.axis(\"off\");\n plt.show()","def display_images(filenames):\n for filename in filenames:\n display(Image(filename))","def show_data(self, samples=5):\n self._samples = samples\n \n idx = 0\n batch = next(iter(self._loader))\n while idx <= self._samples:\n\n (img_batch, label_batch) = batch\n\n fig = plt.figure()\n ax1 = fig.add_subplot(121)\n ax2 = fig.add_subplot(122)\n \n ax1.imshow(np.transpose(img_batch[idx], (1, 2, 0)))\n ax2.imshow(np.transpose(label_batch[idx], (1, 2, 0)).squeeze(dim=2))\n\n plt.show()\n idx += 1","def visualize_image(images, save_name):\n dim = images.shape[0]\n n_image_rows = int(np.ceil(np.sqrt(dim)))\n n_image_cols = int(np.ceil(dim * 1.0 / n_image_rows))\n gs = gridspec.GridSpec(n_image_rows, n_image_cols, top=1., bottom=0.,\n right=1., left=0., hspace=0., wspace=0.)\n\n for g, count in zip(gs, range(int(dim))):\n ax = plt.subplot(g)\n ax.imshow(images[count, :].astype(np.float32).reshape((28, 28)))\n ax.set_xticks([])\n ax.set_yticks([])\n plt.savefig(save_name + '_vis.png')","def plot_gallery(images , h, w, n_row=3, n_col=6):\n plt.figure(figsize=(1.7 * n_col, 2.3 * n_row))\n plt.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35)\n for i in range(len(images)):\n plt.subplot(n_row, n_col, i + 1)\n plt.imshow(images[i].reshape((h, w)), cmap=plt.cm.gray)\n\n plt.xticks(())\n plt.yticks(())","def plot_10_by_10_images(images):\n\n\tn = images.shape[0]\n\n\tq = n // 10\n\tr = n%10\n\tprint n,q,r\n\n\tfig = plt.figure()\n\tplt.ion()\n\n\tfor x in range(q):\n\t\tprint x\n\t\tif not x%10:\n\t\t\tplt.clf()\n\t\tfor y in range(10):\n\t\t\tax = fig.add_subplot(10, 10, 10*y+x%10+1)\n\t\t\tax.matshow(images[10*y+x%10], cmap = mpl.cm.binary)\n\t\t\tplt.xticks(np.array([]))\n\t\t\tplt.yticks(np.array([]))\n\t\tplt.show()\n\t\t_=raw_input(\"Press enter to show next 10\")","def read_vanhateren_images (n_imgs=5):\n folder_name = r'D:\\VanHateren\\vanhateren_imc' # change this to point to the directory which holds the van hateren data\n # files = listdir(folder_name)\n onlyfiles = [ f for f in listdir(folder_name) if isfile(join(folder_name,f)) ]\n imgs = []\n for i in range(n_imgs):\n filename = join(folder_name, onlyfiles[i])\n with open(filename, 'rb') as handle:\n s = handle.read()\n arr = array.array('H', s)\n arr.byteswap()\n img_i = np.array(arr, dtype='uint16').reshape(1024, 1536)\n imgs.append(img_i) \n return imgs\n #pylab.imshow(img)\n #pylab.show()","def show_four_images(img1, img2, img3, img4, title):\n shape = (460, 250)\n # Get all images in same size for better display\n img1 = cv2.resize(img1, shape)\n img2 = cv2.resize(img2, shape)\n img3 = cv2.resize(img3, shape)\n img4 = cv2.resize(img4, shape)\n # combined 2 images horizontally\n numpy_horizontal1 = np.hstack((img1, img2))\n # combined the rest 2 images horizontally\n numpy_horizontal2 = np.hstack((img3, img4))\n # now combined all vertically to 1 image and display\n numpy_vertical = np.vstack((numpy_horizontal1, numpy_horizontal2))\n # final thing - show the output:\n show_image(numpy_vertical, title)","def plot_images(imgs, layout, img_sz = 0.7, suptitle = ''):\n\tnrows, ncols = layout \n\tfig, axes = plt.subplots(nrows, ncols, \n\t\tfigsize = (img_sz * ncols, img_sz * nrows))\n\taxes = axes.ravel()\n\tfig.subplots_adjust(hspace = 0, wspace = 0)\n\tfig.suptitle(suptitle)\n\tfor i, img in enumerate(imgs):\n\t\taxes[i].get_xaxis().set_visible(False)\n\t\taxes[i].get_yaxis().set_visible(False)\n\t\taxes[i].imshow(img)","def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()","def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()","def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()","def images(self, **kwargs):\n\n raise NotImplementedError","def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()\n # plt.savefig('./drive/My Drive/Colab Notebooks/TACK/Large/result' + ' '.join(name.split('_')).title() + '.png')","def load_images(folder_path, num_images):\n imgs = np.zeros(shape=[num_images, 400, 400, 3])\n for i in range(1, num_images + 1):\n image_name = \"satImage_%.3d\" % i\n image_path = folder_path + image_name + \".png\"\n if os.path.isfile(image_path):\n print('Loading ' + image_path)\n img = mpimg.imread(image_path)\n\n #imgs[i - 1] = np.asarray(img).reshape(400, 400, 3)\n imgs[i - 1] = img.reshape(400, 400, 3)\n else:\n print('File ' + image_path + ' does not exist')\n return imgs","def plot_latent_images(self, n):\n\n norm = tfp.distributions.Normal(0, 1)\n grid_x = norm.quantile(np.linspace(0.05, 0.95, n))\n grid_y = norm.quantile(np.linspace(0.05, 0.95, n))\n image_width = self.data.digit_size*n\n image_height = image_width\n image = np.zeros((image_height, image_width))\n\n for i, yi in enumerate(grid_x):\n for j, xi in enumerate(grid_y):\n z = np.array([[xi, yi]])\n x_decoded = self.model.sample(z)\n digit = tf.reshape(x_decoded[0], (self.data.digit_size, self.data.digit_size))\n image[i * self.data.digit_size: (i + 1) * self.data.digit_size,\n j * self.data.digit_size: (j + 1) * self.data.digit_size] = digit.numpy()\n\n plt.figure(figsize=(10, 10))\n plt.imshow(image, cmap='Greys_r')\n plt.axis('Off')\n plt.show()","def extract_images(dimension = (_HEIGHT, _WIDTH), n = 100, color = True, include = ['00', '01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12', '13']):\n # establish directory routes\n origin = '/Users/jaoming/Active Projects/Shopee Challenge/shopee-product-detection-dataset'\n main_train_folder = '/Users/jaoming/Active Projects/Shopee Challenge/shopee-product-detection-dataset/train/train'\n os.chdir(main_train_folder)\n if color:\n imread_color = cv2.IMREAD_COLOR\n else:\n imread_color = cv2.IMREAD_GRAYSCALE\n\n # setting up the variables \n data, labels = [], []\n for name in include:\n os.chdir(name)\n image_namelist = os.listdir()\n if '.DS_Store' in image_namelist: # removing unnecessary files\n image_namelist.remove('.DS_Store')\n count = 0\n while count < n:\n data.append(cv2.resize(\n cv2.imread(image_namelist[count], imread_color),\n dimension,\n interpolation = cv2.INTER_CUBIC\n ))\n labels.append(int(name))\n count += 1\n os.chdir(main_train_folder)\n\n os.chdir(origin)\n return data, labels","def plot_images_grid(images, labels, title):\n images = images.cpu()\n labels = labels.cpu()\n \n assert type(images[0]) is torch.Tensor, 'Image to plot is not torch.Tensor'\n image_size = int(np.sqrt(images[0].shape[0]))\n \n fig = plt.figure(figsize=(10,4))\n for idx in range(10):\n ax = fig.add_subplot(2,10/2,idx+1, xticks=[], yticks=[])\n ax.imshow(images[idx].view(image_size, image_size), cmap = 'gray')\n label = labels[idx].item()\n ax.set_title(label)\n #end\n fig.suptitle(title, fontsize = 14)\n plt.show()\n plt.close('all')","def visualize(base_path, test_dataset, plot_dir, batch_size=4, ):\n device = torch.device('cuda')\n dataset = HeadDataset(test_dataset,\n base_path,\n dataset_param={},\n train=False)\n batch_iterator = iter(data.DataLoader(dataset, batch_size,\n shuffle=False,\n num_workers=4,\n collate_fn=coco_collate))\n for ind, (images, targets) in enumerate(tqdm(batch_iterator)):\n images = list(img.to(device) for img in images)\n np_images = [(ims.cpu().numpy()*255.).astype(np.uint8) for ims in images]\n gt_boxes = [gt['boxes'].numpy().astype(np.float64) for gt in targets]\n for np_im, gt_box in zip(np_images, gt_boxes):\n plot_images = plot_ims(np_im, [], gt_box)\n imsave(osp.join(plot_dir, str(ind) + '.jpg'), plot_images)","def collage(images, cols = 2, save = False, filename = \"\", show = False):\n \n rows = ceil(len(images) / cols)\n \n fig, ax = plt.subplots(rows, cols)\n\n index = 0\n\n for row in range(rows):\n for col in range(cols):\n \n if index < len(images):\n ax[row, col].imshow(images[index])\n \n ax[row, col].axis('off')\n index += 1\n plt.tight_layout()\n \n if save:\n fig.savefig(filename)\n\n if show:\n plt.show(fig)\n \n return 0","def visualization(data, rows, cols, titles, figsize):\n fig, ax = plt.subplots(nrows=rows, ncols=cols, figsize=figsize)\n # plot image on each subplot\n for i, axi in enumerate(ax.flat):\n # i is in range [0, nrows * ncols)\n # axi is equivalent to ax[rowid][colid]\n axi.imshow(data[i])\n axi.set_title(titles[i])\n plt.tight_layout(True)\n plt.show()","def load_dataset(path_test, width, height):\n tot_images = 0\n for label in listdir(path_test):\n label_full = join(path_test, label)\n for img_name in listdir(label_full):\n tot_images += 1\n\n # allocate the memory\n # THE DTYPE is float, should be the right one\n all_images = np.zeros((tot_images, width, height, 3))\n\n true_labels = []\n num_images = 0\n for label in listdir(path_test):\n label_full = join(path_test, label)\n for img_name in listdir(label_full):\n # for img_name in listdir(label_full)[:10]:\n img_name_full = join(label_full, img_name)\n print(f\"Opening {img_name_full} {width}\")\n\n image = cv2.imread(img_name_full)\n\n image = cv2.resize(image, (width, height))\n\n # scale the pixel values to [0, 1]\n image = image.astype(\"float\") / 255.0\n\n all_images[num_images, :, :, :] = image\n\n num_images += 1\n true_labels.append(label)\n\n print(f\"All_images.shape {all_images.shape}\")\n\n # cv2.imshow('Resized all_images[0]', all_images[0])\n # cv2.waitKey(0)\n\n return all_images, true_labels","def show(self):\n \n \n \n \n \n \n r = 4\n f, axarr = plt.subplots(r, r, figsize=(8,8))\n counter = 0\n for i in range(r):\n for j in range(r):\n temp = self.x[counter,:]\n counter += 1\n img = self.x[counter,:]\n axarr[i][j].imshow(img)\n #######################################################################\n # #\n # #\n # TODO: YOUR CODE HERE #\n # #\n # #\n #######################################################################","def plot_images(imgs_org, imgs_pred, nb_examples=10):\n if nb_examples == 0:\n return\n\n n = nb_examples\n plt.figure(figsize=(nb_examples * 2, 4))\n for i in range(n):\n # display original\n ax = plt.subplot(2, n, i + 1)\n plt.imshow(imgs_org[i].reshape(84, 84))\n plt.gray()\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n\n # display reconstruction\n ax = plt.subplot(2, n, i + 1 + n)\n plt.imshow(imgs_pred[i].reshape(84, 84))\n plt.gray()\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n plt.show()","def displayFaceData(X, rows, cols):\n\twidth, height = 32, 32 # This is the shape of original photo (32*32)\n\tpictures_combined = np.zeros((height*rows, width*cols))\n\t\n\trow, col = 0, 0\n\tfor a_picture_index in xrange(rows*cols):\n\t\tif col == cols:\n\t\t\trow += 1\n\t\t\tcol = 0\n\t\ta_picture = ReshapeIntoImage(X[a_picture_index],width)\n\t\tpictures_combined[row*height:(row*height+a_picture.shape[0]), col*width:(col*width+a_picture.shape[1])] = a_picture\n\t\tcol += 1\n\n\tfig = plt.figure(figsize=(10,10))\n\timg = scipy.misc.toimage( pictures_combined )\n\tplt.imshow(img,cmap = cm.Greys_r)\n\tplt.show(block=False)","def main():\n labels, data = load_image_data()\n print(labels.shape, data.shape)","def retrieve_images(self, batch_size=5, offset=0):\n\t\treturn self.session.query(Image.id, Image.image_path, Image.quantity, Image.cost) \\\n\t\t\t\t\t\t .order_by(Image.id.desc()).offset(offset).limit(batch_size).all()","def display_image(df, fname_col, img_dir, n):\n\t# Display some train images\n\tnrows = 1+n//20 \n\tfig, axs = plt.subplots(nrows,20, figsize=(20,1.2*nrows),\n\t\t\t\t\t\t facecolor='w', edgecolor='k')\n\taxs = axs.ravel()\n\n\tfor idx, filename in enumerate (df[fname_col][0:n].values):\n\n\t\tif not os.path.isfile(img_dir+filename):\n\t\t\tlogger.error(\"path {} does not exit\".format(img_dir+filename))\n\t\t\t\t\t\t\n\t\timg = mpimg.imread(img_dir + filename)\n\n\t\taxs[idx].imshow(img)\n\t\taxs[idx].set_axis_off()\n\t \n\tplt.subplots_adjust(wspace=0, hspace=0)\n\tplt.show()","def loadDataset(dataset):\n # List of images.\n images = []\n\n\n\n # Read all filenames from the dataset.\n for filename in dataset:\n # Read the input image.\n image = cv2.imread(filename)\n\n # Add the current image on the list.\n if image is not None: \n images.append(image)\n else:\n print(\"Could not read file: {}\".format(filename))\n sys.exit()\n\n # Return the images list.\n return images","def graphical(cls, images):\n images = [(plt.imread(i), i.split(os.path.sep)[-1]) for i in images]\n views = [View(ViewPosition.click(img, path), img, img) for img, path in images]\n return cls(views)","def show_slice(file_path, x, y, z):\n img = nib.load(file_path)\n img = img.get_fdata()\n print(\"The scan has dimensions {}.\".format(img.shape))\n slice_0 = img[x, :, :]\n slice_1 = img[:, y, :]\n slice_2 = img[:, :, z]\n slices = [slice_0, slice_1, slice_2]\n fig, axes = plt.subplots(1, len(slices), figsize=[12, 4])\n for i, sli in enumerate(slices):\n axes[i].imshow(sli.T, cmap=\"gray\", origin=\"lower\")","def images(self):\n return self.gameimage_set.all()","def generate_image_grid(sess, df, filenames,op, op2):\n #x_points = np.arange(0, 1, 1.5).astype(np.float32)\n #y_points = np.arange(0, 1, 1.5).astype(np.float32)\n\n nx, ny = 12, 1\n #plt.subplot()\n gs = gridspec.GridSpec(nx, ny, hspace=1, wspace=0.05)\n # input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\n #\n # plt.imshow(np.array(df[0].tolist()).reshape(28, 28), cmap='gray')\n # plt.show()\n # x = sess.run(op, feed_dict={decoder_input: input_x[0].reshape(1,2)})\n # img = np.array(x.tolist()).reshape(28, 28)\n #\n # plt.imshow(img, cmap='gray')\n # plt.show()\n\n \"\"\" grid \"\"\"\n input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\n for i, g in enumerate(gs):\n\n x = sess.run(op, feed_dict={decoder_input: input_x[i].reshape(1,2)})\n ax = plt.subplot(g)\n img = np.array(x.tolist()).reshape(28, 28)\n ax.imshow(img, cmap='gray')\n ax.set_xticks([])\n ax.set_yticks([])\n #ax.set_aspect('auto')\n ax.set_title(filenames[i])\n plt.show()\n\n for i, g in enumerate(gs):\n\n ax = plt.subplot(g)\n img = np.array(df[i].tolist()).reshape(28, 28)\n ax.imshow(img, cmap='gray')\n ax.set_xticks([])\n ax.set_yticks([])\n #ax.set_aspect('auto')\n ax.set_title(filenames[i])\n plt.show()","def plot_gallery(self,images, titles, h, w, n_row=5, n_col=5):\n plt.figure(figsize=(1.8 * n_col, 2.4 * n_row))\n plt.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35)\n for i in range(n_row * n_col):\n plt.subplot(n_row, n_col, i + 1)\n plt.imshow(images[i].reshape((h, w)), cmap=plt.cm.gray)\n plt.title(titles[i], size=12)\n plt.xticks(())\n plt.yticks(())\n plt.show()","def showImages(images):\n idx = 0\n\n while True:\n\n cv2.imshow(\"Image\", images[idx])\n\n if cv2.waitKey(15) & 0xFF == ord(\"d\"):\n if idx+1 >= len(images):\n print(\"This is the last image in the set.\")\n else:\n idx += 1\n print(\"Viewing image no. {0} / {1}\".format(idx+1, len(images)))\n\n if cv2.waitKey(15) & 0xFF == ord(\"a\"):\n if idx-1 < 0:\n print(\"This is the first image in the set.\")\n else:\n idx -= 1\n print(\"Viewing image no. {0} / {1}\".format(idx+1, len(images)))\n\n if cv2.waitKey(15) & 0xFF == ord(\"q\"):\n break","def displayImages(self):\n\n plt.figure(figsize=(8,6))\n plt.subplot(1,2,1)\n plt.imshow( self.original_image, cmap=\"gray\")\n plt.title(\"Original Image\")\n plt.subplot(1,2,2)\n plt.imshow( self.blurred_image, cmap=\"gray\")\n plt.title(\"Blurred Image\")","def vis(group, indexlist, save=False):\n ##### Modify these: #####\n # imageloc = '/home/teja/Project_005/toronto/iaprtc12/images/'\n # trainloc = '/home/teja/Project_005/toronto/iaprtc12_2/iaprtc12_train_list.txt'\n # testloc = '/home/teja/Project_005/toronto/iaprtc12_2/iaprtc12_test_list.txt'\n #########################\n\n ##### Modify these: #####\n imageloc = '/home/teja/Programs/convnet/examples/imagenet/'\n trainloc = '/home/teja/Project_005/toronto/iaprtc12_2/iaprtc12_train_list.txt'\n testloc = '/home/teja/Programs/convnet/examples/imagenet/images_list.txt'\n #########################\n\n\n if group == 'train':\n listloc = trainloc\n else:\n listloc = testloc\n f = open(listloc, 'rb')\n ims = []\n for line in f:\n ims.append(line.strip() + '.jpg')\n f.close()\n for i in range(len(indexlist)):\n imloc = imageloc + ims[indexlist[i]]\n im = Image.open(imloc)\n # im.thumbnail((256,256), Image.ANTIALIAS)\n # im.show()\n if save:\n im.save('r' + str(indexlist[i]) + '.jpg')","def getimgs():","def makeImage(self):\n\n for row in range(self.height):\n self.makeRow(row)\n self.window.update() # display a row of pixels","def visualize(**images):\r\n n_images = len(images)\r\n plt.figure(figsize=(20, 8))\r\n for idx, (name, image) in enumerate(images.items()):\r\n plt.subplot(1, n_images, idx + 1)\r\n plt.xticks([])\r\n plt.yticks([])\r\n # get title from the parameter names\r\n plt.title(name.replace('_', ' ').title(), fontsize=20)\r\n plt.imshow(image)\r\n plt.show()","def plot_image_grid(epoch, generated_images):\n\n fig = plt.figure(figsize=(GRID_SIZE, GRID_SIZE))\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.001, hspace=0.001)\n\n for ind in range(GRID_IMGS):\n ax = fig.add_subplot(GRID_SIZE, GRID_SIZE, ind + 1, xticks=[], yticks=[])\n ax.imshow(np.uint8(((generated_images[ind] + 1) / 2) * 255), cmap='gray')\n\n plt.savefig('/content/drive/My Drive/WGAN/train_images/image_iteration_{:05d}.png'.format(epoch + 1))\n plt.close()","def display(self):\n fig, axes = plt.subplots(1, len(self.views),\n figsize=self._figsize(\n [(self.views[0].image, len(self.views))]),\n squeeze=True)\n for ax, view in zip(axes.ravel(), self.views):\n ax.imshow(view.grey)\n points = self._common_keypoints(view).reshape(-1, 2)[::-1]\n ax.plot(points[..., 0], points[..., 1], 'r+')\n ax.axis('off')\n ax.xaxis.set_visible(False)\n ax.yaxis.set_visible(False)\n ax.set(title=view.position.id)\n fig.tight_layout()\n fig.canvas.draw()\n img_array = np.array(fig.canvas.renderer._renderer)\n plt.close('all')\n return img_array","def display_some_traffic_sign_examples(path):\n\n images_paths = glob.glob(path + \"\\\\*.png\") # image paths\n plt.figure(figsize = (10, 10))\n\n for i in range(25):\n # select a random index in the dataset\n idx = np.random.randint(0, len(images_paths) - 1)\n img = imread(images_paths[idx])\n\n # subplot the dataset examples\n plt.subplot(5, 5, i + 1)\n plt.tight_layout(rect = [0, 0, 1, 0.95])\n plt.imshow(img)\n\n plt.suptitle(\"Dataset Examples\")\n plt.show()","def plot_gallery(images, titles, n_row=3, n_col=4):\n plt.figure(figsize=(2.5 * n_col, 2.4 * n_row))\n plt.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35, wspace = .35)\n for i in range(n_row * n_col):\n plt.subplot(n_row, n_col, i + 1)\n #plt.imshow(images[i].reshape((h, w)), cmap=plt.cm.gray)\n # image = images[i].reshape(h, w)\n # img = []\n # for j in range(len(image)):\n # img.append(list(image[j]))\n # #print(img[:5])\n plt.imshow(images[i])\n #plt.imshow(images[i])\n plt.title(titles[i], size=12)\n plt.xticks(())\n plt.yticks(())","def plot_gallery(images, titles, h, w, n_row=3, n_col=4):\n pl.figure(figsize=(1.8 * n_col, 2.4 * n_row))\n pl.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35)\n for i in range(n_row * n_col):\n pl.subplot(n_row, n_col, i + 1)\n pl.imshow(images[i].reshape((h, w)), cmap=pl.cm.gray)\n pl.title(titles[i], size=12)\n pl.xticks(())\n pl.yticks(())","def process_images(self, images, mode='train'):\n if self.dataset_name == 'dataset1':\n return images[:5000]\n elif self.dataset_name == 'dataset2':\n return np.add(images, 745)\n elif self.dataset_name == 'dataset3':\n # concatenate three images into three-digit image\n if mode == 'train':\n return np.concatenate((images[:40000], images[10000:50000],\n images[20000:60000]), axis=1)\n elif mode == 'test':\n return np.concatenate((images[:8000], images[1000:9000],\n images[2000:10000]), axis=1)\n elif self.dataset_name == 'dataset4':\n # merge two images into one\n if mode == 'train':\n return images[:50000] + images[-50000:]\n elif mode == 'test':\n return images[:9000] + images[-9000:]\n else:\n return images","def _showphotos(self, btn):\n global layout\n global curdir\n\n # Create the layouts.\n layout = GridLayout(cols=5, padding=0, spacing=0, size_hint=(1, None))\n layout.bind(minimum_height=layout.setter(\"height\"))\n\n foldername = btn\n\n # Args is combined with \"curdir\" to load the thumbnails, and add them to the Gridlayout.\n if foldername == \"\":\n pass\n else:\n for filename in sorted(glob(join(curdir, \"thumb\", foldername, \"*\"))):\n try:\n canvas = BoxLayout(size_hint=(1, None))\n im = Image(source=filename)\n canvas.add_widget(im)\n layout.add_widget(canvas)\n\n except Exception:\n print(\"Pictures: Unable to load <%s>\" % filename)\n\n return layout","def crop_images(dataset_dir):\n data = []\n for folder in os.listdir(dataset_dir):\n path = os.path.join(dataset_dir, folder, \"*.png\")\n data.extend(glob(path))\n\n for index, filePath in enumerate(data):\n print ('{}/{}'.format(index, len(data)))\n\n img = scipy.misc.imread(filePath).astype(np.uint8)\n img = scipy.misc.imresize(img, 0.25, interp='bilinear', mode=None)\n scipy.misc.imsave('/data/vllab1/dataset/CITYSCAPES/CITY_test/fine_image/' + filePath.split('/')[-1], img)","def plotImages(images_arr):\n \n fig, axes = plt.subplots(1, 5, figsize=(20,20))\n axes = axes.flatten()\n for img, ax in zip( images_arr, axes):\n ax.imshow(img)\n ax.axis('off')\n plt.tight_layout()\n plt.show()\n \n return","def images_example(path='train_images.pickle'):\n patch_size = (8, 8)\n\n with open('train_images.pickle', 'rb') as f:\n train_pictures = pickle.load(f)\n\n patches = sample_patches(train_pictures, psize=patch_size, n=20000)\n\n plt.figure()\n plt.imshow(train_pictures[0])\n plt.title(\"Picture Example\")\n\n plt.figure()\n for i in range(4):\n plt.subplot(2, 2, i + 1)\n plt.imshow(patches[:, i].reshape(patch_size), cmap='gray')\n plt.title(\"Patch Example\")\n plt.show()","def build_dataset(self):\n print(\"reading data of images currently , please wait......\")\n x_train, y_train, _ = get_images(self.train_directory)\n x_test, y_test, _ = get_images(self.test_directory)\n x_train, y_train = image_subset(self.num_classes, x_train, y_train)\n x_test, y_test = image_subset(self.num_classes, x_test, y_test)\n x_train = x_train.astype('float32')\n x_test = x_test.astype('float32')\n self.x_train = x_train / 255\n self.x_test = x_test / 255\n self.y_train = utils.to_categorical(y_train, self.num_classes)\n self.y_test = utils.to_categorical(y_test, self.num_classes)","def display_images(images, imageConversion=cv.COLOR_BGR2RGB, titles=[], columns=4, rows=None, show=True):\n if not show:\n return\n if imageConversion is not None:\n images = [cv.cvtColor(img, imageConversion) for img in images]\n\n # append filtered image\n if rows is None:\n rows = ceil(float(len(images)) / columns)\n\n try:\n for i in xrange(len(images)):\n plt.subplot(rows,columns,i+1),plt.imshow(images[i],'gray')\n if titles:\n plt.title(titles[i])\n plt.xticks([]),plt.yticks([])\n plt.show()\n except:\n logging.exception(\"Could not plot / show images. Saving instead.\")\n save_plt_figure(plt, \"img_show\")","def plotgrid(data,d=10,shape=(30,30)):\n ion()\n gray()\n clf()\n for i in range(min(d*d,len(data))):\n subplot(d,d,i+1)\n row = data[i]\n if shape is not None: row = row.reshape(shape)\n imshow(row)\n ginput(1,timeout=0.1)","def plot_sample_imgs(get_imgs_fun, img_shape, plot_side=5, savepath=None):\n f, axarr = plt.subplots(plot_side, plot_side)\n samples = get_imgs_fun(plot_side*plot_side)\n for row in range(plot_side):\n for col in range(plot_side):\n axarr[row, col].imshow(samples[plot_side*row+col].reshape(img_shape))\n axarr[row, col].set_title('')\n axarr[row, col].axis('off')\n if savepath:\n f.savefig(savepath)\n plt.close()\n else:\n plt.show()","def visualize(**images):\n n_images = len(images)\n plt.figure(figsize=(20,8))\n for idx, (name, image) in enumerate(images.items()):\n plt.subplot(1, n_images, idx + 1)\n plt.xticks([]); \n plt.yticks([])\n # get title from the parameter names\n plt.title(name.replace('_',' ').title(), fontsize=20)\n plt.imshow(image)\n plt.savefig('sample_gt_pred_2_max.jpeg')\n plt.show()","def init_datasets(self, display_samples = False):\n print(\"==> Loading images from \", self.img_dir)\n self.image_data_gen = ImageDataGenerator(\n rescale=1./255,\n #rotation_range=30,\n #shear_range=30,\n #width_shift_range=.15,\n #height_shift_range=.15,\n #zoom_range=0.5,\n validation_split=0.2)\n\n self.train_dataset = self.image_data_gen.flow_from_directory(\n batch_size=BATCH_SIZE,\n directory=self.img_dir,\n shuffle=True,\n target_size=self.img_size,\n class_mode='sparse',\n subset='training')\n\n self.val_dataset = self.image_data_gen.flow_from_directory(\n batch_size=BATCH_SIZE,\n directory=self.img_dir,\n shuffle=True,\n target_size=self.img_size,\n class_mode='sparse',\n subset='validation')\n\n if display_samples:\n self.display_sample_images()","def plotRandImages(train_data, output):\n rint_array = np.random.randint(0,train_data.shape[0],size=4)\n\n fig = plt.figure(figsize=(8,8))\n plt.subplot(2,2,1)\n for ii,rint in enumerate(rint_array):\n plt.subplot(2,2,ii+1)\n img = train_data[rint].reshape((20,20)).T\n #print \" output: \",output[rint]\n plt.imshow(img,aspect='auto',interpolation='nearest',\n origin='lower')\n plt.title('Image of %d'%output.T[rint])\n plt.show()\n\n return","def display(self):\n nrow = 2\n ncol = len(self.views) + 1\n rows = [(self.views[0].original, len(self.views)),\n (self.views[0].image, len(self.views) + 1)]\n fig, axes = plt.subplots(nrows=nrow, ncols=ncol,\n figsize=self._figsize(rows),\n squeeze=True)\n originals = [(v.position.id, v.original) for v in self.views] + [\n ('combined', np.median(np.stack([v.original for v in self.views]), axis=0))]\n warped = [(v.position.id, v.image) for v in self.views] + [\n ('combined', self.image)]\n for ax, (title, img) in zip(axes.ravel(), originals + warped):\n ax.imshow(img)\n ax.axis('off')\n ax.xaxis.set_visible(False)\n ax.yaxis.set_visible(False)\n ax.set(title=title)\n fig.tight_layout()\n fig.canvas.draw()\n img_array = np.array(fig.canvas.renderer._renderer)\n plt.close('all')\n return img_array","def plot_gallery(images, titles, h, w, n_row=3, n_col=4):\n plt.figure(figsize=(1.8 * n_col, 2.4 * n_row))\n plt.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35)\n for i in range(n_row * n_col):\n plt.subplot(n_row, n_col, i + 1)\n plt.imshow(images[i].reshape((h, w)), cmap=plt.cm.gray)\n plt.title(titles[i], size=12)\n plt.xticks(())\n plt.yticks(())\n plt.show()\n plt.savefig(\"feature_{}.png\".format(50))","def visualize(imgobjs, cols=4, collated=True, size=None):\n\n ## Separate into list of single instance image objects\n imgs = []\n if isinstance(imgobjs, list):\n for io in imgobjs:\n imgs += images._create_img_list(io)\n else:\n imgs = images._create_img_list(imgobjs)\n\n ## Grid layout settings. Sets N, N_rows, N_cols\n N = len(imgs)\n assert N > 0\n if not size:\n size = [0, 0] # H, W\n for img in imgs:\n _, _, H, W = get_dimensions(img)\n size[0] += H\n size[1] += W\n size = [int(d/len(imgs)) for d in size]\n else:\n assert len(size) == 2\n\n N_cols = cols if cols else 4\n if N < 4:\n N_cols = N\n N_rows = math.ceil(N/N_cols)\n print(f\"Cols: {N_cols}, Rows: {N_rows}\")\n\n ## Display Figure\n figure = plt.figure(figsize=(15, 10))\n for i in range(N):\n dims = images.get_dimensions(imgs[i])[1:]\n title = f\"[Image {i+1}/{N}]\"\n if isinstance(imgs[i], str):\n title = f\"[Image {i+1}/{N}] {files.get_filename(imgs[i])}\"\n title += f\"\\n shape{dims}\"\n img = images.to_np(imgs[i], size=size, color='rgb')\n subplt = figure.add_subplot(N_rows, N_cols, i+1)\n subplt.set_title(title, fontsize=10)\n subplt.axis('off')\n plt.imshow(img)\n figure.tight_layout()\n # plt.subplots_adjust(wspace=.25, hspace=.5)\n plt.show()","def display_dataset(path, save, dset='sum'):\n # List datasets\n files_surf = os.listdir(path[0])\n files_surf.sort()\n files_deep = os.listdir(path[1])\n files_deep.sort()\n files_calc = os.listdir(path[2])\n files_calc.sort()\n\n # Corrected names\n files = os.listdir(r'Y:\\3DHistoData\\Subvolumes_2mm')\n files.sort()\n\n k = 0\n # Loop for displaying images\n for fsurf, fdeep, fcalc in zip(files_surf, files_deep, files_calc):\n # Load images\n im_surf = loadh5(path[0], fsurf, dset)\n im_deep = loadh5(path[1], fdeep, dset)\n im_calc = loadh5(path[2], fcalc, dset)\n # Create figure\n fig = plt.figure(dpi=300)\n ax1 = fig.add_subplot(131)\n ax1.imshow(im_surf, cmap='gray')\n plt.title(fsurf + ', Surface')\n ax2 = fig.add_subplot(132)\n ax2.imshow(im_deep, cmap='gray')\n plt.title('Deep')\n ax3 = fig.add_subplot(133)\n ax3.imshow(im_calc, cmap='gray')\n plt.title('Calcified')\n if save is not None:\n while files[k] == 'Images' or files[k] == 'MeanStd':\n k += 1\n\n # Save figure\n if not os.path.exists(save):\n os.makedirs(save, exist_ok=True)\n plt.tight_layout()\n fig.savefig(os.path.join(save, files[k]), bbox_inches=\"tight\", transparent=True)\n plt.close()\n\n # Save h5\n if not os.path.exists(save + '\\\\MeanStd\\\\'):\n os.makedirs(save + '\\\\MeanStd\\\\', exist_ok=True)\n\n h5 = h5py.File(save + \"\\\\MeanStd\\\\\" + files[k] + '.h5', 'w')\n h5.create_dataset('surf', data=im_surf)\n h5.create_dataset('deep', data=im_deep)\n h5.create_dataset('calc', data=im_calc)\n h5.close()\n else:\n plt.show()\n k += 1","def matplotlibDisplayMulti(imgs, titles=None, colorFlag='gray'):\n if titles is None:\n titles = []\n for i in range(len(imgs)):\n titles.append(\"IMAGE \" + str(i))\n for i in range(len(imgs)):\n plt.subplot(1, len(imgs), 1+i)\n plt.imshow(imgs[i], colorFlag)\n plt.title(titles[i])\n plt.xticks([])\n plt.yticks([])\n plt.show()","def load_images(self, tmx):\n for image_data in tmx.images:\n if image_data:\n image, _, _ = image_data\n self.load_image(image)","def show_dataset(folder, n=10):\n volumes = volume_paths(folder)\n for i, v in enumerate(volumes):\n print(load_pages(v)[0][0:500])\n if i >= n:\n break","def get_images(self, page_number):","def gather_images():\n # Import an empty image\n null_img = Image.open('assests/null/null.png')\n null_img = ImageTk.PhotoImage(null_img.resize((100,100), Image.ANTIALIAS))\n\n # Import image and icon for X\n X_img = Image.open('assests/X_Assets/X.png')\n X_icon = ImageTk.PhotoImage(X_img.resize((15, 12), Image.ANTIALIAS))\n X_img = ImageTk.PhotoImage(X_img.resize((95, 80), Image.ANTIALIAS))\n\n # Import horizontally striked X\n X_hor = Image.open('assests/X_Assets/X_hor.png')\n X_hor = ImageTk.PhotoImage(X_hor.resize((95, 80), Image.ANTIALIAS))\n\n # Import vertically striked X\n X_vert = Image.open('assests/X_Assets/X_vert.png')\n X_vert = ImageTk.PhotoImage(X_vert.resize((95, 80), Image.ANTIALIAS))\n\n # Import diagonally strikedX\n X_diag = Image.open('assests/X_Assets/X_diag.png')\n X_diag = ImageTk.PhotoImage(X_diag.resize((95, 80), Image.ANTIALIAS))\n\n # Import another diagonally striked X\n X_diag2 = Image.open('assests/X_Assets/X_diag2.png')\n X_diag2 = ImageTk.PhotoImage(X_diag2.resize((95, 80), Image.ANTIALIAS))\n\n # Import image and icon for O\n O_img = Image.open('assests/O_Assets/O.png')\n O_icon = ImageTk.PhotoImage(O_img.resize((14, 14), Image.ANTIALIAS))\n O_img = ImageTk.PhotoImage(O_img.resize((90, 90), Image.ANTIALIAS))\n\n # Import horizontally striked O\n O_hor = Image.open('assests/O_Assets/O_hor2.png')\n O_hor = ImageTk.PhotoImage(O_hor.resize((90, 90), Image.ANTIALIAS))\n\n # Import vertically striked O\n O_vert = Image.open('assests/O_Assets/O_vert2.png')\n O_vert = ImageTk.PhotoImage(O_vert.resize((90, 90), Image.ANTIALIAS))\n\n # Import diagonally striked O\n O_diag = Image.open('assests/O_Assets/O_diag.png')\n O_diag = ImageTk.PhotoImage(O_diag.resize((90, 90), Image.ANTIALIAS))\n\n # Import another diagonally striked O\n O_diag2 = Image.open('assests/O_Assets/O_diag2.png')\n O_diag2 = ImageTk.PhotoImage(O_diag2.resize((90, 90), Image.ANTIALIAS))\n\n return (null_img, X_icon, X_img, X_hor, X_vert, X_diag, X_diag2, O_icon, O_img, O_hor, O_vert, O_diag, O_diag2)","def plot_random_generated_images(self):\n dimensions=(10, 10)\n figsize=(10, 10)\n n_samples=100\n \n (X, _), _ = self.generate_generator_prediction_samples(n_samples)\n \n self.grid_plot(X, dimensions=dimensions, figsize=figsize)","def plot_examples(n_samples, images, start_image=0):\n n_cols = len(images)\n index = 0\n for j in range(0+start_image, n_samples+start_image):\n for col_id, img in enumerate(images):\n img_to_plot = img[j:j+1, :, :, :]\n img_to_plot = np.squeeze(img_to_plot)\n plt.subplot(n_samples, n_cols, index + col_id + 1)\n plt.imshow(img_to_plot, cmap='gray', vmin=0, vmax=1)\n plt.axis('off')\n index += n_cols"],"string":"[\n \"def show_imgs(dataset, n_imgs, plot_size=(15, 15), cmap=None):\\n n_cols = int(np.sqrt(n_imgs))\\n n_rows = int(np.ceil(np.sqrt(n_imgs)))\\n class_idx = dataset.class_to_idx\\n idx_class = idx_to_class(class_idx)\\n\\n fig, axes = plt.subplots(n_rows, n_cols, figsize=plot_size)\\n for i, ax in enumerate(axes.flatten()):\\n ax.axis('off')\\n title = f'Class : {idx_class[dataset.targets[i]]}'\\n ax.imshow(dataset.data[i], cmap=cmap)\\n ax.set_title(title)\\n fig.tight_layout()\",\n \"def display_sample_images(self):\\n if self.train_dataset is None:\\n self.init_datasets()\\n\\n images, labels = next(self.train_dataset)\\n plt.figure(figsize=(5,5))\\n for n in range(min(25, images.shape[0])):\\n ax = plt.subplot(5,5,n+1)\\n plt.imshow(images[n])\\n if len(labels.shape) == 1:\\n plt.title(self.class_names[int(labels[n])].title())\\n else:\\n m = np.argmax(labels[n])\\n plt.title(self.class_names[int(labels[n, m])].title())\\n plt.axis('off')\\n\\n plt.tight_layout()\\n plt.show()\",\n \"def PlotImages(x):\\r\\n # 5.1 Create figure-window and axes\\r\\n _, ax = plt.subplots(nrows = 2, ncols= 3)\\r\\n # 5.2\\r\\n ax[0,0].imshow(x[0, :].reshape(75,75))\\r\\n ax[0,1].imshow(x[1, :].reshape(75,75))\\r\\n ax[0,2].imshow(x[2, :].reshape(75,75))\\r\\n ax[1,0].imshow(x[3, :].reshape(75,75))\\r\\n ax[1,1].imshow(x[4, :].reshape(75,75))\\r\\n ax[1,2].imshow(x[5, :].reshape(75,75))\\r\\n plt.show()\",\n \"def show_imagegrid_dataset(dataset,\\n num=10,\\n shuffle=True,\\n classes='auto',\\n figsize=None,\\n fontsize=20,\\n image_attr={'cmap': plt.cm.Greys_r}):\\n sample = dataset[0]\\n if isinstance(sample, tuple) and len(sample) == 2:\\n images_per_class = get_labeled_imagegrid(dataset,\\n num=num,\\n shuffle=shuffle,\\n classes=classes)\\n num = min(num, max(map(len, images_per_class.values())))\\n classes = list(images_per_class.keys())\\n\\n if figsize is None:\\n figsize = (2 * num, 2 * len(classes))\\n fig, axs = plt.subplots(figsize=figsize, nrows=len(classes), ncols=num)\\n if len(classes) == 1:\\n axs = np.expand_dims(axs, 0)\\n if num == 1:\\n axs = np.expand_dims(axs, -1)\\n for i, (class_name, class_images) in enumerate(images_per_class.items()):\\n for j, img in enumerate(class_images):\\n show_image(img, axs[i][j], image_attr)\\n axs[i][0].set_ylabel(str(class_name), fontsize=fontsize)\\n elif isinstance(sample, (Image, torch.Tensor, np.ndarray)):\\n image_list = get_imagegrid(dataset,\\n num=num,\\n shuffle=shuffle)\\n num = min(len(image_list), num)\\n nrows = math.ceil(math.sqrt(num))\\n ncols = math.ceil(num / nrows)\\n if figsize is None:\\n figsize = (2 * nrows, 2 * ncols)\\n fig, axs = plt.subplots(figsize=figsize, nrows=nrows, ncols=ncols)\\n axs = axs.flatten()\\n for i, img in enumerate(image_list):\\n show_image(img, axs[i], image_attr)\",\n \"def show_images(images, save=None, size=None):\\n assert len(images) > 0, \\\"images should contain at least 1 element\\\"\\n assert len(images[0].shape) == 3, \\\"each image should contain 3 elements (c, w,h)\\\"\\n \\n fig, ax = plt.subplots(nrows=images[0].shape[0], ncols=len(images))\\n \\n for i in range(len(images)): \\n for j in range(images[0].shape[0]):\\n ax[i,j].imshow(images[i][j,:,:], cmap='gray')\\n \\n plt.show()\",\n \"def show_images(imgs, nrows, ncols, figsize=None):\\n figsize = (ncols, nrows)\\n _, figs = plt.subplots(nrows, ncols, figsize=figsize)\\n for i in range(nrows):\\n for j in range(ncols):\\n figs[i][j].imshow(imgs[i*ncols+j].asnumpy())\\n figs[i][j].axes.get_xaxis().set_visible(False)\\n figs[i][j].axes.get_yaxis().set_visible(False)\\n plt.show()\",\n \"def view_image(train_dataloader):\\n for (x, target) in train_dataloader:\\n np.save(\\\"img.npy\\\", x)\\n print(x.shape)\\n exit(0)\",\n \"def display_images_in_grid(imgs, row, col):\\n if len(imgs) != (row * col):\\n raise ValueError(f\\\"Invalid imgs len:{len(imgs)} col:{row} row:{col}\\\")\\n\\n for i, img in enumerate(imgs):\\n plot_num = i + 1\\n plt.subplot(row, col, plot_num)\\n plt.tick_params(labelbottom=False) # remove x axis\\n plt.tick_params(labelleft=False) # remove y axis\\n plt.imshow(img)\\n plt.show()\",\n \"def grid(images, cols = 2, save = False, filename = \\\"\\\", show = False):\\n \\n rows = ceil(len(images) / cols)\\n \\n fig, ax = plt.subplots(rows, 1)\\n\\n index = 0\\n element = []\\n for row in range(rows):\\n for col in range(cols): \\n if index < len(images):\\n element.append(images[index])\\n index += 1\\n \\n stack = np.hstack(tuple(element))\\n ax[row].axis('off')\\n ax[row].imshow(stack)\\n element = []\\n \\n plt.tight_layout()\\n \\n if save:\\n fig.savefig(filename)\\n\\n if show:\\n plt.show(fig)\\n \\n return 0\",\n \"def display_images(digits_im):\\n i = 0\\n\\n for img in digits_im:\\n if i < N_NEIGHBOURS:\\n # Visualize your data\\n im_max = np.max(img)\\n img = PIXELS * (np.abs(im_max - img) / im_max)\\n res = cv2.resize(img, (DIM, DIM), interpolation=cv2.INTER_CUBIC)\\n cv2.imwrite('digit ' + str(i) + '.png', res)\\n i += 1\\n else:\\n break\",\n \"def visulize_5(X):\\n fig, axes1 = plt.subplots(5,5,figsize=(3,3))\\n for j in range(5):\\n for k in range(5):\\n i = np.random.choice(range(len(X)))\\n axes1[j][k].set_axis_off()\\n axes1[j][k].imshow(X[:,i].reshape(32, 32, 3))\\n plt.show()\",\n \"def img_viewer_examples(images, labels, prediction = None, size=0, greyscale=False):\\n batchSize = min(size, images.shape[0])\\n \\n if size == 0:\\n batchSize = images.shape[0]\\n\\n # I CAN TAKE THE BATCH_SIZE from the images size/shape according the sent data type\\n no_of_columns = round(math.sqrt(batchSize))\\n no_of_rows = math.ceil(batchSize / no_of_columns)\\n print(\\\"batch size {}, no_of_rows {}, no_of_columns {}\\\".format(batchSize, no_of_rows, no_of_columns))\\n fig = plt.figure(figsize=(no_of_columns*1.25, no_of_rows*1.5))\\n # (width, height)\\n for idx in np.arange(batchSize):\\n ax = fig.add_subplot(no_of_rows, no_of_columns,\\n idx+1, xticks=[], yticks=[])\\n if greyscale:\\n ax.imshow(np.squeeze(images[idx]), cmap='gray')\\n else:\\n ax.imshow(np.squeeze(images[idx]))\\n # print out the correct label for each image\\n # .item() gets the value contained in a Tensor\\n # WAIT FOR TASNEEM TO SEE THE RETURNED DATA TYPE\\n if not prediction is None:\\n ax.set_title(\\\"{} ({})\\\".format(str(prediction[idx]), str(labels[idx])),\\n color=(\\\"green\\\" if prediction[idx] == labels[idx] else \\\"red\\\"))\\n else:\\n ax.set_title(str(labels[idx]))\",\n \"def show_images(imgs, num_rows, num_cols, scale=2):\\n figsize = (num_cols * scale, num_rows * scale)\\n _, axes = plt.subplots(num_rows, num_cols, figsize=figsize)\\n for i in range(num_rows):\\n for j in range(num_cols):\\n axes[i][j].imshow(imgs[i * num_cols + j].asnumpy())\\n axes[i][j].axes.get_xaxis().set_visible(False)\\n axes[i][j].axes.get_yaxis().set_visible(False)\\n return axes\",\n \"def imshow_grid(images, shape=[2, 8]):\\n fig = plt.figure(1)\\n grid = ImageGrid(fig, 111, nrows_ncols=shape, axes_pad=0.05)\\n\\n size = shape[0] * shape[1]\\n for i in range(size):\\n grid[i].axis('off')\\n grid[i].imshow(images[i]) # The AxesGrid object work as a list of axes.\\n\\n plt.show()\",\n \"def imshow_grid(images, shape=[2, 8]):\\n fig = plt.figure(1)\\n grid = ImageGrid(fig, 111, nrows_ncols=shape, axes_pad=0.05)\\n\\n size = shape[0] * shape[1]\\n for i in range(size):\\n grid[i].axis('off')\\n grid[i].imshow(images[i]) # The AxesGrid object work as a list of axes.\\n\\n plt.show()\",\n \"def imshow_grid(images, shape=[2, 2], name='default', save=False):\\n fig = plt.figure()\\n grid = ImageGrid(fig, 111, nrows_ncols=shape, axes_pad=0.05)\\n\\n size = shape[0] * shape[1]\\n for i in range(size):\\n grid[i].axis('off')\\n img = images[i]\\n if img.shape[0]==3:\\n img = img.transpose(1, 2, 0)\\n img = (img - img.min())/(img.max() - img.min())\\n grid[i].imshow(img, vmin=-132, vmax = 164) # The AxesGrid object work as a list of axes.\\n\\n plt.show()\",\n \"def show_imgs(imgs, row, col):\\n if len(imgs) != (row * col):\\n raise ValueError(\\n \\\"Invalid imgs len:{} col:{} row:{}\\\".format(len(imgs), row, col))\\n\\n for i, img in enumerate(imgs):\\n plot_num = i+1\\n plt.subplot(row, col, plot_num)\\n plt.tick_params(labelbottom=False) # x軸の削除\\n plt.tick_params(labelleft=False) # y軸の削除\\n plt.imshow(img)\\n plt.show()\",\n \"def show_images(imgs, num_rows, num_cols, scale=2):\\n figsize = (num_cols*scale, num_rows*scale)\\n _, axes = plt.subplots(num_rows, num_cols, figsize=figsize)\\n for i in range(num_rows):\\n for j in range(num_cols):\\n # show the target image\\n axes[i][j].imshow(imgs[i*num_cols+j])\\n # set the sub-axis to be invisible\\n axes[i][j].axes.get_xaxis().set_visible(False)\\n axes[i][j].axes.get_yaxis().set_visible(False)\\n # remember to show figure at last\\n plt.show()\\n return axes\",\n \"def show_train_images(train_data, train_labels):\\n plt.figure(1, figsize=(8, 8))\\n n = 0\\n\\n for i in range(16):\\n n += 1\\n # each time random images are loaded\\n # r = np.random.randint(0, train_data.shape[0], 1)\\n plt.subplot(4, 4, n)\\n plt.subplots_adjust(hspace=0.5, wspace=0.5)\\n plt.imshow(train_data[i] / 255.)\\n plt.title('{}'.format(train_labels[i]))\\n plt.xticks([]), plt.yticks([])\\n plt.show()\",\n \"def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5): #@save\\n figsize = (num_cols * scale, num_rows * scale)\\n _, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)\\n axes = axes.flatten()\\n for i, (ax, img) in enumerate(zip(axes, imgs)):\\n ax.imshow(d2l.numpy(img))\\n ax.axes.get_xaxis().set_visible(False)\\n ax.axes.get_yaxis().set_visible(False)\\n if titles:\\n ax.set_title(titles[i])\\n return axes\",\n \"def show_images(images, db):\\n images = [int(image) for image in images]\\n files = get_img_files(images, db)\\n show_files(files)\",\n \"def plot_100_images(X, indices=None):\\n width, height = IMAGE_WIDTH, IMAGE_HEIGHT\\n nrows, ncols = 10, 10\\n if indices is None:\\n indices = range(X.shape[0])\\n indices_to_display = np.random.choice(indices, nrows * ncols)\\n\\n big_picture = np.zeros((height * nrows, width * ncols))\\n\\n irow, icol = 0, 0\\n for idx in indices_to_display:\\n if icol == ncols:\\n irow += 1\\n icol = 0\\n iimg = X[idx].reshape(width, height).T # transpose the data set\\n big_picture[irow * height:irow * height + iimg.shape[0],\\n icol * width:icol * width + iimg.shape[1]] = iimg\\n icol += 1\\n plt.imshow(big_picture, cmap=matplotlib.cm.Greys_r)\\n\\n plt.show()\",\n \"def display_data():\\n data = read_data_from_file()\\n data_size = len(data)\\n print('Data size - ' + str(data_size))\\n\\n\\n for i in range(data_size-1, 0, -1):\\n image = data[i]\\n cv2.imshow('window', image[0])\\n print(str(image[1]))\\n cv2.waitKey(50)\",\n \"def show_image_grid(imgs):\\n grd = make_grid(imgs)\\n npimg = grd.numpy()\\n plt.imshow(np.transpose(npimg, (1,2,0)), interpolation='nearest')\\n plt.ion()\\n plt.show()\",\n \"def plot_n_image(X, n):\\n pic_size = int(np.sqrt(X.shape[1]))\\n grid_size = int(np.sqrt(n))\\n\\n first_n_images = X[:n, :]\\n\\n fig, ax_array = plt.subplots(nrows=grid_size, ncols=grid_size,sharey=True, sharex=True, figsize=(8, 8))\\n\\n for r in range(grid_size):\\n for c in range(grid_size):\\n ax_array[r, c].imshow(first_n_images[grid_size * r + c].reshape((pic_size, pic_size)))\\n plt.xticks(np.array([]))\\n plt.yticks(np.array([]))\",\n \"def show_torch_imgs(imgs, nrow=8, figsize=(8, 5), axis_off=True , **opt):\\n import torchvision\\n import torch\\n if not torch.is_tensor(imgs):\\n # Not a torch tensor. Assume that it is torch.autograd.Variable\\n # Try to get the tensor inside the Variable.\\n try:\\n imgs = imgs.data\\n except:\\n raise ValueError('Expect input imgs to be a torch Tensor or torch.autograd.Variable.')\\n # https://gist.github.com/anonymous/bf16430f7750c023141c562f3e9f2a91\\n img = torchvision.utils.make_grid(imgs, nrow=nrow, **opt)\\n npimg = img.cpu().numpy()\\n # make it height x width x channels\\n npimg = np.transpose(npimg, (1, 2, 0))\\n\\n plt.figure(figsize=figsize)\\n plt.imshow(npimg, interpolation='nearest')\\n if axis_off:\\n plt.axis('off')\",\n \"def display_imgs(img_dir,img_list):\\n for img in img_list:\\n display_img(img_dir, img)\",\n \"def plot_many_images(images, titles, rows=1, columns=2):\\n for i, image in enumerate(images):\\n plt.subplot(rows, columns, i + 1)\\n plt.imshow(image, \\\"gray\\\")\\n plt.title(titles[i])\\n plt.xticks([]), plt.yticks([]) # Hide tick marks\\n plt.show()\",\n \"def show_images(images):\\n for name, img in images:\\n cv2.imshow(name, img)\\n\\n cv2.waitKey(0)\",\n \"def three_sample_images():\\n samples = samples_path()\\n _truck = np.array(Image.open(os.path.join(samples, \\\"truck.png\\\")))\\n _deer = np.array(Image.open(os.path.join(samples, \\\"deer.png\\\")))\\n _frog = np.array(Image.open(os.path.join(samples, \\\"frog.png\\\")))\\n truck = transforms.ToTensor()(_truck)\\n deer = transforms.ToTensor()(_deer)\\n frog = transforms.ToTensor()(_frog)\\n return torch.stack([truck, deer, frog])\",\n \"def displayData(indices_to_display = None):\\n width, height = 20, 20\\n nrows, ncols = 10, 10\\n if not indices_to_display:\\n indices_to_display = random.sample(range(X.shape[0]), nrows*ncols)\\n \\n big_picture = np.zeros((height*nrows,width*ncols))\\n \\n irow, icol = 0, 0\\n for idx in indices_to_display:\\n if icol == ncols:\\n irow += 1\\n icol = 0\\n iimg = getDatumImg(X[idx])\\n big_picture[irow*height:irow*height+iimg.shape[0], icol*width:icol*width+iimg.shape[1]] = iimg\\n icol += 1\\n fig = plt.figure(figsize=(6,6))\\n\\n big_picture = (big_picture * 255).astype(np.int8)\\n img = Image.fromarray(big_picture, mode='L')\\n plt.imshow(img, cmap = cm.Greys)\",\n \"def grid_image(output):\\n grid = []\\n for data in output:\\n grid += [make_grid(data, nrow=5, normalize=True)]\\n return grid\",\n \"def print_images(i, df):\\n \\n images_folder_path = \\\"dataset/petfinder-adoption-prediction/train_images/\\\"\\n plt.imshow(cv2.cvtColor(cv2.imread(images_folder_path+df.filename[i]), cv2.COLOR_BGR2RGB),);\\n plt.axis(\\\"off\\\");\\n plt.show()\",\n \"def display_images(filenames):\\n for filename in filenames:\\n display(Image(filename))\",\n \"def show_data(self, samples=5):\\n self._samples = samples\\n \\n idx = 0\\n batch = next(iter(self._loader))\\n while idx <= self._samples:\\n\\n (img_batch, label_batch) = batch\\n\\n fig = plt.figure()\\n ax1 = fig.add_subplot(121)\\n ax2 = fig.add_subplot(122)\\n \\n ax1.imshow(np.transpose(img_batch[idx], (1, 2, 0)))\\n ax2.imshow(np.transpose(label_batch[idx], (1, 2, 0)).squeeze(dim=2))\\n\\n plt.show()\\n idx += 1\",\n \"def visualize_image(images, save_name):\\n dim = images.shape[0]\\n n_image_rows = int(np.ceil(np.sqrt(dim)))\\n n_image_cols = int(np.ceil(dim * 1.0 / n_image_rows))\\n gs = gridspec.GridSpec(n_image_rows, n_image_cols, top=1., bottom=0.,\\n right=1., left=0., hspace=0., wspace=0.)\\n\\n for g, count in zip(gs, range(int(dim))):\\n ax = plt.subplot(g)\\n ax.imshow(images[count, :].astype(np.float32).reshape((28, 28)))\\n ax.set_xticks([])\\n ax.set_yticks([])\\n plt.savefig(save_name + '_vis.png')\",\n \"def plot_gallery(images , h, w, n_row=3, n_col=6):\\n plt.figure(figsize=(1.7 * n_col, 2.3 * n_row))\\n plt.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35)\\n for i in range(len(images)):\\n plt.subplot(n_row, n_col, i + 1)\\n plt.imshow(images[i].reshape((h, w)), cmap=plt.cm.gray)\\n\\n plt.xticks(())\\n plt.yticks(())\",\n \"def plot_10_by_10_images(images):\\n\\n\\tn = images.shape[0]\\n\\n\\tq = n // 10\\n\\tr = n%10\\n\\tprint n,q,r\\n\\n\\tfig = plt.figure()\\n\\tplt.ion()\\n\\n\\tfor x in range(q):\\n\\t\\tprint x\\n\\t\\tif not x%10:\\n\\t\\t\\tplt.clf()\\n\\t\\tfor y in range(10):\\n\\t\\t\\tax = fig.add_subplot(10, 10, 10*y+x%10+1)\\n\\t\\t\\tax.matshow(images[10*y+x%10], cmap = mpl.cm.binary)\\n\\t\\t\\tplt.xticks(np.array([]))\\n\\t\\t\\tplt.yticks(np.array([]))\\n\\t\\tplt.show()\\n\\t\\t_=raw_input(\\\"Press enter to show next 10\\\")\",\n \"def read_vanhateren_images (n_imgs=5):\\n folder_name = r'D:\\\\VanHateren\\\\vanhateren_imc' # change this to point to the directory which holds the van hateren data\\n # files = listdir(folder_name)\\n onlyfiles = [ f for f in listdir(folder_name) if isfile(join(folder_name,f)) ]\\n imgs = []\\n for i in range(n_imgs):\\n filename = join(folder_name, onlyfiles[i])\\n with open(filename, 'rb') as handle:\\n s = handle.read()\\n arr = array.array('H', s)\\n arr.byteswap()\\n img_i = np.array(arr, dtype='uint16').reshape(1024, 1536)\\n imgs.append(img_i) \\n return imgs\\n #pylab.imshow(img)\\n #pylab.show()\",\n \"def show_four_images(img1, img2, img3, img4, title):\\n shape = (460, 250)\\n # Get all images in same size for better display\\n img1 = cv2.resize(img1, shape)\\n img2 = cv2.resize(img2, shape)\\n img3 = cv2.resize(img3, shape)\\n img4 = cv2.resize(img4, shape)\\n # combined 2 images horizontally\\n numpy_horizontal1 = np.hstack((img1, img2))\\n # combined the rest 2 images horizontally\\n numpy_horizontal2 = np.hstack((img3, img4))\\n # now combined all vertically to 1 image and display\\n numpy_vertical = np.vstack((numpy_horizontal1, numpy_horizontal2))\\n # final thing - show the output:\\n show_image(numpy_vertical, title)\",\n \"def plot_images(imgs, layout, img_sz = 0.7, suptitle = ''):\\n\\tnrows, ncols = layout \\n\\tfig, axes = plt.subplots(nrows, ncols, \\n\\t\\tfigsize = (img_sz * ncols, img_sz * nrows))\\n\\taxes = axes.ravel()\\n\\tfig.subplots_adjust(hspace = 0, wspace = 0)\\n\\tfig.suptitle(suptitle)\\n\\tfor i, img in enumerate(imgs):\\n\\t\\taxes[i].get_xaxis().set_visible(False)\\n\\t\\taxes[i].get_yaxis().set_visible(False)\\n\\t\\taxes[i].imshow(img)\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\",\n \"def images(self, **kwargs):\\n\\n raise NotImplementedError\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\\n # plt.savefig('./drive/My Drive/Colab Notebooks/TACK/Large/result' + ' '.join(name.split('_')).title() + '.png')\",\n \"def load_images(folder_path, num_images):\\n imgs = np.zeros(shape=[num_images, 400, 400, 3])\\n for i in range(1, num_images + 1):\\n image_name = \\\"satImage_%.3d\\\" % i\\n image_path = folder_path + image_name + \\\".png\\\"\\n if os.path.isfile(image_path):\\n print('Loading ' + image_path)\\n img = mpimg.imread(image_path)\\n\\n #imgs[i - 1] = np.asarray(img).reshape(400, 400, 3)\\n imgs[i - 1] = img.reshape(400, 400, 3)\\n else:\\n print('File ' + image_path + ' does not exist')\\n return imgs\",\n \"def plot_latent_images(self, n):\\n\\n norm = tfp.distributions.Normal(0, 1)\\n grid_x = norm.quantile(np.linspace(0.05, 0.95, n))\\n grid_y = norm.quantile(np.linspace(0.05, 0.95, n))\\n image_width = self.data.digit_size*n\\n image_height = image_width\\n image = np.zeros((image_height, image_width))\\n\\n for i, yi in enumerate(grid_x):\\n for j, xi in enumerate(grid_y):\\n z = np.array([[xi, yi]])\\n x_decoded = self.model.sample(z)\\n digit = tf.reshape(x_decoded[0], (self.data.digit_size, self.data.digit_size))\\n image[i * self.data.digit_size: (i + 1) * self.data.digit_size,\\n j * self.data.digit_size: (j + 1) * self.data.digit_size] = digit.numpy()\\n\\n plt.figure(figsize=(10, 10))\\n plt.imshow(image, cmap='Greys_r')\\n plt.axis('Off')\\n plt.show()\",\n \"def extract_images(dimension = (_HEIGHT, _WIDTH), n = 100, color = True, include = ['00', '01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12', '13']):\\n # establish directory routes\\n origin = '/Users/jaoming/Active Projects/Shopee Challenge/shopee-product-detection-dataset'\\n main_train_folder = '/Users/jaoming/Active Projects/Shopee Challenge/shopee-product-detection-dataset/train/train'\\n os.chdir(main_train_folder)\\n if color:\\n imread_color = cv2.IMREAD_COLOR\\n else:\\n imread_color = cv2.IMREAD_GRAYSCALE\\n\\n # setting up the variables \\n data, labels = [], []\\n for name in include:\\n os.chdir(name)\\n image_namelist = os.listdir()\\n if '.DS_Store' in image_namelist: # removing unnecessary files\\n image_namelist.remove('.DS_Store')\\n count = 0\\n while count < n:\\n data.append(cv2.resize(\\n cv2.imread(image_namelist[count], imread_color),\\n dimension,\\n interpolation = cv2.INTER_CUBIC\\n ))\\n labels.append(int(name))\\n count += 1\\n os.chdir(main_train_folder)\\n\\n os.chdir(origin)\\n return data, labels\",\n \"def plot_images_grid(images, labels, title):\\n images = images.cpu()\\n labels = labels.cpu()\\n \\n assert type(images[0]) is torch.Tensor, 'Image to plot is not torch.Tensor'\\n image_size = int(np.sqrt(images[0].shape[0]))\\n \\n fig = plt.figure(figsize=(10,4))\\n for idx in range(10):\\n ax = fig.add_subplot(2,10/2,idx+1, xticks=[], yticks=[])\\n ax.imshow(images[idx].view(image_size, image_size), cmap = 'gray')\\n label = labels[idx].item()\\n ax.set_title(label)\\n #end\\n fig.suptitle(title, fontsize = 14)\\n plt.show()\\n plt.close('all')\",\n \"def visualize(base_path, test_dataset, plot_dir, batch_size=4, ):\\n device = torch.device('cuda')\\n dataset = HeadDataset(test_dataset,\\n base_path,\\n dataset_param={},\\n train=False)\\n batch_iterator = iter(data.DataLoader(dataset, batch_size,\\n shuffle=False,\\n num_workers=4,\\n collate_fn=coco_collate))\\n for ind, (images, targets) in enumerate(tqdm(batch_iterator)):\\n images = list(img.to(device) for img in images)\\n np_images = [(ims.cpu().numpy()*255.).astype(np.uint8) for ims in images]\\n gt_boxes = [gt['boxes'].numpy().astype(np.float64) for gt in targets]\\n for np_im, gt_box in zip(np_images, gt_boxes):\\n plot_images = plot_ims(np_im, [], gt_box)\\n imsave(osp.join(plot_dir, str(ind) + '.jpg'), plot_images)\",\n \"def collage(images, cols = 2, save = False, filename = \\\"\\\", show = False):\\n \\n rows = ceil(len(images) / cols)\\n \\n fig, ax = plt.subplots(rows, cols)\\n\\n index = 0\\n\\n for row in range(rows):\\n for col in range(cols):\\n \\n if index < len(images):\\n ax[row, col].imshow(images[index])\\n \\n ax[row, col].axis('off')\\n index += 1\\n plt.tight_layout()\\n \\n if save:\\n fig.savefig(filename)\\n\\n if show:\\n plt.show(fig)\\n \\n return 0\",\n \"def visualization(data, rows, cols, titles, figsize):\\n fig, ax = plt.subplots(nrows=rows, ncols=cols, figsize=figsize)\\n # plot image on each subplot\\n for i, axi in enumerate(ax.flat):\\n # i is in range [0, nrows * ncols)\\n # axi is equivalent to ax[rowid][colid]\\n axi.imshow(data[i])\\n axi.set_title(titles[i])\\n plt.tight_layout(True)\\n plt.show()\",\n \"def load_dataset(path_test, width, height):\\n tot_images = 0\\n for label in listdir(path_test):\\n label_full = join(path_test, label)\\n for img_name in listdir(label_full):\\n tot_images += 1\\n\\n # allocate the memory\\n # THE DTYPE is float, should be the right one\\n all_images = np.zeros((tot_images, width, height, 3))\\n\\n true_labels = []\\n num_images = 0\\n for label in listdir(path_test):\\n label_full = join(path_test, label)\\n for img_name in listdir(label_full):\\n # for img_name in listdir(label_full)[:10]:\\n img_name_full = join(label_full, img_name)\\n print(f\\\"Opening {img_name_full} {width}\\\")\\n\\n image = cv2.imread(img_name_full)\\n\\n image = cv2.resize(image, (width, height))\\n\\n # scale the pixel values to [0, 1]\\n image = image.astype(\\\"float\\\") / 255.0\\n\\n all_images[num_images, :, :, :] = image\\n\\n num_images += 1\\n true_labels.append(label)\\n\\n print(f\\\"All_images.shape {all_images.shape}\\\")\\n\\n # cv2.imshow('Resized all_images[0]', all_images[0])\\n # cv2.waitKey(0)\\n\\n return all_images, true_labels\",\n \"def show(self):\\n \\n \\n \\n \\n \\n \\n r = 4\\n f, axarr = plt.subplots(r, r, figsize=(8,8))\\n counter = 0\\n for i in range(r):\\n for j in range(r):\\n temp = self.x[counter,:]\\n counter += 1\\n img = self.x[counter,:]\\n axarr[i][j].imshow(img)\\n #######################################################################\\n # #\\n # #\\n # TODO: YOUR CODE HERE #\\n # #\\n # #\\n #######################################################################\",\n \"def plot_images(imgs_org, imgs_pred, nb_examples=10):\\n if nb_examples == 0:\\n return\\n\\n n = nb_examples\\n plt.figure(figsize=(nb_examples * 2, 4))\\n for i in range(n):\\n # display original\\n ax = plt.subplot(2, n, i + 1)\\n plt.imshow(imgs_org[i].reshape(84, 84))\\n plt.gray()\\n ax.get_xaxis().set_visible(False)\\n ax.get_yaxis().set_visible(False)\\n\\n # display reconstruction\\n ax = plt.subplot(2, n, i + 1 + n)\\n plt.imshow(imgs_pred[i].reshape(84, 84))\\n plt.gray()\\n ax.get_xaxis().set_visible(False)\\n ax.get_yaxis().set_visible(False)\\n plt.show()\",\n \"def displayFaceData(X, rows, cols):\\n\\twidth, height = 32, 32 # This is the shape of original photo (32*32)\\n\\tpictures_combined = np.zeros((height*rows, width*cols))\\n\\t\\n\\trow, col = 0, 0\\n\\tfor a_picture_index in xrange(rows*cols):\\n\\t\\tif col == cols:\\n\\t\\t\\trow += 1\\n\\t\\t\\tcol = 0\\n\\t\\ta_picture = ReshapeIntoImage(X[a_picture_index],width)\\n\\t\\tpictures_combined[row*height:(row*height+a_picture.shape[0]), col*width:(col*width+a_picture.shape[1])] = a_picture\\n\\t\\tcol += 1\\n\\n\\tfig = plt.figure(figsize=(10,10))\\n\\timg = scipy.misc.toimage( pictures_combined )\\n\\tplt.imshow(img,cmap = cm.Greys_r)\\n\\tplt.show(block=False)\",\n \"def main():\\n labels, data = load_image_data()\\n print(labels.shape, data.shape)\",\n \"def retrieve_images(self, batch_size=5, offset=0):\\n\\t\\treturn self.session.query(Image.id, Image.image_path, Image.quantity, Image.cost) \\\\\\n\\t\\t\\t\\t\\t\\t .order_by(Image.id.desc()).offset(offset).limit(batch_size).all()\",\n \"def display_image(df, fname_col, img_dir, n):\\n\\t# Display some train images\\n\\tnrows = 1+n//20 \\n\\tfig, axs = plt.subplots(nrows,20, figsize=(20,1.2*nrows),\\n\\t\\t\\t\\t\\t\\t facecolor='w', edgecolor='k')\\n\\taxs = axs.ravel()\\n\\n\\tfor idx, filename in enumerate (df[fname_col][0:n].values):\\n\\n\\t\\tif not os.path.isfile(img_dir+filename):\\n\\t\\t\\tlogger.error(\\\"path {} does not exit\\\".format(img_dir+filename))\\n\\t\\t\\t\\t\\t\\t\\n\\t\\timg = mpimg.imread(img_dir + filename)\\n\\n\\t\\taxs[idx].imshow(img)\\n\\t\\taxs[idx].set_axis_off()\\n\\t \\n\\tplt.subplots_adjust(wspace=0, hspace=0)\\n\\tplt.show()\",\n \"def loadDataset(dataset):\\n # List of images.\\n images = []\\n\\n\\n\\n # Read all filenames from the dataset.\\n for filename in dataset:\\n # Read the input image.\\n image = cv2.imread(filename)\\n\\n # Add the current image on the list.\\n if image is not None: \\n images.append(image)\\n else:\\n print(\\\"Could not read file: {}\\\".format(filename))\\n sys.exit()\\n\\n # Return the images list.\\n return images\",\n \"def graphical(cls, images):\\n images = [(plt.imread(i), i.split(os.path.sep)[-1]) for i in images]\\n views = [View(ViewPosition.click(img, path), img, img) for img, path in images]\\n return cls(views)\",\n \"def show_slice(file_path, x, y, z):\\n img = nib.load(file_path)\\n img = img.get_fdata()\\n print(\\\"The scan has dimensions {}.\\\".format(img.shape))\\n slice_0 = img[x, :, :]\\n slice_1 = img[:, y, :]\\n slice_2 = img[:, :, z]\\n slices = [slice_0, slice_1, slice_2]\\n fig, axes = plt.subplots(1, len(slices), figsize=[12, 4])\\n for i, sli in enumerate(slices):\\n axes[i].imshow(sli.T, cmap=\\\"gray\\\", origin=\\\"lower\\\")\",\n \"def images(self):\\n return self.gameimage_set.all()\",\n \"def generate_image_grid(sess, df, filenames,op, op2):\\n #x_points = np.arange(0, 1, 1.5).astype(np.float32)\\n #y_points = np.arange(0, 1, 1.5).astype(np.float32)\\n\\n nx, ny = 12, 1\\n #plt.subplot()\\n gs = gridspec.GridSpec(nx, ny, hspace=1, wspace=0.05)\\n # input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\\n #\\n # plt.imshow(np.array(df[0].tolist()).reshape(28, 28), cmap='gray')\\n # plt.show()\\n # x = sess.run(op, feed_dict={decoder_input: input_x[0].reshape(1,2)})\\n # img = np.array(x.tolist()).reshape(28, 28)\\n #\\n # plt.imshow(img, cmap='gray')\\n # plt.show()\\n\\n \\\"\\\"\\\" grid \\\"\\\"\\\"\\n input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\\n for i, g in enumerate(gs):\\n\\n x = sess.run(op, feed_dict={decoder_input: input_x[i].reshape(1,2)})\\n ax = plt.subplot(g)\\n img = np.array(x.tolist()).reshape(28, 28)\\n ax.imshow(img, cmap='gray')\\n ax.set_xticks([])\\n ax.set_yticks([])\\n #ax.set_aspect('auto')\\n ax.set_title(filenames[i])\\n plt.show()\\n\\n for i, g in enumerate(gs):\\n\\n ax = plt.subplot(g)\\n img = np.array(df[i].tolist()).reshape(28, 28)\\n ax.imshow(img, cmap='gray')\\n ax.set_xticks([])\\n ax.set_yticks([])\\n #ax.set_aspect('auto')\\n ax.set_title(filenames[i])\\n plt.show()\",\n \"def plot_gallery(self,images, titles, h, w, n_row=5, n_col=5):\\n plt.figure(figsize=(1.8 * n_col, 2.4 * n_row))\\n plt.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35)\\n for i in range(n_row * n_col):\\n plt.subplot(n_row, n_col, i + 1)\\n plt.imshow(images[i].reshape((h, w)), cmap=plt.cm.gray)\\n plt.title(titles[i], size=12)\\n plt.xticks(())\\n plt.yticks(())\\n plt.show()\",\n \"def showImages(images):\\n idx = 0\\n\\n while True:\\n\\n cv2.imshow(\\\"Image\\\", images[idx])\\n\\n if cv2.waitKey(15) & 0xFF == ord(\\\"d\\\"):\\n if idx+1 >= len(images):\\n print(\\\"This is the last image in the set.\\\")\\n else:\\n idx += 1\\n print(\\\"Viewing image no. {0} / {1}\\\".format(idx+1, len(images)))\\n\\n if cv2.waitKey(15) & 0xFF == ord(\\\"a\\\"):\\n if idx-1 < 0:\\n print(\\\"This is the first image in the set.\\\")\\n else:\\n idx -= 1\\n print(\\\"Viewing image no. {0} / {1}\\\".format(idx+1, len(images)))\\n\\n if cv2.waitKey(15) & 0xFF == ord(\\\"q\\\"):\\n break\",\n \"def displayImages(self):\\n\\n plt.figure(figsize=(8,6))\\n plt.subplot(1,2,1)\\n plt.imshow( self.original_image, cmap=\\\"gray\\\")\\n plt.title(\\\"Original Image\\\")\\n plt.subplot(1,2,2)\\n plt.imshow( self.blurred_image, cmap=\\\"gray\\\")\\n plt.title(\\\"Blurred Image\\\")\",\n \"def vis(group, indexlist, save=False):\\n ##### Modify these: #####\\n # imageloc = '/home/teja/Project_005/toronto/iaprtc12/images/'\\n # trainloc = '/home/teja/Project_005/toronto/iaprtc12_2/iaprtc12_train_list.txt'\\n # testloc = '/home/teja/Project_005/toronto/iaprtc12_2/iaprtc12_test_list.txt'\\n #########################\\n\\n ##### Modify these: #####\\n imageloc = '/home/teja/Programs/convnet/examples/imagenet/'\\n trainloc = '/home/teja/Project_005/toronto/iaprtc12_2/iaprtc12_train_list.txt'\\n testloc = '/home/teja/Programs/convnet/examples/imagenet/images_list.txt'\\n #########################\\n\\n\\n if group == 'train':\\n listloc = trainloc\\n else:\\n listloc = testloc\\n f = open(listloc, 'rb')\\n ims = []\\n for line in f:\\n ims.append(line.strip() + '.jpg')\\n f.close()\\n for i in range(len(indexlist)):\\n imloc = imageloc + ims[indexlist[i]]\\n im = Image.open(imloc)\\n # im.thumbnail((256,256), Image.ANTIALIAS)\\n # im.show()\\n if save:\\n im.save('r' + str(indexlist[i]) + '.jpg')\",\n \"def getimgs():\",\n \"def makeImage(self):\\n\\n for row in range(self.height):\\n self.makeRow(row)\\n self.window.update() # display a row of pixels\",\n \"def visualize(**images):\\r\\n n_images = len(images)\\r\\n plt.figure(figsize=(20, 8))\\r\\n for idx, (name, image) in enumerate(images.items()):\\r\\n plt.subplot(1, n_images, idx + 1)\\r\\n plt.xticks([])\\r\\n plt.yticks([])\\r\\n # get title from the parameter names\\r\\n plt.title(name.replace('_', ' ').title(), fontsize=20)\\r\\n plt.imshow(image)\\r\\n plt.show()\",\n \"def plot_image_grid(epoch, generated_images):\\n\\n fig = plt.figure(figsize=(GRID_SIZE, GRID_SIZE))\\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.001, hspace=0.001)\\n\\n for ind in range(GRID_IMGS):\\n ax = fig.add_subplot(GRID_SIZE, GRID_SIZE, ind + 1, xticks=[], yticks=[])\\n ax.imshow(np.uint8(((generated_images[ind] + 1) / 2) * 255), cmap='gray')\\n\\n plt.savefig('/content/drive/My Drive/WGAN/train_images/image_iteration_{:05d}.png'.format(epoch + 1))\\n plt.close()\",\n \"def display(self):\\n fig, axes = plt.subplots(1, len(self.views),\\n figsize=self._figsize(\\n [(self.views[0].image, len(self.views))]),\\n squeeze=True)\\n for ax, view in zip(axes.ravel(), self.views):\\n ax.imshow(view.grey)\\n points = self._common_keypoints(view).reshape(-1, 2)[::-1]\\n ax.plot(points[..., 0], points[..., 1], 'r+')\\n ax.axis('off')\\n ax.xaxis.set_visible(False)\\n ax.yaxis.set_visible(False)\\n ax.set(title=view.position.id)\\n fig.tight_layout()\\n fig.canvas.draw()\\n img_array = np.array(fig.canvas.renderer._renderer)\\n plt.close('all')\\n return img_array\",\n \"def display_some_traffic_sign_examples(path):\\n\\n images_paths = glob.glob(path + \\\"\\\\\\\\*.png\\\") # image paths\\n plt.figure(figsize = (10, 10))\\n\\n for i in range(25):\\n # select a random index in the dataset\\n idx = np.random.randint(0, len(images_paths) - 1)\\n img = imread(images_paths[idx])\\n\\n # subplot the dataset examples\\n plt.subplot(5, 5, i + 1)\\n plt.tight_layout(rect = [0, 0, 1, 0.95])\\n plt.imshow(img)\\n\\n plt.suptitle(\\\"Dataset Examples\\\")\\n plt.show()\",\n \"def plot_gallery(images, titles, n_row=3, n_col=4):\\n plt.figure(figsize=(2.5 * n_col, 2.4 * n_row))\\n plt.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35, wspace = .35)\\n for i in range(n_row * n_col):\\n plt.subplot(n_row, n_col, i + 1)\\n #plt.imshow(images[i].reshape((h, w)), cmap=plt.cm.gray)\\n # image = images[i].reshape(h, w)\\n # img = []\\n # for j in range(len(image)):\\n # img.append(list(image[j]))\\n # #print(img[:5])\\n plt.imshow(images[i])\\n #plt.imshow(images[i])\\n plt.title(titles[i], size=12)\\n plt.xticks(())\\n plt.yticks(())\",\n \"def plot_gallery(images, titles, h, w, n_row=3, n_col=4):\\n pl.figure(figsize=(1.8 * n_col, 2.4 * n_row))\\n pl.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35)\\n for i in range(n_row * n_col):\\n pl.subplot(n_row, n_col, i + 1)\\n pl.imshow(images[i].reshape((h, w)), cmap=pl.cm.gray)\\n pl.title(titles[i], size=12)\\n pl.xticks(())\\n pl.yticks(())\",\n \"def process_images(self, images, mode='train'):\\n if self.dataset_name == 'dataset1':\\n return images[:5000]\\n elif self.dataset_name == 'dataset2':\\n return np.add(images, 745)\\n elif self.dataset_name == 'dataset3':\\n # concatenate three images into three-digit image\\n if mode == 'train':\\n return np.concatenate((images[:40000], images[10000:50000],\\n images[20000:60000]), axis=1)\\n elif mode == 'test':\\n return np.concatenate((images[:8000], images[1000:9000],\\n images[2000:10000]), axis=1)\\n elif self.dataset_name == 'dataset4':\\n # merge two images into one\\n if mode == 'train':\\n return images[:50000] + images[-50000:]\\n elif mode == 'test':\\n return images[:9000] + images[-9000:]\\n else:\\n return images\",\n \"def _showphotos(self, btn):\\n global layout\\n global curdir\\n\\n # Create the layouts.\\n layout = GridLayout(cols=5, padding=0, spacing=0, size_hint=(1, None))\\n layout.bind(minimum_height=layout.setter(\\\"height\\\"))\\n\\n foldername = btn\\n\\n # Args is combined with \\\"curdir\\\" to load the thumbnails, and add them to the Gridlayout.\\n if foldername == \\\"\\\":\\n pass\\n else:\\n for filename in sorted(glob(join(curdir, \\\"thumb\\\", foldername, \\\"*\\\"))):\\n try:\\n canvas = BoxLayout(size_hint=(1, None))\\n im = Image(source=filename)\\n canvas.add_widget(im)\\n layout.add_widget(canvas)\\n\\n except Exception:\\n print(\\\"Pictures: Unable to load <%s>\\\" % filename)\\n\\n return layout\",\n \"def crop_images(dataset_dir):\\n data = []\\n for folder in os.listdir(dataset_dir):\\n path = os.path.join(dataset_dir, folder, \\\"*.png\\\")\\n data.extend(glob(path))\\n\\n for index, filePath in enumerate(data):\\n print ('{}/{}'.format(index, len(data)))\\n\\n img = scipy.misc.imread(filePath).astype(np.uint8)\\n img = scipy.misc.imresize(img, 0.25, interp='bilinear', mode=None)\\n scipy.misc.imsave('/data/vllab1/dataset/CITYSCAPES/CITY_test/fine_image/' + filePath.split('/')[-1], img)\",\n \"def plotImages(images_arr):\\n \\n fig, axes = plt.subplots(1, 5, figsize=(20,20))\\n axes = axes.flatten()\\n for img, ax in zip( images_arr, axes):\\n ax.imshow(img)\\n ax.axis('off')\\n plt.tight_layout()\\n plt.show()\\n \\n return\",\n \"def images_example(path='train_images.pickle'):\\n patch_size = (8, 8)\\n\\n with open('train_images.pickle', 'rb') as f:\\n train_pictures = pickle.load(f)\\n\\n patches = sample_patches(train_pictures, psize=patch_size, n=20000)\\n\\n plt.figure()\\n plt.imshow(train_pictures[0])\\n plt.title(\\\"Picture Example\\\")\\n\\n plt.figure()\\n for i in range(4):\\n plt.subplot(2, 2, i + 1)\\n plt.imshow(patches[:, i].reshape(patch_size), cmap='gray')\\n plt.title(\\\"Patch Example\\\")\\n plt.show()\",\n \"def build_dataset(self):\\n print(\\\"reading data of images currently , please wait......\\\")\\n x_train, y_train, _ = get_images(self.train_directory)\\n x_test, y_test, _ = get_images(self.test_directory)\\n x_train, y_train = image_subset(self.num_classes, x_train, y_train)\\n x_test, y_test = image_subset(self.num_classes, x_test, y_test)\\n x_train = x_train.astype('float32')\\n x_test = x_test.astype('float32')\\n self.x_train = x_train / 255\\n self.x_test = x_test / 255\\n self.y_train = utils.to_categorical(y_train, self.num_classes)\\n self.y_test = utils.to_categorical(y_test, self.num_classes)\",\n \"def display_images(images, imageConversion=cv.COLOR_BGR2RGB, titles=[], columns=4, rows=None, show=True):\\n if not show:\\n return\\n if imageConversion is not None:\\n images = [cv.cvtColor(img, imageConversion) for img in images]\\n\\n # append filtered image\\n if rows is None:\\n rows = ceil(float(len(images)) / columns)\\n\\n try:\\n for i in xrange(len(images)):\\n plt.subplot(rows,columns,i+1),plt.imshow(images[i],'gray')\\n if titles:\\n plt.title(titles[i])\\n plt.xticks([]),plt.yticks([])\\n plt.show()\\n except:\\n logging.exception(\\\"Could not plot / show images. Saving instead.\\\")\\n save_plt_figure(plt, \\\"img_show\\\")\",\n \"def plotgrid(data,d=10,shape=(30,30)):\\n ion()\\n gray()\\n clf()\\n for i in range(min(d*d,len(data))):\\n subplot(d,d,i+1)\\n row = data[i]\\n if shape is not None: row = row.reshape(shape)\\n imshow(row)\\n ginput(1,timeout=0.1)\",\n \"def plot_sample_imgs(get_imgs_fun, img_shape, plot_side=5, savepath=None):\\n f, axarr = plt.subplots(plot_side, plot_side)\\n samples = get_imgs_fun(plot_side*plot_side)\\n for row in range(plot_side):\\n for col in range(plot_side):\\n axarr[row, col].imshow(samples[plot_side*row+col].reshape(img_shape))\\n axarr[row, col].set_title('')\\n axarr[row, col].axis('off')\\n if savepath:\\n f.savefig(savepath)\\n plt.close()\\n else:\\n plt.show()\",\n \"def visualize(**images):\\n n_images = len(images)\\n plt.figure(figsize=(20,8))\\n for idx, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n_images, idx + 1)\\n plt.xticks([]); \\n plt.yticks([])\\n # get title from the parameter names\\n plt.title(name.replace('_',' ').title(), fontsize=20)\\n plt.imshow(image)\\n plt.savefig('sample_gt_pred_2_max.jpeg')\\n plt.show()\",\n \"def init_datasets(self, display_samples = False):\\n print(\\\"==> Loading images from \\\", self.img_dir)\\n self.image_data_gen = ImageDataGenerator(\\n rescale=1./255,\\n #rotation_range=30,\\n #shear_range=30,\\n #width_shift_range=.15,\\n #height_shift_range=.15,\\n #zoom_range=0.5,\\n validation_split=0.2)\\n\\n self.train_dataset = self.image_data_gen.flow_from_directory(\\n batch_size=BATCH_SIZE,\\n directory=self.img_dir,\\n shuffle=True,\\n target_size=self.img_size,\\n class_mode='sparse',\\n subset='training')\\n\\n self.val_dataset = self.image_data_gen.flow_from_directory(\\n batch_size=BATCH_SIZE,\\n directory=self.img_dir,\\n shuffle=True,\\n target_size=self.img_size,\\n class_mode='sparse',\\n subset='validation')\\n\\n if display_samples:\\n self.display_sample_images()\",\n \"def plotRandImages(train_data, output):\\n rint_array = np.random.randint(0,train_data.shape[0],size=4)\\n\\n fig = plt.figure(figsize=(8,8))\\n plt.subplot(2,2,1)\\n for ii,rint in enumerate(rint_array):\\n plt.subplot(2,2,ii+1)\\n img = train_data[rint].reshape((20,20)).T\\n #print \\\" output: \\\",output[rint]\\n plt.imshow(img,aspect='auto',interpolation='nearest',\\n origin='lower')\\n plt.title('Image of %d'%output.T[rint])\\n plt.show()\\n\\n return\",\n \"def display(self):\\n nrow = 2\\n ncol = len(self.views) + 1\\n rows = [(self.views[0].original, len(self.views)),\\n (self.views[0].image, len(self.views) + 1)]\\n fig, axes = plt.subplots(nrows=nrow, ncols=ncol,\\n figsize=self._figsize(rows),\\n squeeze=True)\\n originals = [(v.position.id, v.original) for v in self.views] + [\\n ('combined', np.median(np.stack([v.original for v in self.views]), axis=0))]\\n warped = [(v.position.id, v.image) for v in self.views] + [\\n ('combined', self.image)]\\n for ax, (title, img) in zip(axes.ravel(), originals + warped):\\n ax.imshow(img)\\n ax.axis('off')\\n ax.xaxis.set_visible(False)\\n ax.yaxis.set_visible(False)\\n ax.set(title=title)\\n fig.tight_layout()\\n fig.canvas.draw()\\n img_array = np.array(fig.canvas.renderer._renderer)\\n plt.close('all')\\n return img_array\",\n \"def plot_gallery(images, titles, h, w, n_row=3, n_col=4):\\n plt.figure(figsize=(1.8 * n_col, 2.4 * n_row))\\n plt.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35)\\n for i in range(n_row * n_col):\\n plt.subplot(n_row, n_col, i + 1)\\n plt.imshow(images[i].reshape((h, w)), cmap=plt.cm.gray)\\n plt.title(titles[i], size=12)\\n plt.xticks(())\\n plt.yticks(())\\n plt.show()\\n plt.savefig(\\\"feature_{}.png\\\".format(50))\",\n \"def visualize(imgobjs, cols=4, collated=True, size=None):\\n\\n ## Separate into list of single instance image objects\\n imgs = []\\n if isinstance(imgobjs, list):\\n for io in imgobjs:\\n imgs += images._create_img_list(io)\\n else:\\n imgs = images._create_img_list(imgobjs)\\n\\n ## Grid layout settings. Sets N, N_rows, N_cols\\n N = len(imgs)\\n assert N > 0\\n if not size:\\n size = [0, 0] # H, W\\n for img in imgs:\\n _, _, H, W = get_dimensions(img)\\n size[0] += H\\n size[1] += W\\n size = [int(d/len(imgs)) for d in size]\\n else:\\n assert len(size) == 2\\n\\n N_cols = cols if cols else 4\\n if N < 4:\\n N_cols = N\\n N_rows = math.ceil(N/N_cols)\\n print(f\\\"Cols: {N_cols}, Rows: {N_rows}\\\")\\n\\n ## Display Figure\\n figure = plt.figure(figsize=(15, 10))\\n for i in range(N):\\n dims = images.get_dimensions(imgs[i])[1:]\\n title = f\\\"[Image {i+1}/{N}]\\\"\\n if isinstance(imgs[i], str):\\n title = f\\\"[Image {i+1}/{N}] {files.get_filename(imgs[i])}\\\"\\n title += f\\\"\\\\n shape{dims}\\\"\\n img = images.to_np(imgs[i], size=size, color='rgb')\\n subplt = figure.add_subplot(N_rows, N_cols, i+1)\\n subplt.set_title(title, fontsize=10)\\n subplt.axis('off')\\n plt.imshow(img)\\n figure.tight_layout()\\n # plt.subplots_adjust(wspace=.25, hspace=.5)\\n plt.show()\",\n \"def display_dataset(path, save, dset='sum'):\\n # List datasets\\n files_surf = os.listdir(path[0])\\n files_surf.sort()\\n files_deep = os.listdir(path[1])\\n files_deep.sort()\\n files_calc = os.listdir(path[2])\\n files_calc.sort()\\n\\n # Corrected names\\n files = os.listdir(r'Y:\\\\3DHistoData\\\\Subvolumes_2mm')\\n files.sort()\\n\\n k = 0\\n # Loop for displaying images\\n for fsurf, fdeep, fcalc in zip(files_surf, files_deep, files_calc):\\n # Load images\\n im_surf = loadh5(path[0], fsurf, dset)\\n im_deep = loadh5(path[1], fdeep, dset)\\n im_calc = loadh5(path[2], fcalc, dset)\\n # Create figure\\n fig = plt.figure(dpi=300)\\n ax1 = fig.add_subplot(131)\\n ax1.imshow(im_surf, cmap='gray')\\n plt.title(fsurf + ', Surface')\\n ax2 = fig.add_subplot(132)\\n ax2.imshow(im_deep, cmap='gray')\\n plt.title('Deep')\\n ax3 = fig.add_subplot(133)\\n ax3.imshow(im_calc, cmap='gray')\\n plt.title('Calcified')\\n if save is not None:\\n while files[k] == 'Images' or files[k] == 'MeanStd':\\n k += 1\\n\\n # Save figure\\n if not os.path.exists(save):\\n os.makedirs(save, exist_ok=True)\\n plt.tight_layout()\\n fig.savefig(os.path.join(save, files[k]), bbox_inches=\\\"tight\\\", transparent=True)\\n plt.close()\\n\\n # Save h5\\n if not os.path.exists(save + '\\\\\\\\MeanStd\\\\\\\\'):\\n os.makedirs(save + '\\\\\\\\MeanStd\\\\\\\\', exist_ok=True)\\n\\n h5 = h5py.File(save + \\\"\\\\\\\\MeanStd\\\\\\\\\\\" + files[k] + '.h5', 'w')\\n h5.create_dataset('surf', data=im_surf)\\n h5.create_dataset('deep', data=im_deep)\\n h5.create_dataset('calc', data=im_calc)\\n h5.close()\\n else:\\n plt.show()\\n k += 1\",\n \"def matplotlibDisplayMulti(imgs, titles=None, colorFlag='gray'):\\n if titles is None:\\n titles = []\\n for i in range(len(imgs)):\\n titles.append(\\\"IMAGE \\\" + str(i))\\n for i in range(len(imgs)):\\n plt.subplot(1, len(imgs), 1+i)\\n plt.imshow(imgs[i], colorFlag)\\n plt.title(titles[i])\\n plt.xticks([])\\n plt.yticks([])\\n plt.show()\",\n \"def load_images(self, tmx):\\n for image_data in tmx.images:\\n if image_data:\\n image, _, _ = image_data\\n self.load_image(image)\",\n \"def show_dataset(folder, n=10):\\n volumes = volume_paths(folder)\\n for i, v in enumerate(volumes):\\n print(load_pages(v)[0][0:500])\\n if i >= n:\\n break\",\n \"def get_images(self, page_number):\",\n \"def gather_images():\\n # Import an empty image\\n null_img = Image.open('assests/null/null.png')\\n null_img = ImageTk.PhotoImage(null_img.resize((100,100), Image.ANTIALIAS))\\n\\n # Import image and icon for X\\n X_img = Image.open('assests/X_Assets/X.png')\\n X_icon = ImageTk.PhotoImage(X_img.resize((15, 12), Image.ANTIALIAS))\\n X_img = ImageTk.PhotoImage(X_img.resize((95, 80), Image.ANTIALIAS))\\n\\n # Import horizontally striked X\\n X_hor = Image.open('assests/X_Assets/X_hor.png')\\n X_hor = ImageTk.PhotoImage(X_hor.resize((95, 80), Image.ANTIALIAS))\\n\\n # Import vertically striked X\\n X_vert = Image.open('assests/X_Assets/X_vert.png')\\n X_vert = ImageTk.PhotoImage(X_vert.resize((95, 80), Image.ANTIALIAS))\\n\\n # Import diagonally strikedX\\n X_diag = Image.open('assests/X_Assets/X_diag.png')\\n X_diag = ImageTk.PhotoImage(X_diag.resize((95, 80), Image.ANTIALIAS))\\n\\n # Import another diagonally striked X\\n X_diag2 = Image.open('assests/X_Assets/X_diag2.png')\\n X_diag2 = ImageTk.PhotoImage(X_diag2.resize((95, 80), Image.ANTIALIAS))\\n\\n # Import image and icon for O\\n O_img = Image.open('assests/O_Assets/O.png')\\n O_icon = ImageTk.PhotoImage(O_img.resize((14, 14), Image.ANTIALIAS))\\n O_img = ImageTk.PhotoImage(O_img.resize((90, 90), Image.ANTIALIAS))\\n\\n # Import horizontally striked O\\n O_hor = Image.open('assests/O_Assets/O_hor2.png')\\n O_hor = ImageTk.PhotoImage(O_hor.resize((90, 90), Image.ANTIALIAS))\\n\\n # Import vertically striked O\\n O_vert = Image.open('assests/O_Assets/O_vert2.png')\\n O_vert = ImageTk.PhotoImage(O_vert.resize((90, 90), Image.ANTIALIAS))\\n\\n # Import diagonally striked O\\n O_diag = Image.open('assests/O_Assets/O_diag.png')\\n O_diag = ImageTk.PhotoImage(O_diag.resize((90, 90), Image.ANTIALIAS))\\n\\n # Import another diagonally striked O\\n O_diag2 = Image.open('assests/O_Assets/O_diag2.png')\\n O_diag2 = ImageTk.PhotoImage(O_diag2.resize((90, 90), Image.ANTIALIAS))\\n\\n return (null_img, X_icon, X_img, X_hor, X_vert, X_diag, X_diag2, O_icon, O_img, O_hor, O_vert, O_diag, O_diag2)\",\n \"def plot_random_generated_images(self):\\n dimensions=(10, 10)\\n figsize=(10, 10)\\n n_samples=100\\n \\n (X, _), _ = self.generate_generator_prediction_samples(n_samples)\\n \\n self.grid_plot(X, dimensions=dimensions, figsize=figsize)\",\n \"def plot_examples(n_samples, images, start_image=0):\\n n_cols = len(images)\\n index = 0\\n for j in range(0+start_image, n_samples+start_image):\\n for col_id, img in enumerate(images):\\n img_to_plot = img[j:j+1, :, :, :]\\n img_to_plot = np.squeeze(img_to_plot)\\n plt.subplot(n_samples, n_cols, index + col_id + 1)\\n plt.imshow(img_to_plot, cmap='gray', vmin=0, vmax=1)\\n plt.axis('off')\\n index += n_cols\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6872789","0.6706518","0.66048354","0.65576744","0.6477456","0.6438162","0.64273864","0.6386546","0.6381494","0.63184965","0.6311449","0.62808603","0.6278003","0.6259482","0.6259482","0.62534124","0.6243781","0.6227257","0.6224085","0.6216505","0.6158989","0.61508155","0.61446035","0.61427486","0.61373985","0.6089885","0.6060406","0.6059162","0.6047537","0.60443485","0.60263276","0.6013175","0.6011418","0.59987587","0.5993068","0.5985406","0.5968301","0.59430104","0.5929085","0.5920354","0.59108514","0.59048563","0.59048563","0.59048563","0.59023833","0.58959174","0.5891544","0.5885532","0.5877551","0.58716077","0.58641285","0.5863476","0.5861947","0.5860006","0.5841318","0.5837511","0.58219117","0.58169425","0.5814045","0.5812875","0.5807936","0.5807744","0.5784084","0.5775105","0.57567185","0.5756346","0.5755834","0.5752832","0.5752499","0.5747984","0.57474875","0.5744836","0.5743422","0.57373273","0.5737096","0.57312435","0.5728227","0.5727724","0.57121646","0.57119465","0.5706884","0.5705012","0.57045","0.5701718","0.56953335","0.56890804","0.5686475","0.568529","0.56784683","0.5675977","0.56746984","0.5670269","0.56687915","0.5667783","0.5661418","0.5658541","0.56561935","0.5656007","0.56541514","0.5649831"],"string":"[\n \"0.6872789\",\n \"0.6706518\",\n \"0.66048354\",\n \"0.65576744\",\n \"0.6477456\",\n \"0.6438162\",\n \"0.64273864\",\n \"0.6386546\",\n \"0.6381494\",\n \"0.63184965\",\n \"0.6311449\",\n \"0.62808603\",\n \"0.6278003\",\n \"0.6259482\",\n \"0.6259482\",\n \"0.62534124\",\n \"0.6243781\",\n \"0.6227257\",\n \"0.6224085\",\n \"0.6216505\",\n \"0.6158989\",\n \"0.61508155\",\n \"0.61446035\",\n \"0.61427486\",\n \"0.61373985\",\n \"0.6089885\",\n \"0.6060406\",\n \"0.6059162\",\n \"0.6047537\",\n \"0.60443485\",\n \"0.60263276\",\n \"0.6013175\",\n \"0.6011418\",\n \"0.59987587\",\n \"0.5993068\",\n \"0.5985406\",\n \"0.5968301\",\n \"0.59430104\",\n \"0.5929085\",\n \"0.5920354\",\n \"0.59108514\",\n \"0.59048563\",\n \"0.59048563\",\n \"0.59048563\",\n \"0.59023833\",\n \"0.58959174\",\n \"0.5891544\",\n \"0.5885532\",\n \"0.5877551\",\n \"0.58716077\",\n \"0.58641285\",\n \"0.5863476\",\n \"0.5861947\",\n \"0.5860006\",\n \"0.5841318\",\n \"0.5837511\",\n \"0.58219117\",\n \"0.58169425\",\n \"0.5814045\",\n \"0.5812875\",\n \"0.5807936\",\n \"0.5807744\",\n \"0.5784084\",\n \"0.5775105\",\n \"0.57567185\",\n \"0.5756346\",\n \"0.5755834\",\n \"0.5752832\",\n \"0.5752499\",\n \"0.5747984\",\n \"0.57474875\",\n \"0.5744836\",\n \"0.5743422\",\n \"0.57373273\",\n \"0.5737096\",\n \"0.57312435\",\n \"0.5728227\",\n \"0.5727724\",\n \"0.57121646\",\n \"0.57119465\",\n \"0.5706884\",\n \"0.5705012\",\n \"0.57045\",\n \"0.5701718\",\n \"0.56953335\",\n \"0.56890804\",\n \"0.5686475\",\n \"0.568529\",\n \"0.56784683\",\n \"0.5675977\",\n \"0.56746984\",\n \"0.5670269\",\n \"0.56687915\",\n \"0.5667783\",\n \"0.5661418\",\n \"0.5658541\",\n \"0.56561935\",\n \"0.5656007\",\n \"0.56541514\",\n \"0.5649831\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.760682"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9095,"cells":{"query":{"kind":"string","value":"Normalises and reshapes the images in the dataset."},"document":{"kind":"string","value":"def normalise(dataset):\n # Scale images to the [0, 1] range\n dataset = dataset.astype(\"float32\") / 255\n # Make sure images have shape (28, 28, 1)\n return np.expand_dims(dataset, -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 normalize_dataset(self):","def normalize_images(data, blend_cat, Args):\n im = data['X_train']['blend_image']\n std = np.std(im)\n mean = np.mean(im)\n data['X_train']['blend_image'] = (im - mean) / std\n data['X_val']['blend_image'] = (data['X_val']['blend_image'] - mean) / std\n data['X_train'] = normalize_other_inputs(data['X_train'], Args)\n data['X_val'] = normalize_other_inputs(data['X_val'], Args)\n for key in data['Y_train'].keys():\n data['Y_train'][key] = (data['Y_train'][key] - mean) / std\n data['Y_val'][key] = (data['Y_val'][key] - mean) / std\n blend_cat['std'] = std\n blend_cat['mean'] = mean\n return data","def flatten_image(data):\n\t# print(img.shape[0])\n\t# print(img.shape[1])\n\t# cv2.imshow('image',img)\n\t# gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n\t# plt.imshow(gray)\n\t# plt.show()\n\t# X_normalized = preprocessing.normalize(img, norm='l2')\n\t\n\t# s = img.shape[0] * img.shape[1]\n\t# img_wide = img.reshape((1, s,-1))\t\n\t# img_wide = np.rollaxis(X_normalized, axis=1, start=0)\n\t# plt.imshow(img_wide[0])\n\t# plt.show()\n\t# print(X_normalized)\n\tnsamples, nx, ny = data.shape\n\td2_train_dataset = data.reshape((nsamples,nx*ny))\n\treturn d2_train_dataset","def normalize_data(img):\n nor = np.linalg.norm(img, axis = 1)\n nor = np.reshape(nor, (len(img), 1))\n img = np.divide(img, nor)\n return img","def _normalize(images):\n images -= images.mean(axis=0, keepdims=True)\n images /= np.maximum(images.std(axis=0, keepdims=True), 3e-1)","def _normalize(images):\n images -= images.mean(axis=0, keepdims=True)\n images /= np.maximum(images.std(axis=0, keepdims=True), 3e-1)","def normalise(image):","def normalize_data(data):\n if data.element_spec[0].shape[2] == 1:\n data = data.map(lambda x, y: (tf.image.grayscale_to_rgb(\n tf.image.resize(x, [32, 32])), y))\n else:\n data = data.map(lambda x, y: (tf.image.resize(x, [32, 32]), y))\n normalization_layer = tf.keras.layers.experimental.preprocessing.Rescaling(1. / 255)\n normalized_ds = data.map(lambda x, y: (normalization_layer(x), y))\n return normalized_ds","def preprocess(imgs):\n imgs_p = np.ndarray((len(imgs), img_rows, img_cols), dtype=np.float32)\n for i in range(len(imgs)):\n imgs_p[i] = imgs[i].reshape((img_rows, img_cols))/255.\n\n imgs_p = imgs_p[..., np.newaxis]\n\n # Perform data normalization\n mean = imgs_p.mean()\n std = imgs_p.std()\n imgs_p -= mean\n imgs_p /= std\n\n return imgs_p","def normalize_image(self):\n # The image normalization is identical to Cloud TPU ResNet.\n self._image = tf.image.convert_image_dtype(self._image, dtype=tf.float32)\n offset = tf.constant(DATASET_MEAN)\n offset = tf.expand_dims(offset, axis=0)\n offset = tf.expand_dims(offset, axis=0)\n self._image -= offset\n\n scale = tf.constant(DATASET_VAR)\n scale = tf.expand_dims(scale, axis=0)\n scale = tf.expand_dims(scale, axis=0)\n self._image /= scale","def unnormalize(images, mean, std):\n \n unnorm_images = images * std + mean\n \n \n return unnorm_images","def set_normalization(self, dataloader):\n mean = 0\n square = 0\n for (data_in, _) in dataloader:\n mean += data_in.mean()\n square += data_in.pow(2).mean()\n\n mean /= len(dataloader)\n square /= len(dataloader)\n std = np.sqrt(square - mean ** 2)\n\n # The input data should be roughly normally distributed after\n # passing through net_fixed.\n self.scale_in.bias.data.fill_(- mean / std)\n self.scale_in.weight.data.fill_(1 / std)","def normalize(self):\n d = learning_utils.convert_data_to_2d(self._data)\n d = learning_utils.normalize_2d(d)\n self._data = learning_utils.convert_data_to_1d(d)","def normalization(imgs):\n\n imgs = np.asarray(imgs).astype(np.float32)\n imgs = np.expand_dims(imgs / 255, axis=-1)\n return imgs","def denormalize(img, dataset=\"imagenet\"):\r\n if dataset == \"cifar10\":\r\n c_std = [0.247, 0.243, 0.261]\r\n c_mean = [0.4914, 0.4822, 0.4466]\r\n elif dataset == \"imagenet\":\r\n c_std = [0.229, 0.224, 0.225]\r\n c_mean = [0.485, 0.456, 0.406]\r\n for i in [0, 1, 2]:\r\n img[i] = img[i] * c_std[i] + c_mean[i]\r\n return img","def normalize(dataset):\n minVals = dataset.min(axis=0)\n maxVals = dataset.max(axis=0)\n factors = maxVals-minVals\n num = dataset.shape[0]\n norm_data = (dataset - np.tile(minVals,(num,1)))/np.tile(factors,(num,1)) \n return norm_data","def _normalize_images(self, images: th.Tensor) -> th.Tensor:\n output = ((images+2)/4 - self._norm_mean)/self._norm_std\n return output","def denormalize(img, means, stds, resize_to_original=False):\n\n img = np.moveaxis(img, 0, 2)\n img = img*stds + means\n img = np.clip(img, 0, 255).astype('uint8')\n\n if resize_to_original:\n # revert def preprocess_image()\n img = img[:,(img_w//4): (img_w - img_w//4),:]\n img = cv2.copyMakeBorder( img, img.shape[0], 0,0,0, cv2.BORDER_CONSTANT) #, borderType)\n img = cv2.resize(img, (img_orig_w, img_orig_h))\n \n return img","def normalize_ds(dataset):\n dataset = copy.copy(dataset)\n\n dim_dataset = dataset.shape\n\n for n_row in range(dim_dataset[0]):\n k = dataset[n_row,:]\n k_norm =(k - np.min(k))/(np.max(k) - np.min(k))\n dataset[n_row,:] = k_norm\n\n return dataset","def _normalize(self, dataset):\n if self.max is None: # if we are normalizing the training set\n self.max, self.min = dataset.max(), dataset.min() # find max, min value for each columns\n for row in dataset.index: # for each row in dataset\n for col in self.features: # for each feature in the instance (exclude target)\n dataset.at[row, col] = (dataset.at[row, col] - self.min[col]) / (self.max[col] - self.min[col]) if col != \"Bias\" else 1","def reshape_normalise(img):\n\t# The image shape is expected to match the input of VGG19\n\timg = np.resize(img, (1, CONFIG.IMAGE_HEIGHT, CONFIG.IMAGE_WIDTH, CONFIG.COLOR_CHANNELS)).astype('float32')\n\timg -= CONFIG.MEAN_PIXEL\n\treturn img","def _normalize(\n ds: xr.Dataset,\n *,\n dim: Sequence[str],\n kind: str = ADDITIVE,\n) -> xr.Dataset:\n if \"norm\" in ds:\n norm = ds.norm\n else:\n norm = ds.data.mean(dim=dim)\n norm.attrs[\"_group_apply_reshape\"] = True\n\n return xr.Dataset(\n dict(data=apply_correction(ds.data, invert(norm, kind), kind), norm=norm)\n )","def reshape_dataset(self, dataset, params):\n assert hasattr(params, \"vectorize_data\"), (\n \"Model params must set vectorize_data.\")\n for key in dataset.keys():\n if dataset[key] is None:\n continue\n dataset[key].images = dp.reshape_data(dataset[key].images, params.vectorize_data)[0]\n dataset[key].shape = dataset[key].images.shape\n return dataset","def normalize_images(x_images, mean_value):\n x_flat = np.zeros((x_images.shape[0], 784))\n for k in range(0, x_images.shape[0]):\n img = x_images[k, ...] - mean_value\n img = cv2.normalize(img.astype('float'), None, 0.0, 1.0, cv2.NORM_MINMAX).astype(np.float32)\n x_flat[k, ...] = np.reshape(img, [-1])\n\n return x_flat","def preprocess_image(self, batched_inputs):\n images = [x[\"image\"].float().to(self.device) for x in batched_inputs]\n images = [self.normalizer(img) for img in images]\n images = ImageList.from_tensors(images, self.backbone.size_divisibility)\n return images","def test_normalize(dummy_input):\n # Test the 2D image: H, W, C\n image, label = dummy_input(image_size=(512, 512, 3),\n label_size=(512, 512, 1))\n transform = Normalize(means=None, stds=None)\n _image, _label = transform(image, label, normalize_tags=[True, False])\n assert not (image == _image).all()\n assert (label == _label).all()\n\n # Test the 3D image: H, W, D, C\n image, label = dummy_input(image_size=(512, 512, 20, 3),\n label_size=(512, 512, 20, 1))\n transform = Normalize(means=None, stds=None)\n _image, _label = transform(image, label, normalize_tags=[True, False])\n assert not (image == _image).all()\n assert (label == _label).all()\n assert np.abs(np.mean(_image)-0) < 1e-8\n assert np.abs(np.std(_image)-1) < 1e-8","def normalize_data(data=None):\n # Data pre-processing\n n = data.shape[0]\n for i in range(n):\n xx = data[i,:,:]\n xx -= np.mean(xx) # Centering in 0\n xx /= np.linalg.norm(xx) # Normalizing to 1\n data[i] = xx # Affect value\n return data","def img_normalize(image, label):\n mean, std = ds_stats\n image -= tf.constant(mean, shape=[1, 1, num_channels], dtype=image.dtype)\n image /= tf.constant(std, shape=[1, 1, num_channels], dtype=image.dtype)\n return image, label","def normalize(self, image, transpose=False, data_type=None):\n return normalize(image, self.mean, self.std, transpose)","def pre_process_data(input_path: list, cuts: int, shape: int = 32, normalize: bool = True) -> list:\n images = []\n images_uncut = []\n for files_path in input_path:\n\n files = os.listdir(files_path) # TODO paths\n for f in files:\n file_path = f'{files_path}/{f}'\n im_uncut = cv2.imread(file_path)\n im_uncut = cv2.cvtColor(im_uncut, cv2.COLOR_RGB2GRAY)\n images_uncut.append(cv2.resize(im_uncut, (shape * cuts, shape * cuts)))\n x = np.array(images_uncut)\n\n if normalize:\n x_mean = np.mean(x, axis=(0, 1, 2))\n x_std = np.std(x, axis=(0, 1, 2))\n x = (x - x_mean) / (x_std + 1e-9)\n\n for im in x:\n height = im.shape[0]\n width = im.shape[1]\n frac_h = height // cuts\n frac_w = width // cuts\n i = 0\n image = []\n for h in range(cuts):\n for w in range(cuts):\n crop = im[h * frac_h:(h + 1) * frac_h, w * frac_w:(w + 1) * frac_w]\n crop_rehaped = cv2.resize(crop, (shape, shape))\n image.append([crop_rehaped, i, number_to_angle(i, cuts), neighbours(i, cuts)])\n i = i + 1\n images.append(image)\n # return np.array(images) # todo back to array\n return images","def normalize_data(self):\n self.x_mean, self.x_std = du.get_mean_std(self.x_train)\n self.x_train = du.normalize(self.x_train, self.x_mean, self.x_std)\n if self.x_test is not None and self.y_test is not None:\n self.x_test = du.normalize(self.x_test, self.x_mean, self.x_std)\n self.normalized_data = True","def normalize_images(image_sitk):\n\n max = 400\n min = -1000\n\n image_np = sitk.GetArrayFromImage(image_sitk)\n\n # Normalization\n image_np = (image_np - min)/(max - min)\n image_np[image_np > 1] = 1\n image_np[image_np < 0] = 0\n\n # Convert back to SITK\n out_image_sitk = sitk.GetImageFromArray(image_np)\n out_image_sitk.CopyInformation(image_sitk)\n\n return out_image_sitk","def preprocess_image(self, batched_inputs):\n images = [x.to(self.device) for x in batched_inputs]\n norms = [self.normalizer(x) for x in images]\n size = (norms[0].shape[1],norms[0].shape[2])\n images = ImageList.from_tensors(norms, self.backbone.size_divisibility)\n return images, size","def normalize(image, label):\n image -= settings.DATASET_MEAN\n image /= settings.DATASET_STD\n\n return image, label","def prepare(dataset):\n dataset = dataset.reshape(dataset.shape[0], 1, 28, 28)\n dataset = dataset.astype('float32')\n dataset /= 255\n return dataset","def normalize(dataset):\n return normalize_standard_deviation(normalize_mean(dataset))","def run(self):\n self.run_tasks()\n self.images = np.array(self.images)\n self.shapes.extend(self.images.shape[-2:])\n\n self.images = np.reshape(self.images, self.shapes)","def normalize(img, mean, std, data_format='CHW'):\n _assert_image_tensor(img, data_format)\n\n mean = paddle.to_tensor(mean, place=img.place)\n std = paddle.to_tensor(std, place=img.place)\n\n if _is_channel_first(data_format):\n mean = mean.reshape([-1, 1, 1])\n std = std.reshape([-1, 1, 1])\n\n return (img - mean) / std","def rescale_data(self):\n\n # Dividing every array of simulated data vectors by the mean of that array.\n '''# Didnt work\n for key in self.data.keys():\n self.data[key] /= np.mean(self.data[key])\n '''\n\n self.rescaled = True\n\n # Mean normalization\n \"\"\" didnt work\n for key in self.data.keys():\n self.data[key] -= np.mean(self.data[key])\n self.data[key] /= (np.max(self.data[key]) - np.min(self.data[key]))\n \"\"\"\n\n # Median normalization\n \"\"\" didnt work, still dividing by large number \n for key in self.data.keys():\n self.data[key] -= np.median(self.data[key])\n self.data[key] /= (np.max(self.data[key]) - np.min(self.data[key]))\n \"\"\"\n\n # Divide by median\n \"\"\" didnt work\n for key in self.data.keys():\n self.data[key] -= np.median(self.data[key])\n self.data[key] /= (np.median(self.data[key]))\n \"\"\"\n\n # Take logarithm of data\n \"\"\" didnt work\n for key in self.data.keys():\n self.data[key] = np.log10(self.data[key])\n \"\"\"\n\n # Scale by length of vector\n \"\"\"\n for key in self.data.keys():\n self.data[key] /= np.linalg.norm(self.Cl_noiseless)\n \"\"\"\n\n \n # Scale by negative of the natural logarithm \n for key in self.data.keys():\n self.data[key] = -1 * np.log(self.data[key]) \n \n \"\"\"\n # Scale by subtracting the mean and dividing by std\n std = np.nanstd(self.data['data'])\n mean = np.nanmean(self.data['data'])\n for key in self.data.keys():\n # self.data[key] -= np.log(self.Cl_noiseless) # -1* # scale this same way\n # self.data[key] -= self.Cl_noiseless # -1* # scale this same way\n self.data[key] -= mean \n self.data[key] /= std\n \"\"\"","def normalize(img):\n # TODO: implement this function.\n min_img = min([min(i) for i in img])\n max_img = max([max(i) for i in img])\n\n for i in range(len(img)):\n \tfor j in range(len(img[0])):\n \t\timg[i][j] = ((img[i][j] - min_img) / (max_img - min_img))\n #raise NotImplementedError\n return img","def preprocess_image(self, batched_inputs):\n images = [x[\"image\"].to(self.device) for x in batched_inputs]\n images_aug = [x[\"image_color\"].to(self.device) for x in batched_inputs]\n\n images = [self.normalizer(x) for x in images]\n images_aug = [self.normalizer(x) for x in images_aug]\n\n images = ImageList.from_tensors(images,\n self.backbone.size_divisibility)\n images_aug = ImageList.from_tensors(images_aug,\n self.backbone.size_divisibility)\n return images, images_aug","def preprocess(img):\n \n scaler=StandardScaler() ## scaler object to perform preprocessing\n img=scaler.fit_transform(img) ## zero-center and normalize\n \n return img","def normalize(self):\n self._data /= self.norm()","def normalise(self):\n return self / self.mean(axis=1).reshape(self.shape[0], 1)","def unNormalizeData(normalizedData, data_mean, data_std, dimensions_to_ignore):\n T = normalizedData.shape[0]\n D = data_mean.shape[0]\n\n origData = np.zeros((T, D), dtype=np.float32)\n dimensions_to_use = []\n for i in range(D):\n if i in dimensions_to_ignore:\n continue\n dimensions_to_use.append(i)\n dimensions_to_use = np.array(dimensions_to_use)\n\n origData[:, dimensions_to_use] = normalizedData\n\n # potentially ineficient, but only done once per experimentdata_conversions\n stdMat = data_std.reshape((1, D))\n stdMat = np.repeat(stdMat, T, axis=0)\n meanMat = data_mean.reshape((1, D))\n meanMat = np.repeat(meanMat, T, axis=0)\n origData = np.multiply(origData, stdMat) + meanMat\n return origData","def normalizeData(meanAndStd, dataset):\n\n for i in range(len(dataset)):\n for j in range(len(dataset[i])-1):\n mean = meanAndStd[j][\"mean\"]\n std = meanAndStd[j][\"std\"]\n dataset[i][j] = (dataset[i][j] - mean)/std","def pre_process(self, images: Union[np.ndarray, List]) -> np.ndarray:\n images = validate_image(images)\n image_sizes = []\n image_arr = []\n for image in images:\n image_sizes.append(image.shape)\n image = resize(image,\n height=self.in_h,\n width=self.in_w)\n image = normalize(image)\n image_arr.append(image)\n image_arr = np.array(image_arr)\n return image_arr, image_sizes","def _images_and_boxes_preprocessing(self, imgs, boxes):\r\n # Image [0, 255] -> [0, 1].\r\n imgs = imgs.float()\r\n imgs = imgs / 255.0\r\n\r\n height, width = imgs.shape[2], imgs.shape[3]\r\n # The format of boxes is [x1, y1, x2, y2]. The input boxes are in the\r\n # range of [0, 1].\r\n boxes[:, [0, 2]] *= width\r\n boxes[:, [1, 3]] *= height\r\n boxes = transform.clip_boxes_to_image(boxes, height, width)\r\n\r\n if self._split == \"train\":\r\n # Train split\r\n imgs, boxes = transform.random_short_side_scale_jitter(\r\n imgs,\r\n min_size=self._jitter_min_scale,\r\n max_size=self._jitter_max_scale,\r\n boxes=boxes,\r\n )\r\n imgs, boxes = transform.random_crop(imgs, self._crop_size, boxes=boxes)\r\n\r\n # Random flip.\r\n imgs, boxes = transform.horizontal_flip(0.5, imgs, boxes=boxes)\r\n elif self._split == \"val\":\r\n # Val split\r\n # Resize short side to crop_size. Non-local and STRG uses 256.\r\n imgs, boxes = transform.random_short_side_scale_jitter(\r\n imgs, min_size=self._crop_size, max_size=self._crop_size, boxes=boxes\r\n )\r\n\r\n # Apply center crop for val split\r\n imgs, boxes = transform.uniform_crop(\r\n imgs, size=self._crop_size, spatial_idx=1, boxes=boxes\r\n )\r\n\r\n if self._test_force_flip:\r\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\r\n elif self._split == \"test\":\r\n # Test split\r\n # Resize short side to crop_size. Non-local and STRG uses 256.\r\n imgs, boxes = transform.random_short_side_scale_jitter(\r\n imgs, min_size=self._crop_size, max_size=self._crop_size, boxes=boxes\r\n )\r\n\r\n if self._test_force_flip:\r\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\r\n else:\r\n raise NotImplementedError(\"{} split not supported yet!\".format(self._split))\r\n\r\n # Do color augmentation (after divided by 255.0).\r\n if self._split == \"train\" and self._use_color_augmentation:\r\n if not self._pca_jitter_only:\r\n imgs = transform.color_jitter(\r\n imgs, img_brightness=0.4, img_contrast=0.4, img_saturation=0.4\r\n )\r\n\r\n imgs = transform.lighting_jitter(\r\n imgs,\r\n alphastd=0.1,\r\n eigval=np.array(self._pca_eigval).astype(np.float32),\r\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\r\n )\r\n\r\n # Normalize images by mean and std.\r\n imgs = transform.color_normalization(\r\n imgs,\r\n np.array(self._data_mean, dtype=np.float32),\r\n np.array(self._data_std, dtype=np.float32),\r\n )\r\n\r\n if self._use_bgr:\r\n # Convert image format from RGB to BGR.\r\n # Note that Kinetics pre-training uses RGB!\r\n imgs = imgs[:, [2, 1, 0], ...]\r\n\r\n boxes = transform.clip_boxes_to_image(boxes, self._crop_size, self._crop_size)\r\n\r\n return imgs, boxes","def _compute_normalization(self, normalize=True):\n if normalize:\n if self._img_norm is None:\n if np.sum(self._data) == 0:\n self._img_norm = 1\n else:\n self._img_norm = self._compute_raw_image_norm()\n\n if self._img_norm != 0.0 and np.isfinite(self._img_norm):\n self._data /= (self._img_norm * self._normalization_correction)\n self._normalization_status = 0\n else:\n self._normalization_status = 1\n self._img_norm = 1\n warnings.warn('Overflow encountered while computing '\n 'normalization constant. Normalization '\n 'constant will be set to 1.', NonNormalizable)\n else:\n self._normalization_status = 2","def normalize(\n ds: xr.Dataset,\n *,\n dim: str,\n kind: str = ADDITIVE,\n) -> xr.Dataset:\n\n if \"norm\" in ds:\n norm = invert(ds.norm, kind)\n else:\n norm = invert(ds.data.mean(dim=dim), kind)\n\n return xr.Dataset(dict(data=apply_correction(ds.data, norm, kind)))","def scale_and_normalize_images(images, means, scales, invert_channels, normalize_to_unit_scale):\n means = torch.tensor(means, dtype=torch.float32)[None, :, None, None] # [1, 3, 1, 1]\n scales = torch.tensor(scales, dtype=torch.float32)[None, :, None, None] # [1. 3. 1. 1]\n if normalize_to_unit_scale:\n images = images / 255.\n\n images = (images - means) / scales\n if invert_channels:\n return images.flip(dims=[1])\n else:\n return images","def normalize(\n self,\n image: np.ndarray,\n data_format: Optional[Union[str, ChannelDimension]] = None,\n input_data_format: Optional[Union[str, ChannelDimension]] = None,\n ) -> np.ndarray:\n image = rescale(image=image, scale=1 / 127.5, data_format=data_format, input_data_format=input_data_format)\n image = image - 1\n return image","def normalize_batch(batch, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]):\n # normalize using imagenet mean and std\n batch = batch.clone()\n mean = torch.tensor(mean).view(-1, 1, 1)\n std = torch.tensor(std).view(-1, 1, 1)\n # if your image data is scaled to scale 0-255, uncomment the line below\n # batch.div_(255.0)\n return (batch - mean) / std","def normalize_datasets(train, test):\n columns = train.columns[:-1]\n train[columns] = (train[columns] - train[columns].mean()) / (train[columns].max() - train[columns].min())\n test[columns] = (test[columns] - test[columns].mean()) / (test[columns].max() - test[columns].min())\n\n return train, test","def _preprocess(self, data, normalize=False) -> np.ndarray:\n \n preprocessor = StandardScaler() if not normalize else Normalizer()\n\n data = preprocessor.fit_transform(data)\n \n return data","def fit(self, dataset, labels):\n self.dataset = dataset\n self.labels = labels\n self.normalization_n = []\n self.normalization_d = []\n self.first_title = list(self.dataset.keys())[0]\n for ind in range(len(self.dataset[self.first_title])):\n self.normalize_features(self.dataset, ind)","def _normalize_patches(patches):\n patches = array_ops.concat(patches, 0)\n mean, variance = nn.moments(patches, [1, 2, 3], keep_dims=True)\n patches = (patches - mean) / math_ops.sqrt(variance)\n return array_ops.reshape(patches, [array_ops.shape(patches)[0], -1])","def normalize_data(X_genesets):\n normalized_datasets = []\n for Xg in X_genesets:\n averages = np.average(Xg, axis=0)\n Xg_centered = Xg - np.repeat(averages, Xg.shape[0], axis=0)\n std_devs = np.sqrt(np.var(Xg_centered, axis=0))\n Xg_normalized = np.divide(Xg, np.repeat(std_devs, Xg.shape[0], axis=0))\n normalized_datasets.append(Xg_normalized)\n return normalized_datasets","def dimension_postprocess(self, chunked_data, original_data, scale=1, padding=True):\r\n\r\n assert len(original_data.shape) == 2, \"data dimension expected to be (xline ,samp_point)\"\r\n assert len(chunked_data.shape) == 3, \"Chunked data dimension expected to be (batch_size, xline, samp_point)\"\r\n\r\n if padding:\r\n if original_data.shape[0] < self.rows:\r\n new_images = []\r\n for data in chunked_data:\r\n new_images.append(data[0:scale * original_data.shape[0], :])\r\n chunked_data = np.array(new_images)\r\n\r\n if original_data.shape[1] < self.cols:\r\n new_images = []\r\n for data in chunked_data:\r\n new_images.append(data[:, 0:scale * original_data.shape[1]])\r\n chunked_data = np.array(new_images)\r\n\r\n new_shape = (\r\n original_data.shape[0] * scale,\r\n original_data.shape[1] * scale\r\n )\r\n reconstruction = np.zeros(new_shape)\r\n x_chunks, y_chunks = self.get_chunks(original_data)\r\n\r\n i = 0\r\n s = scale\r\n for x in x_chunks:\r\n for y in y_chunks:\r\n prior_fill = reconstruction != 0\r\n chunk = np.zeros(new_shape)\r\n chunk[x[0] * s:x[1] * s, y[0] * s:y[1] * s] += chunked_data[i]\r\n chunk_fill = chunk != 0\r\n reconstruction += chunk\r\n reconstruction[prior_fill & chunk_fill] = reconstruction[prior_fill & chunk_fill] / 2\r\n i += 1\r\n return reconstruction","def normalize_data(batch_data):\n B, N, C = batch_data.shape\n normal_data = np.zeros((B, N, C))\n for b in range(B):\n pc = batch_data[b]\n centroid = np.mean(pc, axis=0)\n pc = pc - centroid\n m = np.max(np.sqrt(np.sum(pc ** 2, axis=1)))\n pc = pc / m\n normal_data[b] = pc\n return normal_data","def normalize_data(self):\n\t\tfull_matrix = self.balance_clases()\n\t\ttexture_matrix = Normalizer().fit_transform(X=full_matrix[:,range(0,24)])\n\n\t\treturn texture_matrix","def add_image_normalization(self):\n self.methods.append(self._normalize_image)\n self.args.append(None)","def cast_and_normalise_images(images):\n images = (tf.cast(images, tf.float32) / 255.0) - 0.5\n return images","def normalize_features(self, data_dict, ind):\n pre_norm_list = []\n for title in data_dict:\n pre_norm_list.append(data_dict[title][ind])\n if self.normalization_method == 'min_max':\n mini, maxi, norm_list = normalize.min_max_normalize(pre_norm_list)\n self.normalization_n.append(mini)\n self.normalization_d.append(maxi - mini)\n elif self.normalization_method == 'z_score':\n mean, var, norm_list = normalize.z_score_normalize(pre_norm_list)\n self.normalization_n.append(mean)\n self.normalization_d.append(var)\n elif self.normalization_method == 'none':\n norm_list = pre_norm_list[:]\n self.normalization_n.append(0)\n self.normalization_d.append(1)\n for i, title in enumerate(data_dict):\n data_dict[title][ind] = norm_list[i]","def _images_and_boxes_preprocessing(self, imgs, boxes, gt_boxes=None):\n # Image [0, 255] -> [0, 1].\n imgs = imgs.float()\n imgs = imgs / 255.0\n\n height, width = imgs.shape[2], imgs.shape[3]\n # The format of boxes is [x1, y1, x2, y2]. The input boxes are in the\n # range of [0, 1].\n # boxes[:, [0, 2]] *= width\n # boxes[:, [1, 3]] *= height\n boxes = transform.clip_boxes_to_image(boxes, height, width)\n\n if self._split == \"train\":\n # Train split\n imgs, boxes = transform.random_short_side_scale_jitter(\n imgs,\n min_size=self._jitter_min_scale,\n max_size=self._jitter_max_scale,\n boxes=boxes,\n )\n imgs, boxes = transform.random_crop(\n imgs, self._crop_size, boxes=boxes\n )\n\n # Random flip.\n imgs, boxes = transform.horizontal_flip(0.5, imgs, boxes=boxes)\n elif self._split == \"val\":\n # Val split\n # Resize short side to crop_size. Non-local and STRG uses 256.\n imgs, boxes = transform.random_short_side_scale_jitter(\n imgs,\n min_size=self._crop_size,\n max_size=self._crop_size,\n boxes=boxes,\n )\n\n # Apply center crop for val split\n imgs, boxes = transform.uniform_crop(\n imgs, size=self._crop_size, spatial_idx=1, boxes=boxes\n )\n\n if self._test_force_flip:\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\n elif self._split == \"test\":\n # Test split\n # Resize short side to crop_size. Non-local and STRG uses 256.\n imgs, boxes = transform.random_short_side_scale_jitter(\n imgs,\n min_size=self._crop_size,\n max_size=self._crop_size,\n boxes=boxes,\n )\n\n if self._test_force_flip:\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\n else:\n raise NotImplementedError(\n \"{} split not supported yet!\".format(self._split)\n )\n\n # Do color augmentation (after divided by 255.0).\n if self._split == \"train\" and self._use_color_augmentation:\n if not self._pca_jitter_only:\n imgs = transform.color_jitter(\n imgs,\n img_brightness=0.4,\n img_contrast=0.4,\n img_saturation=0.4,\n )\n\n imgs = transform.lighting_jitter(\n imgs,\n alphastd=0.1,\n eigval=np.array(self._pca_eigval).astype(np.float32),\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\n )\n\n # Normalize images by mean and std.\n imgs = transform.color_normalization(\n imgs,\n np.array(self._data_mean, dtype=np.float32),\n np.array(self._data_std, dtype=np.float32),\n )\n\n if not self._use_bgr:\n # Convert image format from BGR to RGB.\n # Note that Kinetics pre-training uses RGB!\n imgs = imgs[:, [2, 1, 0], ...]\n\n boxes = transform.clip_boxes_to_image(\n boxes, self._crop_size, self._crop_size\n )\n\n return imgs, boxes","def denormalize_detections(detections, resized_size, scale, pad):\n detections[:, 0] = (detections[:, 0] * resized_size - pad[0]) * scale\n detections[:, 1] = (detections[:, 1] * resized_size - pad[1]) * scale\n detections[:, 2] = (detections[:, 2] * resized_size - pad[0]) * scale\n detections[:, 3] = (detections[:, 3] * resized_size - pad[1]) * scale\n\n detections[:, 4::2] = (detections[:, 4::2] * resized_size - pad[1]) * scale\n detections[:, 5::2] = (detections[:, 5::2] * resized_size - pad[0]) * scale\n return detections","def _postprocess(img):\n img = _scale_to_zero_one(img)\n img = img.reshape(1, -1) # to avoid a scikit-learn deprecation warning later\n return img","def preprocess_data():\n le = preprocessing.LabelEncoder()\n # Reshape and normalize pixel values to be between 0 and 1\n train_images_reshaped = train_images.reshape(len(train_images), 1024, 1024, 1)/255.\n test_images_reshaped = test_images.reshape(len(test_images), 1024, 1024, 1)/255.\n\n return train_images_reshaped, test_images_reshaped, le.fit_transform(train_labels), le.fit_transform(test_labels)","def preprocess(self):\n \n file_name_list = os.listdir(self.image_dir)\n random.seed(1234)\n random.shuffle(file_name_list)\n \n for i,d in enumerate(self.domains):\n self.attr2idx[d]=i \n\n for i, file_name in enumerate(file_name_list):\n if (file_name.startswith('X_')):\n continue\n \n parts = file_name.split(\"-\")\n label = int(parts[0])\n if label not in self.domains:\n continue\n img_name = file_name\n\n count=self.get_sample_count(label)\n if count<self.valid_set_size:\n # create holdout set on the fly\n utils.copy_file(self.image_dir,self.valid_set_dir,img_name)\n else:\n self.dataset.append([img_name, self.attr2idx[label]])\n \n self.increment_sample_count(label)\n\n print(\"Sample count per domain: \"+str(self.sample_count)+\" (including holdout set, holdout size per domain is: \"+str(self.valid_set_size)+\")\")\n print('Finished preprocessing the dataset...')","def normalize_image(img):\n arr = np.array(img)\n new_img = Image.fromarray(normalize(arr).astype('uint8'),'L')\n return new_img","def normalize(self):\n self.image = rescale_intensity(self.image, out_range=(0, 255))","def image_preprocess(image, image_size, mean_rgb, stddev_rgb):\n input_processor = dataloader.DetectionInputProcessor(image, image_size)\n input_processor.normalize_image(mean_rgb, stddev_rgb)\n input_processor.set_scale_factors_to_output_size()\n image = input_processor.resize_and_crop_image()\n image_scale = input_processor.image_scale_to_original\n return image, image_scale","def reshape_and_normalize_image(image):\n # Reshape image to mach expected input of VGG16\n image = np.reshape(image, ((1,) + image.shape))\n # Substract the mean to match the expected input of VGG16\n image = image - CONFIG.MEANS\n \n return image","def processImage(imgs):\r\n imgs = imgs.astype(np.float32)\r\n for i, img in enumerate(imgs):\r\n m = img.mean()\r\n s = img.std()\r\n imgs[i] = (img - m) / s\r\n return imgs","def _preprocess_data(self, name, directory):\n if name.endswith('data'):\n for path in glob(str(directory / '**/*.jpg'), recursive=True):\n try:\n with Image.open(path) as img:\n if not name.startswith('feature'):\n img = img.rotate(-90, 0, 1)\n img = img.resize(self.input_shape)\n except (ValueError, OSError):\n print(\"Couldn't open {}\".format(path))\n else:\n path = Path(path)\n filename = path.name.split('img-')[1]\n target = (path.parent / filename).with_suffix('.image.png')\n img.save(target, 'PNG')\n os.remove(str(path))\n elif name.endswith('targets'):\n for path in glob(str(directory / '**/*.mat'), recursive=True):\n try:\n mat = spio.loadmat(path)['depthMap']\n img = spmisc.toimage(mat).resize(self.target_shape)\n except ValueError:\n print(\"Couldn't open {}\".format(path))\n else:\n path = Path(path)\n name = path.name[path.name.index('-') + 1:]\n target = (path.parent / name).with_suffix('.depth.png')\n img.save(target, 'PNG')\n os.remove(str(path))","def imnormalize_tensor(self, img, mean, std, to_rgb=True):\n mean = np.float32(mean.reshape(1, -1))\n stdinv = 1 / np.float32(std.reshape(1, -1))\n if to_rgb:\n img = img[:, :, [2, 1, 0]]\n img = torch.sub(img, torch.tensor(mean).cuda())\n img = torch.mul(img, torch.tensor(stdinv).cuda())\n return img","def initial_resizing(fr_raw_data_path, fr_data_path, dim=300):\n with h5py.File(fr_raw_data_path, 'r') as data:\n images = resize_array(np.asarray(data['images'].value), dim=dim)\n labels = data['labels'].value\n \n with h5py.File(fr_data_path, 'w') as f:\n f.create_dataset('images', data=images)\n\n with h5py.File(fr_raw_data_path, 'r') as data: \n f.copy(data['fri_data'], 'fri_data')\n f.copy(data['frii_data'], 'frii_data')\n f.copy(data['labels'], 'labels')","def _preprocessing(self, input_image):\n if self.resize:\n input_image = self._np_resize_image(input_image,\n self.input_size,\n dtype='int')\n image = self._np_transpose(input_image)\n image = self._np_normalize(image)\n image = self._np_flip_n_cat(image)\n return image","def run_phot_normalization(setup, **params):\n\n log = logs.start_stage_log( setup.red_dir, 'postproc_phot_norm', version=VERSION )\n\n xmatch = crossmatch.CrossMatchTable()\n xmatch.load(params['crossmatch_file'],log=log)\n\n # Identify the datasets to be used as the primary reference in each\n # filter:\n xmatch.id_primary_datasets_per_filter()\n log.info('Identified datasets to be used as the primary references in each filter: '\\\n +repr(xmatch.reference_datasets))\n\n # Add columns to the dataset Table to hold the photometric calibration\n # parameters\n ndset = len(xmatch.datasets)\n ncol = len(xmatch.datasets.colnames)\n if 'norm_a0' not in xmatch.datasets.colnames:\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_a0', index=ncol+1)\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_a1', index=ncol+2)\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_covar_0', index=ncol+3)\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_covar_1', index=ncol+4)\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_covar_2', index=ncol+5)\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_covar_3', index=ncol+6)\n log.info('Expanded xmatch.datasets table for normalization parameters')\n\n # Extract list of filters from xmatch.images['filter'] column\n filter_list = np.unique(xmatch.images['filter'].data)\n log.info('Identified list of filters to process: '+repr(filter_list))\n\n # Read data from quadrant 1\n # Reading in the timeseries data for all four quadrants is at the very\n # edge of the memory limits on the machines available, so it is preferable\n # to calibrate the quadrant's data separately. However, there are sufficient\n # stars in each quantant to be able to determine the photometric calibration\n # from a single quadrant, and apply it to the rest of the image.\n log.info('Loading the timeseries photometry from quadrant 1')\n file_path = path.join(setup.red_dir, params['field_name']+'_quad1_photometry.hdf5')\n phot_data = hd5_utils.read_phot_from_hd5_file(file_path, return_type='array')\n log.info('-> Completed photometry load')\n\n # Identify constant stars in the dataset\n constant_stars = find_constant_stars(xmatch, phot_data, log)\n star = 1\n\n # Normalize the photometry of each dataset to that of the reference\n # image in the primary reference dataset in that filter\n #for filter in filter_list:\n for filter in filter_list:\n\n # Plot an RMS diagram of the lightcurves for all stars in this filter,\n # prior to normalization, for comparison\n image_index = np.where(xmatch.images['filter'] == filter)[0]\n phot_data_filter = phot_data[:,image_index,:]\n (mag_col, mag_err_col) = field_photometry.get_field_photometry_columns('corrected')\n qc_col = 16\n\n plot_multisite_rms(params, phot_data_filter, mag_col, mag_err_col, qc_col,\n 'rms_prenorm_'+str(filter)+'.png', log)\n\n # Extract the reference image photometry for the primary-ref dataset\n # for this filter\n ref_datacode = xmatch.reference_datasets[filter]\n sitecode = get_site_code(ref_datacode)\n log.info('Reference dataset in '+filter+' is '+ref_datacode+', sitecode='+sitecode)\n\n ref_phot = np.zeros((len(xmatch.stars),2))\n ref_phot[:,0] = xmatch.stars['cal_'+filter.replace('p','')+'_mag_'+sitecode]\n ref_phot[:,1] = xmatch.stars['cal_'+filter.replace('p','')+'_magerr_'+sitecode]\n\n # Extract the lightcurves for all other datasets in this filter in turn\n dataset_index = np.where(xmatch.datasets['dataset_filter'] == filter)[0]\n\n for idset in dataset_index:\n dset_datacode = xmatch.datasets['dataset_code'][idset]\n dset_sitecode = get_site_code(dset_datacode)\n\n # If the dataset is the reference dataset, replicate the photometric\n # measurements from the corrected columns to the normalized columns,\n # since no normalization is required - this ensures the full\n # lightcurve can be accessed from the normalization columns.\n if dset_datacode == ref_datacode:\n log.info('Replicating primary reference photometry from dataset '\\\n +dset_datacode+' to the normalized photometry columns')\n image_index = np.where(xmatch.images['dataset_code'] == dset_datacode)[0]\n (mag_col, mag_err_col) = field_photometry.get_field_photometry_columns('corrected')\n (norm_mag_col, norm_mag_err_col) = field_photometry.get_field_photometry_columns('normalized')\n for i in image_index:\n phot_data[:,i,norm_mag_col] = phot_data[:,i,mag_col]\n phot_data[:,i,norm_mag_err_col] = phot_data[:,i,mag_err_col]\n\n # Normalize any dataset that isn't the same as the reference dataset\n else:\n log.info('Normalizing dataset '+dset_datacode+', sitecode='+dset_sitecode)\n image_index = np.where(xmatch.images['dataset_code'] == dset_datacode)[0]\n\n ## Dset created to hold all stars in field, not quadrant - \n # normalization is calculated from whole field.\n dset_phot = np.zeros((len(xmatch.stars),2))\n dset_phot[:,0] = xmatch.stars['cal_'+filter.replace('p','')+'_mag_'+dset_sitecode]\n dset_phot[:,1] = xmatch.stars['cal_'+filter.replace('p','')+'_magerr_'+dset_sitecode]\n\n # Calculate their weighted offset relative to the primary-ref\n # dataset for the filter\n (fit, covar_fit) = calc_phot_normalization(ref_phot, dset_phot,\n constant_stars, log,\n diagnostics=True, ref=sitecode,\n dset=dset_sitecode, f=filter)\n\n # Store the fit results for this dataset\n xmatch = store_dataset_phot_normalization(idset, xmatch, fit, covar_fit, log)\n\n # Apply the normalization calibration to the dataset's reference\n # image photometry, and store the results in the xmatch.stars table\n log.info('Applying normalization to the datasets reference image photometry')\n cal_phot = apply_phot_normalization_single_frame(fit, covar_fit, dset_phot,\n 0, 1, log,\n diagnostics=True, ref=sitecode,\n dset=dset_sitecode, f=filter)\n xmatch.stars['norm_'+filter.replace('p','')+'_mag_'+dset_sitecode] = cal_phot[:,0]\n xmatch.stars['norm_'+filter.replace('p','')+'_magerr_'+dset_sitecode] = cal_phot[:,1]\n\n # Apply the photometry calibration to the timeseries data\n # for this dataset\n (mag_col, mag_err_col) = field_photometry.get_field_photometry_columns('corrected')\n (norm_mag_col, norm_mag_err_col) = field_photometry.get_field_photometry_columns('normalized')\n phot_data = normalize_timeseries_photometry(phot_data, image_index,\n fit, covar_fit,\n mag_col, mag_err_col,\n norm_mag_col, norm_mag_err_col,\n log)\n\n # Plot a second RMS diagram of the lightcurves for all stars in this\n # filter, post normalization, for comparison\n image_index = np.where(xmatch.images['filter'] == filter)[0]\n phot_data_filter = phot_data[:,image_index,:]\n (mag_col, mag_err_col) = field_photometry.get_field_photometry_columns('normalized')\n plot_multisite_rms(params, phot_data_filter, mag_col, mag_err_col, qc_col,\n 'rms_postnorm_'+str(filter)+'.png', log)\n\n\n fig = plt.figure(3,(10,10))\n (norm_mag_col, norm_mag_err_col) = field_photometry.get_field_photometry_columns('normalized')\n idx = np.where(phot_data[star,:,norm_mag_col] > 0.0)[0]\n plt.errorbar(phot_data[star,idx,0], phot_data[star,idx,norm_mag_col],\n yerr=phot_data[star,idx,norm_mag_err_col], fmt='none', color='k')\n (xmin,xmax,ymin,ymax) = plt.axis()\n ymin = max(ymin,14.0)\n ymax = min(ymax,22.0)\n plt.axis([xmin,xmax,ymax,ymin])\n plt.xlabel('HJD')\n plt.ylabel('Mag')\n plt.savefig('Star_'+str(star)+'_lc_norm.png')\n plt.close(3)\n\n # Output updated crossmatch table\n xmatch.save(params['crossmatch_file'])\n\n # Output the photometry for quadrant 1:\n output_quadrant_photometry(params, setup, 1, phot_data, log)\n\n logs.close_log(log)\n\n status = 'OK'\n report = 'Completed successfully'\n return status, report","def norm_and_stack(images):\n imagestack = np.dstack(tuple([cv2.imread(image, cv2.IMREAD_UNCHANGED) for image in images]))\n mean = np.mean(imagestack)\n std = np.std(imagestack)\n new_im = (imagestack - mean)/std \n \n return new_im, mean, std","def normalize_all_data_in_dict(data: Data_dict_type, normalizers: Tuple[object, ...]) -> Data_dict_type:\n for key, item in data.items():\n values, sample_rate = item\n # save old shape and reshape data to supported format for normalizer\n old_shape = values.shape\n values = values.reshape((-1, values.shape[-1]))\n # normalize data\n for normalizer in normalizers:\n values = normalizer.transform(values)\n # Reshape data back to old shape\n values = values.reshape(old_shape)\n data[key] = (values, sample_rate)\n return data","def normalize(imgs, idx=[0]):\n tmp = [img for img in imgs]\n for i in idx:\n tmp[i] = cv2.normalize(imgs[i], None, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32FC1)\n return tmp","def applyMorphologicalCleaning(self, image):","def un_normalize(tensor, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]):\n mean = torch.FloatTensor(mean).view(1,3,1,1)\n std = torch.FloatTensor(std).view(1,3,1,1)\n \n image = tensor.cpu().detach()\n image = image*std+mean\n image = image.numpy()\n \n image = np.transpose(image, (0,2,3,1))\n \n #print(np.max(image))\n #print(np.min(image))\n return image","def normalize_train_data(train_data, hter=False):\n feats = train_data[:, :-1]\n labels = train_data[:, -1]\n if hter:\n labels_pw = labels\n else:\n labels_pw = labels / feats[:, 1]\n scaler = pp.StandardScaler()\n scaler.fit(feats)\n norm_feats = scaler.transform(feats)\n return np.concatenate((norm_feats, labels_pw[:, None]), axis=1), scaler","def _reshape(self, data):\n\n\t\td = np.zeros((32,32,3))\n\t\td_r = data[0:1024].reshape(32,32)\n\t\td_g = data[1024:2048].reshape(32,32)\n\t\td_b = data[2048:].reshape(32,32)\n\n\t\tfor h in range(32):\n\t\t for w in range(32):\n\t\t for c in range(3):\n\n\t\t if c == 0 : d[h,w,c] = d_r[h,w]\n\t\t elif c == 1 : d[h,w,c] = d_g[h,w]\n\t\t else : d[h,w,c] = d_b[h,w]\n\n\t\tarray = np.array(d, dtype=np.uint8)\n\t\timg = Image.fromarray(array)\n\t\ttemp = img.resize(size = (64,64))\n\t\td = image.img_to_array(temp)\n\n\t\t#plt.imshow(d)\n\t\t#plt.show()\n\t\treturn d","def preprocess(self):\n print(\"processing content images...\")\n for dir_item in self.selectedContent:\n join_path = Path(self.content_image_dir,dir_item.replace('/','_'))\n if join_path.exists():\n print(\"processing %s\"%dir_item,end='\\r')\n images = join_path.glob('*.%s'%(self.subffix))\n for item in images:\n self.content_dataset.append(item)\n else:\n print(\"%s dir does not exist!\"%dir_item,end='\\r')\n label_index = 0\n print(\"processing style images...\")\n for class_item in self.selectedStyle:\n images = Path(self.style_image_dir).glob('%s/*.%s'%(class_item, self.subffix))\n for item in images:\n self.art_dataset.append([item, label_index])\n label_index += 1\n random.seed(self.random_seed)\n random.shuffle(self.content_dataset)\n random.shuffle(self.art_dataset)\n # self.dataset = images\n print('Finished preprocessing the Art Works dataset, total image number: %d...'%len(self.art_dataset))\n print('Finished preprocessing the Content dataset, total image number: %d...'%len(self.content_dataset))","def norm_data(self):\n if (self.nrows, self.ncolumns) < self.data.shape:\n self.data = self.data[0:self.nrows, 0:self.ncolumns]\n if self.data.dtype != np.float64:\n self.data = self.data.astype(np.float64)\n self.meanval = self.data.mean()\n self.stdval = self.data.std()","def _generate_dataset(self):\n # create train images\n train_path = os.path.join(self.root_dir, \"shapes\", \"train\", \"good\")\n os.makedirs(train_path, exist_ok=True)\n for i in range(self.num_train):\n result = generate_random_anomaly_image(\n image_width=self.image_width,\n image_height=self.image_height,\n shapes=self.train_shapes,\n generate_mask=False,\n )\n image = result[\"image\"]\n imsave(os.path.join(train_path, f\"{i:03}.png\"), image, check_contrast=False)\n\n # create test images\n for test_category in self.test_shapes:\n test_path = os.path.join(self.root_dir, \"shapes\", \"test\", test_category)\n mask_path = os.path.join(self.root_dir, \"shapes\", \"ground_truth\", test_category)\n os.makedirs(test_path, exist_ok=True)\n os.makedirs(mask_path, exist_ok=True)\n # anomaly and masks. The idea is to superimpose anomalous shapes on top of correct ones\n for i in range(self.num_test):\n correct_shapes = generate_random_anomaly_image(\n image_width=self.image_width,\n image_height=self.image_height,\n shapes=self.train_shapes,\n generate_mask=False,\n )\n result = generate_random_anomaly_image(\n image_width=self.image_width,\n image_height=self.image_height,\n shapes=[test_category],\n generate_mask=True,\n )\n correct_shapes = correct_shapes[\"image\"]\n image, mask = result[\"image\"], result[\"mask\"]\n image = np.minimum(image, correct_shapes) # since 255 is white\n imsave(os.path.join(test_path, f\"{i:03}.png\"), image, check_contrast=False)\n imsave(os.path.join(mask_path, f\"{i:03}_mask.png\"), mask, check_contrast=False)\n # good test\n test_good = os.path.join(self.root_dir, \"shapes\", \"test\", \"good\")\n os.makedirs(test_good, exist_ok=True)\n for i in range(self.num_test):\n result = generate_random_anomaly_image(\n image_width=self.image_width,\n image_height=self.image_height,\n shapes=self.train_shapes,\n )\n image = result[\"image\"]\n imsave(os.path.join(test_good, f\"{i:03}.png\"), image, check_contrast=False)","def make_flat_avg(images, out):\n image = Image(avg_images(images, out))\n image.normalise()\n return out","def __normalizeData__(self,tensors = None):\n if(tensors is None):\n tensors = self.__tensors__\n new_tensors=[]\n for tensor in tensors:\n new_tensors.append( [ [1/(1+x) for x in tensor[0] ] , tensor[1],tensor[2],tensor[3] ])\n return new_tensors","def normalize(batch_img: np.ndarray) -> np.ndarray:\n batch_img = batch_img.astype('float32')\n return batch_img / 127.5 - 1","def _reshape(self, data):\n\n\t\t\td = np.zeros((32,32,3))\n\t\t\td_r = data[0:1024].reshape(32,32)\n\t\t\td_g = data[1024:2048].reshape(32,32)\n\t\t\td_b = data[2048:].reshape(32,32)\n\n\t\t\tfor h in range(32):\n\t\t\t for w in range(32):\n\t\t\t for c in range(3):\n\n\t\t\t if c == 0 : d[h,w,c] = d_r[h,w]\n\t\t\t elif c == 1 : d[h,w,c] = d_g[h,w]\n\t\t\t else : d[h,w,c] = d_b[h,w]\n\n\t\t\tarray = np.array(d, dtype=np.uint8)\n\t\t\timg = Image.fromarray(array)\n\t\t\ttemp = img.resize(size = (64,64))\n\t\t\td = image.img_to_array(temp)\n\n\t\t\t#plt.imshow(d)\n\t\t\t#plt.show()\n\t\t\treturn d","def unnormalize(self, image, transpose=False):\n return unnormalize(image, self.mean, self.std, transpose)","def scale_dataset(ds):\n for i in range(0,ds.dims):\n fmax = ds.data[0][i]\n for j in range(1,len(ds)):\n curr = ds.data[j][i]\n if curr > fmax:\n fmax = curr \n if fmax > 0:\n for j in range(0,len(ds)):\n ds.data[j][i] /= fmax","def specific_normalization(df):\n # Need to scale some vars. This is done using a StandardScaler from sklearn package\n scaler = StandardScaler()\n df['Pclass'] = df['Pclass'].astype('float64')\n df['Family'] = df['Family'].astype('float64')\n # .reshape(-1, 1) is mandatory otherwise an exception is thrown (as 'data has a single feature')\n df['Pclass'] = scaler.fit_transform(df['Pclass'].values.reshape(-1, 1))\n df['Family'] = scaler.fit_transform(df['Family'].values.reshape(-1, 1))\n\n return df","def normalize_labels(self):\n self.y_mean, self.y_std = du.get_mean_std(self.y_train)\n self.y_train = du.normalize(self.y_train, self.y_mean, self.y_std)\n if self.x_test is not None and self.y_test is not None:\n self.y_test = du.normalize(self.y_test, self.y_mean, self.y_std)","def process(self, data):\n # get truncation parameters from config or container defaults\n self._get_params(type(data))\n\n if self.weight_dataset is None:\n self.weight_dataset = [None] * len(self.dataset)\n\n for dset, wgt in zip(self.dataset, self.weight_dataset):\n old_shape = data[dset].local_shape\n val = np.ndarray.reshape(data[dset][:], data[dset][:].size)\n if wgt is None:\n if np.iscomplexobj(data[dset]):\n data[dset][:].real = bit_truncate_fixed(\n val.real, self.fixed_precision\n ).reshape(old_shape)\n data[dset][:].imag = bit_truncate_fixed(\n val.imag, self.fixed_precision\n ).reshape(old_shape)\n else:\n data[dset][:] = bit_truncate_fixed(\n val, self.fixed_precision\n ).reshape(old_shape)\n else:\n if data[dset][:].shape != data[wgt][:].shape:\n raise pipeline.PipelineRuntimeError(\n \"Dataset and weight arrays must have same shape ({} != {})\".format(\n data[dset].shape, data[wgt].shape\n )\n )\n invvar = np.ndarray.reshape(data[wgt][:], data[dset][:].size)\n if np.iscomplexobj(data[dset]):\n data[dset][:].real = bit_truncate_weights(\n val.real,\n invvar * 2.0 / self.variance_increase,\n self.fixed_precision,\n ).reshape(old_shape)\n data[dset][:].imag = bit_truncate_weights(\n val.imag,\n invvar * 2.0 / self.variance_increase,\n self.fixed_precision,\n ).reshape(old_shape)\n else:\n data[dset][:] = bit_truncate_weights(\n val, invvar / self.variance_increase, self.fixed_precision\n ).reshape(old_shape)\n\n return data","def _data_generation(self, batch_data):\n # Initialization\n batch_x = []\n batch_y = defaultdict(list)\n\n for ind, item_data in batch_data.iterrows():\n img_path = os.path.join(self.img_dir, \"images\", \"rgb\", item_data[\"name\"])\n img = cv2.imread(img_path)\n try:\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n except Exception as error:\n print(img_path)\n print(error)\n not_valid_mask = self.read_masks_borders(item_data[\"name\"])\n img[not_valid_mask] = 0\n\n # getmasks\n targets = np.zeros((img.shape[0], img.shape[1], len(self.classes)))\n for i, c in enumerate(self.classes):\n mask_path = os.path.join(self.img_dir, \"labels\", c, item_data[\"name\"])\n mask = cv2.imread(\n mask_path.replace(\".jpg\", \".png\"), cv2.IMREAD_GRAYSCALE\n )\n mask[not_valid_mask[:, :, 0]] = 0\n mask = mask > 0\n targets[:, :, i] = mask\n\n res = self.reshape_func(image=img, mask=targets)\n img, targets = res['image'], res['mask']\n if self.do_aug:\n res = self.aug(image=img, mask=targets)\n img, targets = res['image'], res['mask']\n\n for i, c in enumerate(self.classes):\n batch_y[c].append(targets[:, :, i])\n\n batch_x.append(img)\n\n batch_x = np.array(batch_x, np.float32)\n batch_y = {k: np.array(v, np.float32) for k, v in batch_y.items()}\n batch_y = {k: np.expand_dims(v, axis=-1) for k, v in batch_y.items()}\n\n return (\n imagenet_utils.preprocess_input(batch_x, \"channels_last\", mode=\"tf\"),\n batch_y\n )","def unnormalize_multivariate_data(normed_data, scaling_values):\n data = np.zeros(normed_data.shape, dtype=normed_data.dtype)\n for i in range(normed_data.shape[-1]):\n data[:, :, :, i] = normed_data[:, :, :, i] * scaling_values.loc[i, \"std\"] + scaling_values.loc[i, \"mean\"]\n return data"],"string":"[\n \"def normalize_dataset(self):\",\n \"def normalize_images(data, blend_cat, Args):\\n im = data['X_train']['blend_image']\\n std = np.std(im)\\n mean = np.mean(im)\\n data['X_train']['blend_image'] = (im - mean) / std\\n data['X_val']['blend_image'] = (data['X_val']['blend_image'] - mean) / std\\n data['X_train'] = normalize_other_inputs(data['X_train'], Args)\\n data['X_val'] = normalize_other_inputs(data['X_val'], Args)\\n for key in data['Y_train'].keys():\\n data['Y_train'][key] = (data['Y_train'][key] - mean) / std\\n data['Y_val'][key] = (data['Y_val'][key] - mean) / std\\n blend_cat['std'] = std\\n blend_cat['mean'] = mean\\n return data\",\n \"def flatten_image(data):\\n\\t# print(img.shape[0])\\n\\t# print(img.shape[1])\\n\\t# cv2.imshow('image',img)\\n\\t# gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\\n\\t# plt.imshow(gray)\\n\\t# plt.show()\\n\\t# X_normalized = preprocessing.normalize(img, norm='l2')\\n\\t\\n\\t# s = img.shape[0] * img.shape[1]\\n\\t# img_wide = img.reshape((1, s,-1))\\t\\n\\t# img_wide = np.rollaxis(X_normalized, axis=1, start=0)\\n\\t# plt.imshow(img_wide[0])\\n\\t# plt.show()\\n\\t# print(X_normalized)\\n\\tnsamples, nx, ny = data.shape\\n\\td2_train_dataset = data.reshape((nsamples,nx*ny))\\n\\treturn d2_train_dataset\",\n \"def normalize_data(img):\\n nor = np.linalg.norm(img, axis = 1)\\n nor = np.reshape(nor, (len(img), 1))\\n img = np.divide(img, nor)\\n return img\",\n \"def _normalize(images):\\n images -= images.mean(axis=0, keepdims=True)\\n images /= np.maximum(images.std(axis=0, keepdims=True), 3e-1)\",\n \"def _normalize(images):\\n images -= images.mean(axis=0, keepdims=True)\\n images /= np.maximum(images.std(axis=0, keepdims=True), 3e-1)\",\n \"def normalise(image):\",\n \"def normalize_data(data):\\n if data.element_spec[0].shape[2] == 1:\\n data = data.map(lambda x, y: (tf.image.grayscale_to_rgb(\\n tf.image.resize(x, [32, 32])), y))\\n else:\\n data = data.map(lambda x, y: (tf.image.resize(x, [32, 32]), y))\\n normalization_layer = tf.keras.layers.experimental.preprocessing.Rescaling(1. / 255)\\n normalized_ds = data.map(lambda x, y: (normalization_layer(x), y))\\n return normalized_ds\",\n \"def preprocess(imgs):\\n imgs_p = np.ndarray((len(imgs), img_rows, img_cols), dtype=np.float32)\\n for i in range(len(imgs)):\\n imgs_p[i] = imgs[i].reshape((img_rows, img_cols))/255.\\n\\n imgs_p = imgs_p[..., np.newaxis]\\n\\n # Perform data normalization\\n mean = imgs_p.mean()\\n std = imgs_p.std()\\n imgs_p -= mean\\n imgs_p /= std\\n\\n return imgs_p\",\n \"def normalize_image(self):\\n # The image normalization is identical to Cloud TPU ResNet.\\n self._image = tf.image.convert_image_dtype(self._image, dtype=tf.float32)\\n offset = tf.constant(DATASET_MEAN)\\n offset = tf.expand_dims(offset, axis=0)\\n offset = tf.expand_dims(offset, axis=0)\\n self._image -= offset\\n\\n scale = tf.constant(DATASET_VAR)\\n scale = tf.expand_dims(scale, axis=0)\\n scale = tf.expand_dims(scale, axis=0)\\n self._image /= scale\",\n \"def unnormalize(images, mean, std):\\n \\n unnorm_images = images * std + mean\\n \\n \\n return unnorm_images\",\n \"def set_normalization(self, dataloader):\\n mean = 0\\n square = 0\\n for (data_in, _) in dataloader:\\n mean += data_in.mean()\\n square += data_in.pow(2).mean()\\n\\n mean /= len(dataloader)\\n square /= len(dataloader)\\n std = np.sqrt(square - mean ** 2)\\n\\n # The input data should be roughly normally distributed after\\n # passing through net_fixed.\\n self.scale_in.bias.data.fill_(- mean / std)\\n self.scale_in.weight.data.fill_(1 / std)\",\n \"def normalize(self):\\n d = learning_utils.convert_data_to_2d(self._data)\\n d = learning_utils.normalize_2d(d)\\n self._data = learning_utils.convert_data_to_1d(d)\",\n \"def normalization(imgs):\\n\\n imgs = np.asarray(imgs).astype(np.float32)\\n imgs = np.expand_dims(imgs / 255, axis=-1)\\n return imgs\",\n \"def denormalize(img, dataset=\\\"imagenet\\\"):\\r\\n if dataset == \\\"cifar10\\\":\\r\\n c_std = [0.247, 0.243, 0.261]\\r\\n c_mean = [0.4914, 0.4822, 0.4466]\\r\\n elif dataset == \\\"imagenet\\\":\\r\\n c_std = [0.229, 0.224, 0.225]\\r\\n c_mean = [0.485, 0.456, 0.406]\\r\\n for i in [0, 1, 2]:\\r\\n img[i] = img[i] * c_std[i] + c_mean[i]\\r\\n return img\",\n \"def normalize(dataset):\\n minVals = dataset.min(axis=0)\\n maxVals = dataset.max(axis=0)\\n factors = maxVals-minVals\\n num = dataset.shape[0]\\n norm_data = (dataset - np.tile(minVals,(num,1)))/np.tile(factors,(num,1)) \\n return norm_data\",\n \"def _normalize_images(self, images: th.Tensor) -> th.Tensor:\\n output = ((images+2)/4 - self._norm_mean)/self._norm_std\\n return output\",\n \"def denormalize(img, means, stds, resize_to_original=False):\\n\\n img = np.moveaxis(img, 0, 2)\\n img = img*stds + means\\n img = np.clip(img, 0, 255).astype('uint8')\\n\\n if resize_to_original:\\n # revert def preprocess_image()\\n img = img[:,(img_w//4): (img_w - img_w//4),:]\\n img = cv2.copyMakeBorder( img, img.shape[0], 0,0,0, cv2.BORDER_CONSTANT) #, borderType)\\n img = cv2.resize(img, (img_orig_w, img_orig_h))\\n \\n return img\",\n \"def normalize_ds(dataset):\\n dataset = copy.copy(dataset)\\n\\n dim_dataset = dataset.shape\\n\\n for n_row in range(dim_dataset[0]):\\n k = dataset[n_row,:]\\n k_norm =(k - np.min(k))/(np.max(k) - np.min(k))\\n dataset[n_row,:] = k_norm\\n\\n return dataset\",\n \"def _normalize(self, dataset):\\n if self.max is None: # if we are normalizing the training set\\n self.max, self.min = dataset.max(), dataset.min() # find max, min value for each columns\\n for row in dataset.index: # for each row in dataset\\n for col in self.features: # for each feature in the instance (exclude target)\\n dataset.at[row, col] = (dataset.at[row, col] - self.min[col]) / (self.max[col] - self.min[col]) if col != \\\"Bias\\\" else 1\",\n \"def reshape_normalise(img):\\n\\t# The image shape is expected to match the input of VGG19\\n\\timg = np.resize(img, (1, CONFIG.IMAGE_HEIGHT, CONFIG.IMAGE_WIDTH, CONFIG.COLOR_CHANNELS)).astype('float32')\\n\\timg -= CONFIG.MEAN_PIXEL\\n\\treturn img\",\n \"def _normalize(\\n ds: xr.Dataset,\\n *,\\n dim: Sequence[str],\\n kind: str = ADDITIVE,\\n) -> xr.Dataset:\\n if \\\"norm\\\" in ds:\\n norm = ds.norm\\n else:\\n norm = ds.data.mean(dim=dim)\\n norm.attrs[\\\"_group_apply_reshape\\\"] = True\\n\\n return xr.Dataset(\\n dict(data=apply_correction(ds.data, invert(norm, kind), kind), norm=norm)\\n )\",\n \"def reshape_dataset(self, dataset, params):\\n assert hasattr(params, \\\"vectorize_data\\\"), (\\n \\\"Model params must set vectorize_data.\\\")\\n for key in dataset.keys():\\n if dataset[key] is None:\\n continue\\n dataset[key].images = dp.reshape_data(dataset[key].images, params.vectorize_data)[0]\\n dataset[key].shape = dataset[key].images.shape\\n return dataset\",\n \"def normalize_images(x_images, mean_value):\\n x_flat = np.zeros((x_images.shape[0], 784))\\n for k in range(0, x_images.shape[0]):\\n img = x_images[k, ...] - mean_value\\n img = cv2.normalize(img.astype('float'), None, 0.0, 1.0, cv2.NORM_MINMAX).astype(np.float32)\\n x_flat[k, ...] = np.reshape(img, [-1])\\n\\n return x_flat\",\n \"def preprocess_image(self, batched_inputs):\\n images = [x[\\\"image\\\"].float().to(self.device) for x in batched_inputs]\\n images = [self.normalizer(img) for img in images]\\n images = ImageList.from_tensors(images, self.backbone.size_divisibility)\\n return images\",\n \"def test_normalize(dummy_input):\\n # Test the 2D image: H, W, C\\n image, label = dummy_input(image_size=(512, 512, 3),\\n label_size=(512, 512, 1))\\n transform = Normalize(means=None, stds=None)\\n _image, _label = transform(image, label, normalize_tags=[True, False])\\n assert not (image == _image).all()\\n assert (label == _label).all()\\n\\n # Test the 3D image: H, W, D, C\\n image, label = dummy_input(image_size=(512, 512, 20, 3),\\n label_size=(512, 512, 20, 1))\\n transform = Normalize(means=None, stds=None)\\n _image, _label = transform(image, label, normalize_tags=[True, False])\\n assert not (image == _image).all()\\n assert (label == _label).all()\\n assert np.abs(np.mean(_image)-0) < 1e-8\\n assert np.abs(np.std(_image)-1) < 1e-8\",\n \"def normalize_data(data=None):\\n # Data pre-processing\\n n = data.shape[0]\\n for i in range(n):\\n xx = data[i,:,:]\\n xx -= np.mean(xx) # Centering in 0\\n xx /= np.linalg.norm(xx) # Normalizing to 1\\n data[i] = xx # Affect value\\n return data\",\n \"def img_normalize(image, label):\\n mean, std = ds_stats\\n image -= tf.constant(mean, shape=[1, 1, num_channels], dtype=image.dtype)\\n image /= tf.constant(std, shape=[1, 1, num_channels], dtype=image.dtype)\\n return image, label\",\n \"def normalize(self, image, transpose=False, data_type=None):\\n return normalize(image, self.mean, self.std, transpose)\",\n \"def pre_process_data(input_path: list, cuts: int, shape: int = 32, normalize: bool = True) -> list:\\n images = []\\n images_uncut = []\\n for files_path in input_path:\\n\\n files = os.listdir(files_path) # TODO paths\\n for f in files:\\n file_path = f'{files_path}/{f}'\\n im_uncut = cv2.imread(file_path)\\n im_uncut = cv2.cvtColor(im_uncut, cv2.COLOR_RGB2GRAY)\\n images_uncut.append(cv2.resize(im_uncut, (shape * cuts, shape * cuts)))\\n x = np.array(images_uncut)\\n\\n if normalize:\\n x_mean = np.mean(x, axis=(0, 1, 2))\\n x_std = np.std(x, axis=(0, 1, 2))\\n x = (x - x_mean) / (x_std + 1e-9)\\n\\n for im in x:\\n height = im.shape[0]\\n width = im.shape[1]\\n frac_h = height // cuts\\n frac_w = width // cuts\\n i = 0\\n image = []\\n for h in range(cuts):\\n for w in range(cuts):\\n crop = im[h * frac_h:(h + 1) * frac_h, w * frac_w:(w + 1) * frac_w]\\n crop_rehaped = cv2.resize(crop, (shape, shape))\\n image.append([crop_rehaped, i, number_to_angle(i, cuts), neighbours(i, cuts)])\\n i = i + 1\\n images.append(image)\\n # return np.array(images) # todo back to array\\n return images\",\n \"def normalize_data(self):\\n self.x_mean, self.x_std = du.get_mean_std(self.x_train)\\n self.x_train = du.normalize(self.x_train, self.x_mean, self.x_std)\\n if self.x_test is not None and self.y_test is not None:\\n self.x_test = du.normalize(self.x_test, self.x_mean, self.x_std)\\n self.normalized_data = True\",\n \"def normalize_images(image_sitk):\\n\\n max = 400\\n min = -1000\\n\\n image_np = sitk.GetArrayFromImage(image_sitk)\\n\\n # Normalization\\n image_np = (image_np - min)/(max - min)\\n image_np[image_np > 1] = 1\\n image_np[image_np < 0] = 0\\n\\n # Convert back to SITK\\n out_image_sitk = sitk.GetImageFromArray(image_np)\\n out_image_sitk.CopyInformation(image_sitk)\\n\\n return out_image_sitk\",\n \"def preprocess_image(self, batched_inputs):\\n images = [x.to(self.device) for x in batched_inputs]\\n norms = [self.normalizer(x) for x in images]\\n size = (norms[0].shape[1],norms[0].shape[2])\\n images = ImageList.from_tensors(norms, self.backbone.size_divisibility)\\n return images, size\",\n \"def normalize(image, label):\\n image -= settings.DATASET_MEAN\\n image /= settings.DATASET_STD\\n\\n return image, label\",\n \"def prepare(dataset):\\n dataset = dataset.reshape(dataset.shape[0], 1, 28, 28)\\n dataset = dataset.astype('float32')\\n dataset /= 255\\n return dataset\",\n \"def normalize(dataset):\\n return normalize_standard_deviation(normalize_mean(dataset))\",\n \"def run(self):\\n self.run_tasks()\\n self.images = np.array(self.images)\\n self.shapes.extend(self.images.shape[-2:])\\n\\n self.images = np.reshape(self.images, self.shapes)\",\n \"def normalize(img, mean, std, data_format='CHW'):\\n _assert_image_tensor(img, data_format)\\n\\n mean = paddle.to_tensor(mean, place=img.place)\\n std = paddle.to_tensor(std, place=img.place)\\n\\n if _is_channel_first(data_format):\\n mean = mean.reshape([-1, 1, 1])\\n std = std.reshape([-1, 1, 1])\\n\\n return (img - mean) / std\",\n \"def rescale_data(self):\\n\\n # Dividing every array of simulated data vectors by the mean of that array.\\n '''# Didnt work\\n for key in self.data.keys():\\n self.data[key] /= np.mean(self.data[key])\\n '''\\n\\n self.rescaled = True\\n\\n # Mean normalization\\n \\\"\\\"\\\" didnt work\\n for key in self.data.keys():\\n self.data[key] -= np.mean(self.data[key])\\n self.data[key] /= (np.max(self.data[key]) - np.min(self.data[key]))\\n \\\"\\\"\\\"\\n\\n # Median normalization\\n \\\"\\\"\\\" didnt work, still dividing by large number \\n for key in self.data.keys():\\n self.data[key] -= np.median(self.data[key])\\n self.data[key] /= (np.max(self.data[key]) - np.min(self.data[key]))\\n \\\"\\\"\\\"\\n\\n # Divide by median\\n \\\"\\\"\\\" didnt work\\n for key in self.data.keys():\\n self.data[key] -= np.median(self.data[key])\\n self.data[key] /= (np.median(self.data[key]))\\n \\\"\\\"\\\"\\n\\n # Take logarithm of data\\n \\\"\\\"\\\" didnt work\\n for key in self.data.keys():\\n self.data[key] = np.log10(self.data[key])\\n \\\"\\\"\\\"\\n\\n # Scale by length of vector\\n \\\"\\\"\\\"\\n for key in self.data.keys():\\n self.data[key] /= np.linalg.norm(self.Cl_noiseless)\\n \\\"\\\"\\\"\\n\\n \\n # Scale by negative of the natural logarithm \\n for key in self.data.keys():\\n self.data[key] = -1 * np.log(self.data[key]) \\n \\n \\\"\\\"\\\"\\n # Scale by subtracting the mean and dividing by std\\n std = np.nanstd(self.data['data'])\\n mean = np.nanmean(self.data['data'])\\n for key in self.data.keys():\\n # self.data[key] -= np.log(self.Cl_noiseless) # -1* # scale this same way\\n # self.data[key] -= self.Cl_noiseless # -1* # scale this same way\\n self.data[key] -= mean \\n self.data[key] /= std\\n \\\"\\\"\\\"\",\n \"def normalize(img):\\n # TODO: implement this function.\\n min_img = min([min(i) for i in img])\\n max_img = max([max(i) for i in img])\\n\\n for i in range(len(img)):\\n \\tfor j in range(len(img[0])):\\n \\t\\timg[i][j] = ((img[i][j] - min_img) / (max_img - min_img))\\n #raise NotImplementedError\\n return img\",\n \"def preprocess_image(self, batched_inputs):\\n images = [x[\\\"image\\\"].to(self.device) for x in batched_inputs]\\n images_aug = [x[\\\"image_color\\\"].to(self.device) for x in batched_inputs]\\n\\n images = [self.normalizer(x) for x in images]\\n images_aug = [self.normalizer(x) for x in images_aug]\\n\\n images = ImageList.from_tensors(images,\\n self.backbone.size_divisibility)\\n images_aug = ImageList.from_tensors(images_aug,\\n self.backbone.size_divisibility)\\n return images, images_aug\",\n \"def preprocess(img):\\n \\n scaler=StandardScaler() ## scaler object to perform preprocessing\\n img=scaler.fit_transform(img) ## zero-center and normalize\\n \\n return img\",\n \"def normalize(self):\\n self._data /= self.norm()\",\n \"def normalise(self):\\n return self / self.mean(axis=1).reshape(self.shape[0], 1)\",\n \"def unNormalizeData(normalizedData, data_mean, data_std, dimensions_to_ignore):\\n T = normalizedData.shape[0]\\n D = data_mean.shape[0]\\n\\n origData = np.zeros((T, D), dtype=np.float32)\\n dimensions_to_use = []\\n for i in range(D):\\n if i in dimensions_to_ignore:\\n continue\\n dimensions_to_use.append(i)\\n dimensions_to_use = np.array(dimensions_to_use)\\n\\n origData[:, dimensions_to_use] = normalizedData\\n\\n # potentially ineficient, but only done once per experimentdata_conversions\\n stdMat = data_std.reshape((1, D))\\n stdMat = np.repeat(stdMat, T, axis=0)\\n meanMat = data_mean.reshape((1, D))\\n meanMat = np.repeat(meanMat, T, axis=0)\\n origData = np.multiply(origData, stdMat) + meanMat\\n return origData\",\n \"def normalizeData(meanAndStd, dataset):\\n\\n for i in range(len(dataset)):\\n for j in range(len(dataset[i])-1):\\n mean = meanAndStd[j][\\\"mean\\\"]\\n std = meanAndStd[j][\\\"std\\\"]\\n dataset[i][j] = (dataset[i][j] - mean)/std\",\n \"def pre_process(self, images: Union[np.ndarray, List]) -> np.ndarray:\\n images = validate_image(images)\\n image_sizes = []\\n image_arr = []\\n for image in images:\\n image_sizes.append(image.shape)\\n image = resize(image,\\n height=self.in_h,\\n width=self.in_w)\\n image = normalize(image)\\n image_arr.append(image)\\n image_arr = np.array(image_arr)\\n return image_arr, image_sizes\",\n \"def _images_and_boxes_preprocessing(self, imgs, boxes):\\r\\n # Image [0, 255] -> [0, 1].\\r\\n imgs = imgs.float()\\r\\n imgs = imgs / 255.0\\r\\n\\r\\n height, width = imgs.shape[2], imgs.shape[3]\\r\\n # The format of boxes is [x1, y1, x2, y2]. The input boxes are in the\\r\\n # range of [0, 1].\\r\\n boxes[:, [0, 2]] *= width\\r\\n boxes[:, [1, 3]] *= height\\r\\n boxes = transform.clip_boxes_to_image(boxes, height, width)\\r\\n\\r\\n if self._split == \\\"train\\\":\\r\\n # Train split\\r\\n imgs, boxes = transform.random_short_side_scale_jitter(\\r\\n imgs,\\r\\n min_size=self._jitter_min_scale,\\r\\n max_size=self._jitter_max_scale,\\r\\n boxes=boxes,\\r\\n )\\r\\n imgs, boxes = transform.random_crop(imgs, self._crop_size, boxes=boxes)\\r\\n\\r\\n # Random flip.\\r\\n imgs, boxes = transform.horizontal_flip(0.5, imgs, boxes=boxes)\\r\\n elif self._split == \\\"val\\\":\\r\\n # Val split\\r\\n # Resize short side to crop_size. Non-local and STRG uses 256.\\r\\n imgs, boxes = transform.random_short_side_scale_jitter(\\r\\n imgs, min_size=self._crop_size, max_size=self._crop_size, boxes=boxes\\r\\n )\\r\\n\\r\\n # Apply center crop for val split\\r\\n imgs, boxes = transform.uniform_crop(\\r\\n imgs, size=self._crop_size, spatial_idx=1, boxes=boxes\\r\\n )\\r\\n\\r\\n if self._test_force_flip:\\r\\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\\r\\n elif self._split == \\\"test\\\":\\r\\n # Test split\\r\\n # Resize short side to crop_size. Non-local and STRG uses 256.\\r\\n imgs, boxes = transform.random_short_side_scale_jitter(\\r\\n imgs, min_size=self._crop_size, max_size=self._crop_size, boxes=boxes\\r\\n )\\r\\n\\r\\n if self._test_force_flip:\\r\\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\\r\\n else:\\r\\n raise NotImplementedError(\\\"{} split not supported yet!\\\".format(self._split))\\r\\n\\r\\n # Do color augmentation (after divided by 255.0).\\r\\n if self._split == \\\"train\\\" and self._use_color_augmentation:\\r\\n if not self._pca_jitter_only:\\r\\n imgs = transform.color_jitter(\\r\\n imgs, img_brightness=0.4, img_contrast=0.4, img_saturation=0.4\\r\\n )\\r\\n\\r\\n imgs = transform.lighting_jitter(\\r\\n imgs,\\r\\n alphastd=0.1,\\r\\n eigval=np.array(self._pca_eigval).astype(np.float32),\\r\\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\\r\\n )\\r\\n\\r\\n # Normalize images by mean and std.\\r\\n imgs = transform.color_normalization(\\r\\n imgs,\\r\\n np.array(self._data_mean, dtype=np.float32),\\r\\n np.array(self._data_std, dtype=np.float32),\\r\\n )\\r\\n\\r\\n if self._use_bgr:\\r\\n # Convert image format from RGB to BGR.\\r\\n # Note that Kinetics pre-training uses RGB!\\r\\n imgs = imgs[:, [2, 1, 0], ...]\\r\\n\\r\\n boxes = transform.clip_boxes_to_image(boxes, self._crop_size, self._crop_size)\\r\\n\\r\\n return imgs, boxes\",\n \"def _compute_normalization(self, normalize=True):\\n if normalize:\\n if self._img_norm is None:\\n if np.sum(self._data) == 0:\\n self._img_norm = 1\\n else:\\n self._img_norm = self._compute_raw_image_norm()\\n\\n if self._img_norm != 0.0 and np.isfinite(self._img_norm):\\n self._data /= (self._img_norm * self._normalization_correction)\\n self._normalization_status = 0\\n else:\\n self._normalization_status = 1\\n self._img_norm = 1\\n warnings.warn('Overflow encountered while computing '\\n 'normalization constant. Normalization '\\n 'constant will be set to 1.', NonNormalizable)\\n else:\\n self._normalization_status = 2\",\n \"def normalize(\\n ds: xr.Dataset,\\n *,\\n dim: str,\\n kind: str = ADDITIVE,\\n) -> xr.Dataset:\\n\\n if \\\"norm\\\" in ds:\\n norm = invert(ds.norm, kind)\\n else:\\n norm = invert(ds.data.mean(dim=dim), kind)\\n\\n return xr.Dataset(dict(data=apply_correction(ds.data, norm, kind)))\",\n \"def scale_and_normalize_images(images, means, scales, invert_channels, normalize_to_unit_scale):\\n means = torch.tensor(means, dtype=torch.float32)[None, :, None, None] # [1, 3, 1, 1]\\n scales = torch.tensor(scales, dtype=torch.float32)[None, :, None, None] # [1. 3. 1. 1]\\n if normalize_to_unit_scale:\\n images = images / 255.\\n\\n images = (images - means) / scales\\n if invert_channels:\\n return images.flip(dims=[1])\\n else:\\n return images\",\n \"def normalize(\\n self,\\n image: np.ndarray,\\n data_format: Optional[Union[str, ChannelDimension]] = None,\\n input_data_format: Optional[Union[str, ChannelDimension]] = None,\\n ) -> np.ndarray:\\n image = rescale(image=image, scale=1 / 127.5, data_format=data_format, input_data_format=input_data_format)\\n image = image - 1\\n return image\",\n \"def normalize_batch(batch, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]):\\n # normalize using imagenet mean and std\\n batch = batch.clone()\\n mean = torch.tensor(mean).view(-1, 1, 1)\\n std = torch.tensor(std).view(-1, 1, 1)\\n # if your image data is scaled to scale 0-255, uncomment the line below\\n # batch.div_(255.0)\\n return (batch - mean) / std\",\n \"def normalize_datasets(train, test):\\n columns = train.columns[:-1]\\n train[columns] = (train[columns] - train[columns].mean()) / (train[columns].max() - train[columns].min())\\n test[columns] = (test[columns] - test[columns].mean()) / (test[columns].max() - test[columns].min())\\n\\n return train, test\",\n \"def _preprocess(self, data, normalize=False) -> np.ndarray:\\n \\n preprocessor = StandardScaler() if not normalize else Normalizer()\\n\\n data = preprocessor.fit_transform(data)\\n \\n return data\",\n \"def fit(self, dataset, labels):\\n self.dataset = dataset\\n self.labels = labels\\n self.normalization_n = []\\n self.normalization_d = []\\n self.first_title = list(self.dataset.keys())[0]\\n for ind in range(len(self.dataset[self.first_title])):\\n self.normalize_features(self.dataset, ind)\",\n \"def _normalize_patches(patches):\\n patches = array_ops.concat(patches, 0)\\n mean, variance = nn.moments(patches, [1, 2, 3], keep_dims=True)\\n patches = (patches - mean) / math_ops.sqrt(variance)\\n return array_ops.reshape(patches, [array_ops.shape(patches)[0], -1])\",\n \"def normalize_data(X_genesets):\\n normalized_datasets = []\\n for Xg in X_genesets:\\n averages = np.average(Xg, axis=0)\\n Xg_centered = Xg - np.repeat(averages, Xg.shape[0], axis=0)\\n std_devs = np.sqrt(np.var(Xg_centered, axis=0))\\n Xg_normalized = np.divide(Xg, np.repeat(std_devs, Xg.shape[0], axis=0))\\n normalized_datasets.append(Xg_normalized)\\n return normalized_datasets\",\n \"def dimension_postprocess(self, chunked_data, original_data, scale=1, padding=True):\\r\\n\\r\\n assert len(original_data.shape) == 2, \\\"data dimension expected to be (xline ,samp_point)\\\"\\r\\n assert len(chunked_data.shape) == 3, \\\"Chunked data dimension expected to be (batch_size, xline, samp_point)\\\"\\r\\n\\r\\n if padding:\\r\\n if original_data.shape[0] < self.rows:\\r\\n new_images = []\\r\\n for data in chunked_data:\\r\\n new_images.append(data[0:scale * original_data.shape[0], :])\\r\\n chunked_data = np.array(new_images)\\r\\n\\r\\n if original_data.shape[1] < self.cols:\\r\\n new_images = []\\r\\n for data in chunked_data:\\r\\n new_images.append(data[:, 0:scale * original_data.shape[1]])\\r\\n chunked_data = np.array(new_images)\\r\\n\\r\\n new_shape = (\\r\\n original_data.shape[0] * scale,\\r\\n original_data.shape[1] * scale\\r\\n )\\r\\n reconstruction = np.zeros(new_shape)\\r\\n x_chunks, y_chunks = self.get_chunks(original_data)\\r\\n\\r\\n i = 0\\r\\n s = scale\\r\\n for x in x_chunks:\\r\\n for y in y_chunks:\\r\\n prior_fill = reconstruction != 0\\r\\n chunk = np.zeros(new_shape)\\r\\n chunk[x[0] * s:x[1] * s, y[0] * s:y[1] * s] += chunked_data[i]\\r\\n chunk_fill = chunk != 0\\r\\n reconstruction += chunk\\r\\n reconstruction[prior_fill & chunk_fill] = reconstruction[prior_fill & chunk_fill] / 2\\r\\n i += 1\\r\\n return reconstruction\",\n \"def normalize_data(batch_data):\\n B, N, C = batch_data.shape\\n normal_data = np.zeros((B, N, C))\\n for b in range(B):\\n pc = batch_data[b]\\n centroid = np.mean(pc, axis=0)\\n pc = pc - centroid\\n m = np.max(np.sqrt(np.sum(pc ** 2, axis=1)))\\n pc = pc / m\\n normal_data[b] = pc\\n return normal_data\",\n \"def normalize_data(self):\\n\\t\\tfull_matrix = self.balance_clases()\\n\\t\\ttexture_matrix = Normalizer().fit_transform(X=full_matrix[:,range(0,24)])\\n\\n\\t\\treturn texture_matrix\",\n \"def add_image_normalization(self):\\n self.methods.append(self._normalize_image)\\n self.args.append(None)\",\n \"def cast_and_normalise_images(images):\\n images = (tf.cast(images, tf.float32) / 255.0) - 0.5\\n return images\",\n \"def normalize_features(self, data_dict, ind):\\n pre_norm_list = []\\n for title in data_dict:\\n pre_norm_list.append(data_dict[title][ind])\\n if self.normalization_method == 'min_max':\\n mini, maxi, norm_list = normalize.min_max_normalize(pre_norm_list)\\n self.normalization_n.append(mini)\\n self.normalization_d.append(maxi - mini)\\n elif self.normalization_method == 'z_score':\\n mean, var, norm_list = normalize.z_score_normalize(pre_norm_list)\\n self.normalization_n.append(mean)\\n self.normalization_d.append(var)\\n elif self.normalization_method == 'none':\\n norm_list = pre_norm_list[:]\\n self.normalization_n.append(0)\\n self.normalization_d.append(1)\\n for i, title in enumerate(data_dict):\\n data_dict[title][ind] = norm_list[i]\",\n \"def _images_and_boxes_preprocessing(self, imgs, boxes, gt_boxes=None):\\n # Image [0, 255] -> [0, 1].\\n imgs = imgs.float()\\n imgs = imgs / 255.0\\n\\n height, width = imgs.shape[2], imgs.shape[3]\\n # The format of boxes is [x1, y1, x2, y2]. The input boxes are in the\\n # range of [0, 1].\\n # boxes[:, [0, 2]] *= width\\n # boxes[:, [1, 3]] *= height\\n boxes = transform.clip_boxes_to_image(boxes, height, width)\\n\\n if self._split == \\\"train\\\":\\n # Train split\\n imgs, boxes = transform.random_short_side_scale_jitter(\\n imgs,\\n min_size=self._jitter_min_scale,\\n max_size=self._jitter_max_scale,\\n boxes=boxes,\\n )\\n imgs, boxes = transform.random_crop(\\n imgs, self._crop_size, boxes=boxes\\n )\\n\\n # Random flip.\\n imgs, boxes = transform.horizontal_flip(0.5, imgs, boxes=boxes)\\n elif self._split == \\\"val\\\":\\n # Val split\\n # Resize short side to crop_size. Non-local and STRG uses 256.\\n imgs, boxes = transform.random_short_side_scale_jitter(\\n imgs,\\n min_size=self._crop_size,\\n max_size=self._crop_size,\\n boxes=boxes,\\n )\\n\\n # Apply center crop for val split\\n imgs, boxes = transform.uniform_crop(\\n imgs, size=self._crop_size, spatial_idx=1, boxes=boxes\\n )\\n\\n if self._test_force_flip:\\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\\n elif self._split == \\\"test\\\":\\n # Test split\\n # Resize short side to crop_size. Non-local and STRG uses 256.\\n imgs, boxes = transform.random_short_side_scale_jitter(\\n imgs,\\n min_size=self._crop_size,\\n max_size=self._crop_size,\\n boxes=boxes,\\n )\\n\\n if self._test_force_flip:\\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\\n else:\\n raise NotImplementedError(\\n \\\"{} split not supported yet!\\\".format(self._split)\\n )\\n\\n # Do color augmentation (after divided by 255.0).\\n if self._split == \\\"train\\\" and self._use_color_augmentation:\\n if not self._pca_jitter_only:\\n imgs = transform.color_jitter(\\n imgs,\\n img_brightness=0.4,\\n img_contrast=0.4,\\n img_saturation=0.4,\\n )\\n\\n imgs = transform.lighting_jitter(\\n imgs,\\n alphastd=0.1,\\n eigval=np.array(self._pca_eigval).astype(np.float32),\\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\\n )\\n\\n # Normalize images by mean and std.\\n imgs = transform.color_normalization(\\n imgs,\\n np.array(self._data_mean, dtype=np.float32),\\n np.array(self._data_std, dtype=np.float32),\\n )\\n\\n if not self._use_bgr:\\n # Convert image format from BGR to RGB.\\n # Note that Kinetics pre-training uses RGB!\\n imgs = imgs[:, [2, 1, 0], ...]\\n\\n boxes = transform.clip_boxes_to_image(\\n boxes, self._crop_size, self._crop_size\\n )\\n\\n return imgs, boxes\",\n \"def denormalize_detections(detections, resized_size, scale, pad):\\n detections[:, 0] = (detections[:, 0] * resized_size - pad[0]) * scale\\n detections[:, 1] = (detections[:, 1] * resized_size - pad[1]) * scale\\n detections[:, 2] = (detections[:, 2] * resized_size - pad[0]) * scale\\n detections[:, 3] = (detections[:, 3] * resized_size - pad[1]) * scale\\n\\n detections[:, 4::2] = (detections[:, 4::2] * resized_size - pad[1]) * scale\\n detections[:, 5::2] = (detections[:, 5::2] * resized_size - pad[0]) * scale\\n return detections\",\n \"def _postprocess(img):\\n img = _scale_to_zero_one(img)\\n img = img.reshape(1, -1) # to avoid a scikit-learn deprecation warning later\\n return img\",\n \"def preprocess_data():\\n le = preprocessing.LabelEncoder()\\n # Reshape and normalize pixel values to be between 0 and 1\\n train_images_reshaped = train_images.reshape(len(train_images), 1024, 1024, 1)/255.\\n test_images_reshaped = test_images.reshape(len(test_images), 1024, 1024, 1)/255.\\n\\n return train_images_reshaped, test_images_reshaped, le.fit_transform(train_labels), le.fit_transform(test_labels)\",\n \"def preprocess(self):\\n \\n file_name_list = os.listdir(self.image_dir)\\n random.seed(1234)\\n random.shuffle(file_name_list)\\n \\n for i,d in enumerate(self.domains):\\n self.attr2idx[d]=i \\n\\n for i, file_name in enumerate(file_name_list):\\n if (file_name.startswith('X_')):\\n continue\\n \\n parts = file_name.split(\\\"-\\\")\\n label = int(parts[0])\\n if label not in self.domains:\\n continue\\n img_name = file_name\\n\\n count=self.get_sample_count(label)\\n if count<self.valid_set_size:\\n # create holdout set on the fly\\n utils.copy_file(self.image_dir,self.valid_set_dir,img_name)\\n else:\\n self.dataset.append([img_name, self.attr2idx[label]])\\n \\n self.increment_sample_count(label)\\n\\n print(\\\"Sample count per domain: \\\"+str(self.sample_count)+\\\" (including holdout set, holdout size per domain is: \\\"+str(self.valid_set_size)+\\\")\\\")\\n print('Finished preprocessing the dataset...')\",\n \"def normalize_image(img):\\n arr = np.array(img)\\n new_img = Image.fromarray(normalize(arr).astype('uint8'),'L')\\n return new_img\",\n \"def normalize(self):\\n self.image = rescale_intensity(self.image, out_range=(0, 255))\",\n \"def image_preprocess(image, image_size, mean_rgb, stddev_rgb):\\n input_processor = dataloader.DetectionInputProcessor(image, image_size)\\n input_processor.normalize_image(mean_rgb, stddev_rgb)\\n input_processor.set_scale_factors_to_output_size()\\n image = input_processor.resize_and_crop_image()\\n image_scale = input_processor.image_scale_to_original\\n return image, image_scale\",\n \"def reshape_and_normalize_image(image):\\n # Reshape image to mach expected input of VGG16\\n image = np.reshape(image, ((1,) + image.shape))\\n # Substract the mean to match the expected input of VGG16\\n image = image - CONFIG.MEANS\\n \\n return image\",\n \"def processImage(imgs):\\r\\n imgs = imgs.astype(np.float32)\\r\\n for i, img in enumerate(imgs):\\r\\n m = img.mean()\\r\\n s = img.std()\\r\\n imgs[i] = (img - m) / s\\r\\n return imgs\",\n \"def _preprocess_data(self, name, directory):\\n if name.endswith('data'):\\n for path in glob(str(directory / '**/*.jpg'), recursive=True):\\n try:\\n with Image.open(path) as img:\\n if not name.startswith('feature'):\\n img = img.rotate(-90, 0, 1)\\n img = img.resize(self.input_shape)\\n except (ValueError, OSError):\\n print(\\\"Couldn't open {}\\\".format(path))\\n else:\\n path = Path(path)\\n filename = path.name.split('img-')[1]\\n target = (path.parent / filename).with_suffix('.image.png')\\n img.save(target, 'PNG')\\n os.remove(str(path))\\n elif name.endswith('targets'):\\n for path in glob(str(directory / '**/*.mat'), recursive=True):\\n try:\\n mat = spio.loadmat(path)['depthMap']\\n img = spmisc.toimage(mat).resize(self.target_shape)\\n except ValueError:\\n print(\\\"Couldn't open {}\\\".format(path))\\n else:\\n path = Path(path)\\n name = path.name[path.name.index('-') + 1:]\\n target = (path.parent / name).with_suffix('.depth.png')\\n img.save(target, 'PNG')\\n os.remove(str(path))\",\n \"def imnormalize_tensor(self, img, mean, std, to_rgb=True):\\n mean = np.float32(mean.reshape(1, -1))\\n stdinv = 1 / np.float32(std.reshape(1, -1))\\n if to_rgb:\\n img = img[:, :, [2, 1, 0]]\\n img = torch.sub(img, torch.tensor(mean).cuda())\\n img = torch.mul(img, torch.tensor(stdinv).cuda())\\n return img\",\n \"def initial_resizing(fr_raw_data_path, fr_data_path, dim=300):\\n with h5py.File(fr_raw_data_path, 'r') as data:\\n images = resize_array(np.asarray(data['images'].value), dim=dim)\\n labels = data['labels'].value\\n \\n with h5py.File(fr_data_path, 'w') as f:\\n f.create_dataset('images', data=images)\\n\\n with h5py.File(fr_raw_data_path, 'r') as data: \\n f.copy(data['fri_data'], 'fri_data')\\n f.copy(data['frii_data'], 'frii_data')\\n f.copy(data['labels'], 'labels')\",\n \"def _preprocessing(self, input_image):\\n if self.resize:\\n input_image = self._np_resize_image(input_image,\\n self.input_size,\\n dtype='int')\\n image = self._np_transpose(input_image)\\n image = self._np_normalize(image)\\n image = self._np_flip_n_cat(image)\\n return image\",\n \"def run_phot_normalization(setup, **params):\\n\\n log = logs.start_stage_log( setup.red_dir, 'postproc_phot_norm', version=VERSION )\\n\\n xmatch = crossmatch.CrossMatchTable()\\n xmatch.load(params['crossmatch_file'],log=log)\\n\\n # Identify the datasets to be used as the primary reference in each\\n # filter:\\n xmatch.id_primary_datasets_per_filter()\\n log.info('Identified datasets to be used as the primary references in each filter: '\\\\\\n +repr(xmatch.reference_datasets))\\n\\n # Add columns to the dataset Table to hold the photometric calibration\\n # parameters\\n ndset = len(xmatch.datasets)\\n ncol = len(xmatch.datasets.colnames)\\n if 'norm_a0' not in xmatch.datasets.colnames:\\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_a0', index=ncol+1)\\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_a1', index=ncol+2)\\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_covar_0', index=ncol+3)\\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_covar_1', index=ncol+4)\\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_covar_2', index=ncol+5)\\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_covar_3', index=ncol+6)\\n log.info('Expanded xmatch.datasets table for normalization parameters')\\n\\n # Extract list of filters from xmatch.images['filter'] column\\n filter_list = np.unique(xmatch.images['filter'].data)\\n log.info('Identified list of filters to process: '+repr(filter_list))\\n\\n # Read data from quadrant 1\\n # Reading in the timeseries data for all four quadrants is at the very\\n # edge of the memory limits on the machines available, so it is preferable\\n # to calibrate the quadrant's data separately. However, there are sufficient\\n # stars in each quantant to be able to determine the photometric calibration\\n # from a single quadrant, and apply it to the rest of the image.\\n log.info('Loading the timeseries photometry from quadrant 1')\\n file_path = path.join(setup.red_dir, params['field_name']+'_quad1_photometry.hdf5')\\n phot_data = hd5_utils.read_phot_from_hd5_file(file_path, return_type='array')\\n log.info('-> Completed photometry load')\\n\\n # Identify constant stars in the dataset\\n constant_stars = find_constant_stars(xmatch, phot_data, log)\\n star = 1\\n\\n # Normalize the photometry of each dataset to that of the reference\\n # image in the primary reference dataset in that filter\\n #for filter in filter_list:\\n for filter in filter_list:\\n\\n # Plot an RMS diagram of the lightcurves for all stars in this filter,\\n # prior to normalization, for comparison\\n image_index = np.where(xmatch.images['filter'] == filter)[0]\\n phot_data_filter = phot_data[:,image_index,:]\\n (mag_col, mag_err_col) = field_photometry.get_field_photometry_columns('corrected')\\n qc_col = 16\\n\\n plot_multisite_rms(params, phot_data_filter, mag_col, mag_err_col, qc_col,\\n 'rms_prenorm_'+str(filter)+'.png', log)\\n\\n # Extract the reference image photometry for the primary-ref dataset\\n # for this filter\\n ref_datacode = xmatch.reference_datasets[filter]\\n sitecode = get_site_code(ref_datacode)\\n log.info('Reference dataset in '+filter+' is '+ref_datacode+', sitecode='+sitecode)\\n\\n ref_phot = np.zeros((len(xmatch.stars),2))\\n ref_phot[:,0] = xmatch.stars['cal_'+filter.replace('p','')+'_mag_'+sitecode]\\n ref_phot[:,1] = xmatch.stars['cal_'+filter.replace('p','')+'_magerr_'+sitecode]\\n\\n # Extract the lightcurves for all other datasets in this filter in turn\\n dataset_index = np.where(xmatch.datasets['dataset_filter'] == filter)[0]\\n\\n for idset in dataset_index:\\n dset_datacode = xmatch.datasets['dataset_code'][idset]\\n dset_sitecode = get_site_code(dset_datacode)\\n\\n # If the dataset is the reference dataset, replicate the photometric\\n # measurements from the corrected columns to the normalized columns,\\n # since no normalization is required - this ensures the full\\n # lightcurve can be accessed from the normalization columns.\\n if dset_datacode == ref_datacode:\\n log.info('Replicating primary reference photometry from dataset '\\\\\\n +dset_datacode+' to the normalized photometry columns')\\n image_index = np.where(xmatch.images['dataset_code'] == dset_datacode)[0]\\n (mag_col, mag_err_col) = field_photometry.get_field_photometry_columns('corrected')\\n (norm_mag_col, norm_mag_err_col) = field_photometry.get_field_photometry_columns('normalized')\\n for i in image_index:\\n phot_data[:,i,norm_mag_col] = phot_data[:,i,mag_col]\\n phot_data[:,i,norm_mag_err_col] = phot_data[:,i,mag_err_col]\\n\\n # Normalize any dataset that isn't the same as the reference dataset\\n else:\\n log.info('Normalizing dataset '+dset_datacode+', sitecode='+dset_sitecode)\\n image_index = np.where(xmatch.images['dataset_code'] == dset_datacode)[0]\\n\\n ## Dset created to hold all stars in field, not quadrant - \\n # normalization is calculated from whole field.\\n dset_phot = np.zeros((len(xmatch.stars),2))\\n dset_phot[:,0] = xmatch.stars['cal_'+filter.replace('p','')+'_mag_'+dset_sitecode]\\n dset_phot[:,1] = xmatch.stars['cal_'+filter.replace('p','')+'_magerr_'+dset_sitecode]\\n\\n # Calculate their weighted offset relative to the primary-ref\\n # dataset for the filter\\n (fit, covar_fit) = calc_phot_normalization(ref_phot, dset_phot,\\n constant_stars, log,\\n diagnostics=True, ref=sitecode,\\n dset=dset_sitecode, f=filter)\\n\\n # Store the fit results for this dataset\\n xmatch = store_dataset_phot_normalization(idset, xmatch, fit, covar_fit, log)\\n\\n # Apply the normalization calibration to the dataset's reference\\n # image photometry, and store the results in the xmatch.stars table\\n log.info('Applying normalization to the datasets reference image photometry')\\n cal_phot = apply_phot_normalization_single_frame(fit, covar_fit, dset_phot,\\n 0, 1, log,\\n diagnostics=True, ref=sitecode,\\n dset=dset_sitecode, f=filter)\\n xmatch.stars['norm_'+filter.replace('p','')+'_mag_'+dset_sitecode] = cal_phot[:,0]\\n xmatch.stars['norm_'+filter.replace('p','')+'_magerr_'+dset_sitecode] = cal_phot[:,1]\\n\\n # Apply the photometry calibration to the timeseries data\\n # for this dataset\\n (mag_col, mag_err_col) = field_photometry.get_field_photometry_columns('corrected')\\n (norm_mag_col, norm_mag_err_col) = field_photometry.get_field_photometry_columns('normalized')\\n phot_data = normalize_timeseries_photometry(phot_data, image_index,\\n fit, covar_fit,\\n mag_col, mag_err_col,\\n norm_mag_col, norm_mag_err_col,\\n log)\\n\\n # Plot a second RMS diagram of the lightcurves for all stars in this\\n # filter, post normalization, for comparison\\n image_index = np.where(xmatch.images['filter'] == filter)[0]\\n phot_data_filter = phot_data[:,image_index,:]\\n (mag_col, mag_err_col) = field_photometry.get_field_photometry_columns('normalized')\\n plot_multisite_rms(params, phot_data_filter, mag_col, mag_err_col, qc_col,\\n 'rms_postnorm_'+str(filter)+'.png', log)\\n\\n\\n fig = plt.figure(3,(10,10))\\n (norm_mag_col, norm_mag_err_col) = field_photometry.get_field_photometry_columns('normalized')\\n idx = np.where(phot_data[star,:,norm_mag_col] > 0.0)[0]\\n plt.errorbar(phot_data[star,idx,0], phot_data[star,idx,norm_mag_col],\\n yerr=phot_data[star,idx,norm_mag_err_col], fmt='none', color='k')\\n (xmin,xmax,ymin,ymax) = plt.axis()\\n ymin = max(ymin,14.0)\\n ymax = min(ymax,22.0)\\n plt.axis([xmin,xmax,ymax,ymin])\\n plt.xlabel('HJD')\\n plt.ylabel('Mag')\\n plt.savefig('Star_'+str(star)+'_lc_norm.png')\\n plt.close(3)\\n\\n # Output updated crossmatch table\\n xmatch.save(params['crossmatch_file'])\\n\\n # Output the photometry for quadrant 1:\\n output_quadrant_photometry(params, setup, 1, phot_data, log)\\n\\n logs.close_log(log)\\n\\n status = 'OK'\\n report = 'Completed successfully'\\n return status, report\",\n \"def norm_and_stack(images):\\n imagestack = np.dstack(tuple([cv2.imread(image, cv2.IMREAD_UNCHANGED) for image in images]))\\n mean = np.mean(imagestack)\\n std = np.std(imagestack)\\n new_im = (imagestack - mean)/std \\n \\n return new_im, mean, std\",\n \"def normalize_all_data_in_dict(data: Data_dict_type, normalizers: Tuple[object, ...]) -> Data_dict_type:\\n for key, item in data.items():\\n values, sample_rate = item\\n # save old shape and reshape data to supported format for normalizer\\n old_shape = values.shape\\n values = values.reshape((-1, values.shape[-1]))\\n # normalize data\\n for normalizer in normalizers:\\n values = normalizer.transform(values)\\n # Reshape data back to old shape\\n values = values.reshape(old_shape)\\n data[key] = (values, sample_rate)\\n return data\",\n \"def normalize(imgs, idx=[0]):\\n tmp = [img for img in imgs]\\n for i in idx:\\n tmp[i] = cv2.normalize(imgs[i], None, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32FC1)\\n return tmp\",\n \"def applyMorphologicalCleaning(self, image):\",\n \"def un_normalize(tensor, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]):\\n mean = torch.FloatTensor(mean).view(1,3,1,1)\\n std = torch.FloatTensor(std).view(1,3,1,1)\\n \\n image = tensor.cpu().detach()\\n image = image*std+mean\\n image = image.numpy()\\n \\n image = np.transpose(image, (0,2,3,1))\\n \\n #print(np.max(image))\\n #print(np.min(image))\\n return image\",\n \"def normalize_train_data(train_data, hter=False):\\n feats = train_data[:, :-1]\\n labels = train_data[:, -1]\\n if hter:\\n labels_pw = labels\\n else:\\n labels_pw = labels / feats[:, 1]\\n scaler = pp.StandardScaler()\\n scaler.fit(feats)\\n norm_feats = scaler.transform(feats)\\n return np.concatenate((norm_feats, labels_pw[:, None]), axis=1), scaler\",\n \"def _reshape(self, data):\\n\\n\\t\\td = np.zeros((32,32,3))\\n\\t\\td_r = data[0:1024].reshape(32,32)\\n\\t\\td_g = data[1024:2048].reshape(32,32)\\n\\t\\td_b = data[2048:].reshape(32,32)\\n\\n\\t\\tfor h in range(32):\\n\\t\\t for w in range(32):\\n\\t\\t for c in range(3):\\n\\n\\t\\t if c == 0 : d[h,w,c] = d_r[h,w]\\n\\t\\t elif c == 1 : d[h,w,c] = d_g[h,w]\\n\\t\\t else : d[h,w,c] = d_b[h,w]\\n\\n\\t\\tarray = np.array(d, dtype=np.uint8)\\n\\t\\timg = Image.fromarray(array)\\n\\t\\ttemp = img.resize(size = (64,64))\\n\\t\\td = image.img_to_array(temp)\\n\\n\\t\\t#plt.imshow(d)\\n\\t\\t#plt.show()\\n\\t\\treturn d\",\n \"def preprocess(self):\\n print(\\\"processing content images...\\\")\\n for dir_item in self.selectedContent:\\n join_path = Path(self.content_image_dir,dir_item.replace('/','_'))\\n if join_path.exists():\\n print(\\\"processing %s\\\"%dir_item,end='\\\\r')\\n images = join_path.glob('*.%s'%(self.subffix))\\n for item in images:\\n self.content_dataset.append(item)\\n else:\\n print(\\\"%s dir does not exist!\\\"%dir_item,end='\\\\r')\\n label_index = 0\\n print(\\\"processing style images...\\\")\\n for class_item in self.selectedStyle:\\n images = Path(self.style_image_dir).glob('%s/*.%s'%(class_item, self.subffix))\\n for item in images:\\n self.art_dataset.append([item, label_index])\\n label_index += 1\\n random.seed(self.random_seed)\\n random.shuffle(self.content_dataset)\\n random.shuffle(self.art_dataset)\\n # self.dataset = images\\n print('Finished preprocessing the Art Works dataset, total image number: %d...'%len(self.art_dataset))\\n print('Finished preprocessing the Content dataset, total image number: %d...'%len(self.content_dataset))\",\n \"def norm_data(self):\\n if (self.nrows, self.ncolumns) < self.data.shape:\\n self.data = self.data[0:self.nrows, 0:self.ncolumns]\\n if self.data.dtype != np.float64:\\n self.data = self.data.astype(np.float64)\\n self.meanval = self.data.mean()\\n self.stdval = self.data.std()\",\n \"def _generate_dataset(self):\\n # create train images\\n train_path = os.path.join(self.root_dir, \\\"shapes\\\", \\\"train\\\", \\\"good\\\")\\n os.makedirs(train_path, exist_ok=True)\\n for i in range(self.num_train):\\n result = generate_random_anomaly_image(\\n image_width=self.image_width,\\n image_height=self.image_height,\\n shapes=self.train_shapes,\\n generate_mask=False,\\n )\\n image = result[\\\"image\\\"]\\n imsave(os.path.join(train_path, f\\\"{i:03}.png\\\"), image, check_contrast=False)\\n\\n # create test images\\n for test_category in self.test_shapes:\\n test_path = os.path.join(self.root_dir, \\\"shapes\\\", \\\"test\\\", test_category)\\n mask_path = os.path.join(self.root_dir, \\\"shapes\\\", \\\"ground_truth\\\", test_category)\\n os.makedirs(test_path, exist_ok=True)\\n os.makedirs(mask_path, exist_ok=True)\\n # anomaly and masks. The idea is to superimpose anomalous shapes on top of correct ones\\n for i in range(self.num_test):\\n correct_shapes = generate_random_anomaly_image(\\n image_width=self.image_width,\\n image_height=self.image_height,\\n shapes=self.train_shapes,\\n generate_mask=False,\\n )\\n result = generate_random_anomaly_image(\\n image_width=self.image_width,\\n image_height=self.image_height,\\n shapes=[test_category],\\n generate_mask=True,\\n )\\n correct_shapes = correct_shapes[\\\"image\\\"]\\n image, mask = result[\\\"image\\\"], result[\\\"mask\\\"]\\n image = np.minimum(image, correct_shapes) # since 255 is white\\n imsave(os.path.join(test_path, f\\\"{i:03}.png\\\"), image, check_contrast=False)\\n imsave(os.path.join(mask_path, f\\\"{i:03}_mask.png\\\"), mask, check_contrast=False)\\n # good test\\n test_good = os.path.join(self.root_dir, \\\"shapes\\\", \\\"test\\\", \\\"good\\\")\\n os.makedirs(test_good, exist_ok=True)\\n for i in range(self.num_test):\\n result = generate_random_anomaly_image(\\n image_width=self.image_width,\\n image_height=self.image_height,\\n shapes=self.train_shapes,\\n )\\n image = result[\\\"image\\\"]\\n imsave(os.path.join(test_good, f\\\"{i:03}.png\\\"), image, check_contrast=False)\",\n \"def make_flat_avg(images, out):\\n image = Image(avg_images(images, out))\\n image.normalise()\\n return out\",\n \"def __normalizeData__(self,tensors = None):\\n if(tensors is None):\\n tensors = self.__tensors__\\n new_tensors=[]\\n for tensor in tensors:\\n new_tensors.append( [ [1/(1+x) for x in tensor[0] ] , tensor[1],tensor[2],tensor[3] ])\\n return new_tensors\",\n \"def normalize(batch_img: np.ndarray) -> np.ndarray:\\n batch_img = batch_img.astype('float32')\\n return batch_img / 127.5 - 1\",\n \"def _reshape(self, data):\\n\\n\\t\\t\\td = np.zeros((32,32,3))\\n\\t\\t\\td_r = data[0:1024].reshape(32,32)\\n\\t\\t\\td_g = data[1024:2048].reshape(32,32)\\n\\t\\t\\td_b = data[2048:].reshape(32,32)\\n\\n\\t\\t\\tfor h in range(32):\\n\\t\\t\\t for w in range(32):\\n\\t\\t\\t for c in range(3):\\n\\n\\t\\t\\t if c == 0 : d[h,w,c] = d_r[h,w]\\n\\t\\t\\t elif c == 1 : d[h,w,c] = d_g[h,w]\\n\\t\\t\\t else : d[h,w,c] = d_b[h,w]\\n\\n\\t\\t\\tarray = np.array(d, dtype=np.uint8)\\n\\t\\t\\timg = Image.fromarray(array)\\n\\t\\t\\ttemp = img.resize(size = (64,64))\\n\\t\\t\\td = image.img_to_array(temp)\\n\\n\\t\\t\\t#plt.imshow(d)\\n\\t\\t\\t#plt.show()\\n\\t\\t\\treturn d\",\n \"def unnormalize(self, image, transpose=False):\\n return unnormalize(image, self.mean, self.std, transpose)\",\n \"def scale_dataset(ds):\\n for i in range(0,ds.dims):\\n fmax = ds.data[0][i]\\n for j in range(1,len(ds)):\\n curr = ds.data[j][i]\\n if curr > fmax:\\n fmax = curr \\n if fmax > 0:\\n for j in range(0,len(ds)):\\n ds.data[j][i] /= fmax\",\n \"def specific_normalization(df):\\n # Need to scale some vars. This is done using a StandardScaler from sklearn package\\n scaler = StandardScaler()\\n df['Pclass'] = df['Pclass'].astype('float64')\\n df['Family'] = df['Family'].astype('float64')\\n # .reshape(-1, 1) is mandatory otherwise an exception is thrown (as 'data has a single feature')\\n df['Pclass'] = scaler.fit_transform(df['Pclass'].values.reshape(-1, 1))\\n df['Family'] = scaler.fit_transform(df['Family'].values.reshape(-1, 1))\\n\\n return df\",\n \"def normalize_labels(self):\\n self.y_mean, self.y_std = du.get_mean_std(self.y_train)\\n self.y_train = du.normalize(self.y_train, self.y_mean, self.y_std)\\n if self.x_test is not None and self.y_test is not None:\\n self.y_test = du.normalize(self.y_test, self.y_mean, self.y_std)\",\n \"def process(self, data):\\n # get truncation parameters from config or container defaults\\n self._get_params(type(data))\\n\\n if self.weight_dataset is None:\\n self.weight_dataset = [None] * len(self.dataset)\\n\\n for dset, wgt in zip(self.dataset, self.weight_dataset):\\n old_shape = data[dset].local_shape\\n val = np.ndarray.reshape(data[dset][:], data[dset][:].size)\\n if wgt is None:\\n if np.iscomplexobj(data[dset]):\\n data[dset][:].real = bit_truncate_fixed(\\n val.real, self.fixed_precision\\n ).reshape(old_shape)\\n data[dset][:].imag = bit_truncate_fixed(\\n val.imag, self.fixed_precision\\n ).reshape(old_shape)\\n else:\\n data[dset][:] = bit_truncate_fixed(\\n val, self.fixed_precision\\n ).reshape(old_shape)\\n else:\\n if data[dset][:].shape != data[wgt][:].shape:\\n raise pipeline.PipelineRuntimeError(\\n \\\"Dataset and weight arrays must have same shape ({} != {})\\\".format(\\n data[dset].shape, data[wgt].shape\\n )\\n )\\n invvar = np.ndarray.reshape(data[wgt][:], data[dset][:].size)\\n if np.iscomplexobj(data[dset]):\\n data[dset][:].real = bit_truncate_weights(\\n val.real,\\n invvar * 2.0 / self.variance_increase,\\n self.fixed_precision,\\n ).reshape(old_shape)\\n data[dset][:].imag = bit_truncate_weights(\\n val.imag,\\n invvar * 2.0 / self.variance_increase,\\n self.fixed_precision,\\n ).reshape(old_shape)\\n else:\\n data[dset][:] = bit_truncate_weights(\\n val, invvar / self.variance_increase, self.fixed_precision\\n ).reshape(old_shape)\\n\\n return data\",\n \"def _data_generation(self, batch_data):\\n # Initialization\\n batch_x = []\\n batch_y = defaultdict(list)\\n\\n for ind, item_data in batch_data.iterrows():\\n img_path = os.path.join(self.img_dir, \\\"images\\\", \\\"rgb\\\", item_data[\\\"name\\\"])\\n img = cv2.imread(img_path)\\n try:\\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\\n except Exception as error:\\n print(img_path)\\n print(error)\\n not_valid_mask = self.read_masks_borders(item_data[\\\"name\\\"])\\n img[not_valid_mask] = 0\\n\\n # getmasks\\n targets = np.zeros((img.shape[0], img.shape[1], len(self.classes)))\\n for i, c in enumerate(self.classes):\\n mask_path = os.path.join(self.img_dir, \\\"labels\\\", c, item_data[\\\"name\\\"])\\n mask = cv2.imread(\\n mask_path.replace(\\\".jpg\\\", \\\".png\\\"), cv2.IMREAD_GRAYSCALE\\n )\\n mask[not_valid_mask[:, :, 0]] = 0\\n mask = mask > 0\\n targets[:, :, i] = mask\\n\\n res = self.reshape_func(image=img, mask=targets)\\n img, targets = res['image'], res['mask']\\n if self.do_aug:\\n res = self.aug(image=img, mask=targets)\\n img, targets = res['image'], res['mask']\\n\\n for i, c in enumerate(self.classes):\\n batch_y[c].append(targets[:, :, i])\\n\\n batch_x.append(img)\\n\\n batch_x = np.array(batch_x, np.float32)\\n batch_y = {k: np.array(v, np.float32) for k, v in batch_y.items()}\\n batch_y = {k: np.expand_dims(v, axis=-1) for k, v in batch_y.items()}\\n\\n return (\\n imagenet_utils.preprocess_input(batch_x, \\\"channels_last\\\", mode=\\\"tf\\\"),\\n batch_y\\n )\",\n \"def unnormalize_multivariate_data(normed_data, scaling_values):\\n data = np.zeros(normed_data.shape, dtype=normed_data.dtype)\\n for i in range(normed_data.shape[-1]):\\n data[:, :, :, i] = normed_data[:, :, :, i] * scaling_values.loc[i, \\\"std\\\"] + scaling_values.loc[i, \\\"mean\\\"]\\n return data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69572496","0.67912114","0.67600954","0.6746723","0.6741553","0.6741553","0.6712757","0.667788","0.66753983","0.66424495","0.6628572","0.6604109","0.657797","0.65456814","0.6539488","0.64729387","0.6469001","0.64613545","0.6418981","0.63990253","0.6396894","0.63954324","0.63640827","0.6331304","0.6283619","0.6265867","0.6249871","0.624411","0.62260234","0.6211367","0.6192262","0.61917","0.6155012","0.6153514","0.61427623","0.61223453","0.6076508","0.6069619","0.6050932","0.60416406","0.60411507","0.603168","0.6028816","0.5989901","0.59816337","0.5975304","0.59629685","0.59586686","0.5923289","0.5920414","0.59184664","0.5917082","0.59088665","0.58951575","0.58924943","0.587319","0.58715814","0.58714926","0.5856627","0.5847649","0.5844181","0.5841126","0.5828049","0.5824001","0.581776","0.5812312","0.5807249","0.5802737","0.5778224","0.5770125","0.5767544","0.5764253","0.57605","0.57120025","0.5702945","0.57022","0.5699028","0.5694016","0.56916636","0.56868047","0.56855875","0.5674896","0.56708866","0.56551486","0.565431","0.5653328","0.5650138","0.56439793","0.5637077","0.5625967","0.5621813","0.56208646","0.56174517","0.5614007","0.56125826","0.5607665","0.56040967","0.55962735","0.55935323","0.55892307"],"string":"[\n \"0.69572496\",\n \"0.67912114\",\n \"0.67600954\",\n \"0.6746723\",\n \"0.6741553\",\n \"0.6741553\",\n \"0.6712757\",\n \"0.667788\",\n \"0.66753983\",\n \"0.66424495\",\n \"0.6628572\",\n \"0.6604109\",\n \"0.657797\",\n \"0.65456814\",\n \"0.6539488\",\n \"0.64729387\",\n \"0.6469001\",\n \"0.64613545\",\n \"0.6418981\",\n \"0.63990253\",\n \"0.6396894\",\n \"0.63954324\",\n \"0.63640827\",\n \"0.6331304\",\n \"0.6283619\",\n \"0.6265867\",\n \"0.6249871\",\n \"0.624411\",\n \"0.62260234\",\n \"0.6211367\",\n \"0.6192262\",\n \"0.61917\",\n \"0.6155012\",\n \"0.6153514\",\n \"0.61427623\",\n \"0.61223453\",\n \"0.6076508\",\n \"0.6069619\",\n \"0.6050932\",\n \"0.60416406\",\n \"0.60411507\",\n \"0.603168\",\n \"0.6028816\",\n \"0.5989901\",\n \"0.59816337\",\n \"0.5975304\",\n \"0.59629685\",\n \"0.59586686\",\n \"0.5923289\",\n \"0.5920414\",\n \"0.59184664\",\n \"0.5917082\",\n \"0.59088665\",\n \"0.58951575\",\n \"0.58924943\",\n \"0.587319\",\n \"0.58715814\",\n \"0.58714926\",\n \"0.5856627\",\n \"0.5847649\",\n \"0.5844181\",\n \"0.5841126\",\n \"0.5828049\",\n \"0.5824001\",\n \"0.581776\",\n \"0.5812312\",\n \"0.5807249\",\n \"0.5802737\",\n \"0.5778224\",\n \"0.5770125\",\n \"0.5767544\",\n \"0.5764253\",\n \"0.57605\",\n \"0.57120025\",\n \"0.5702945\",\n \"0.57022\",\n \"0.5699028\",\n \"0.5694016\",\n \"0.56916636\",\n \"0.56868047\",\n \"0.56855875\",\n \"0.5674896\",\n \"0.56708866\",\n \"0.56551486\",\n \"0.565431\",\n \"0.5653328\",\n \"0.5650138\",\n \"0.56439793\",\n \"0.5637077\",\n \"0.5625967\",\n \"0.5621813\",\n \"0.56208646\",\n \"0.56174517\",\n \"0.5614007\",\n \"0.56125826\",\n \"0.5607665\",\n \"0.56040967\",\n \"0.55962735\",\n \"0.55935323\",\n \"0.55892307\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7404679"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9096,"cells":{"query":{"kind":"string","value":"Randomly chooses some data from the dataset."},"document":{"kind":"string","value":"def choice(dataset, size):\n x, y = dataset\n assert x.shape[0] == y.shape[0]\n\n num_datapoints = x.shape[0]\n mask = np.zeros(num_datapoints).astype(\"bool\")\n mask[:size] = True\n np.random.default_rng().shuffle(mask)\n return x.compress(mask, axis=0), y.compress(mask, axis=0)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getRandom(self):\n return random.choice(self.data)","def data_source():\n dataset = [0.1, 0.2, 0.3, 0.4, 0.5]\n while True:\n time.sleep(2)\n yield random.choice(dataset)","def randomRow(self):\r\n l = []\r\n for row in self.data:\r\n l.append(row)\r\n return random.choice(l)","def data_feeder_2():\n return random.sample(range(100), 10)","def Chose_rand():\r\n total_list=list(range(1,467681))\r\n select=13788\r\n random_selected= random.sample(total_list,select)\r\n return (random_selected)","def selectRandomFromList(ldata):\n\treturn ldata[randint(0, len(ldata)-1)]","def bootstrap_sample(data):\n return [random.choice(data) for _ in data]","def getRandom(self):\n \n return self.data[random.randint(0, len(self.data) - 1)]","def sample(self):\n return self.items[self.np_random.choice(len(self.items))]","def gen_data(self, amount):\n\n return random.choices(self.indices, weights=self.weights, k=amount)","def sample_train_data(dataset ,target,data_len, resp = True ):\r\n np.random.seed(222)\r\n ixes = np.random.choice(dataset.index, data_len, replace = False)\r\n print(ixes)\r\n under_df = dataset.iloc[ixes]\r\n if resp==True:\r\n under_target = target.iloc[ixes]\r\n return under_df, under_target\r\n else:\r\n return under_df","def post(self, s):\n return np.random.choice(self.sample_list)","def generate_test_set(data, pts): \n test_set = np.asarray(random.sample(data, pts))\n \n return test_set","def dataset_choice(self):\n # while running:\n\n # select the dataset file for this cycle\n dataset = self.which_dataset()\n # print('A2. dataset = ', dataset)\n\n # send to list making function\n self.data_list = self.dataparsing(dataset)\n\n # how long to read a dataset file for this cycle\n dataset_choice_dur = (random.randrange(6000, 26000) / 1000) * self.glob_speed\n if self.debug_choose:\n print(f'A4 dataset choice duration = {dataset_choice_dur} seconds')\n\n # wait for this process to timeout 6-26 seconds\n # time.sleep(dataset_choice_dur)\n for _ in range (int(dataset_choice_dur) * 100):\n if config.affect_interrupt:\n continue\n else:\n time.sleep(0.01)","def runRandom(self):\n \n # Implementing Random Selection\n\n N = self.myDS.shape[0] \n d = self.myDS.shape[1] \n self.opt_selected = []\n total_reward = 0\n for n in range(0, N):\n ad = random.randrange(d)\n self.opt_selected.append(ad)\n reward = self.myDS.values[n, ad]\n total_reward = total_reward + reward\n \n return total_reward","def sample(self):\n return gc.rand_state.choice(self.domain)","def getRandom(self):\r\n return self.data[rnd.randrange(self.len)]","def _choose_sample(self):\n\n \t #periodically generate a new reconstruction for the purposes of sampling","def __sample(self, data, los, n: Optional[int], random: bool):\n if n is None:\n n = len(data)\n else:\n n = min(len(data), n)\n # Uniform random sampling from our data array\n indices = list(range(len(data)))\n if random:\n np.random.shuffle(indices)\n indices = indices[:n]\n data = torch.Tensor(data[indices])\n los = torch.Tensor(los[indices])\n if self.device != 'cpu' and 'cuda' in self.device.type:\n data = data.cuda()\n los = los.cuda()\n return data, los","def fit(self, data):\n self.seed = random.choice(range(100))","def rand_data():\n # 100 examples, with seq_len=10, each holding 300 features\n return torch.randn((100, 10, 300))","def getRandom(self) -> int:\n return random.choice(list(self.set))","def sample_data(self):\n print(\"Start data sampling...\")\n positives, negatives = [], []\n groups = self.group_data()\n for group in groups:\n positives.extend(list(combinations(group, 2)))\n for _ in range(len(positives)):\n group1, group2 = sample(groups, 2)\n negatives.append((sample(group1, 1)[0], sample(group2, 1)[0]))\n print(f\"\\x1b[32mSuccessfully completed data sampling ({len(positives)} x 2).\\x1b[0m\")\n return [negatives, positives]","def random(self=None, sample=100, min=0, max=100):\r\n\t\treturn DataStatistics([randint(min, max) for i in range(sample)])","def rand(self):\n raise NotImplementedError","def randomize(data):\r\n permutation = np.random.permutation(data.shape[0])\r\n shuffled_data = data[permutation, :]\r\n # shuffled_y = y[permutation]\r\n return shuffled_data","def getRandom(self):\n return random.choice(self.table.keys())","def getRandom(self):\n return random.choice(self.ls)","def select_data(datadir, device):\n images, labels = dataloader.select_n_random('train', datadir, n=2)\n images, labels = images.to(device), labels.to(device)\n return images.float(), labels","def subsample(self, dataset):\n sample_idx = np.random.choice(\n dataset.shape[0], self.sample_size, replace=True)\n sample = dataset[sample_idx,...]\n return sample","def __call__(self, num_actions):\n return np.random.choice(num_actions)","def get_train_data(df):\n\n srch_order = []\n cat0 = df[df.category == 5].index\n cat1 = df[df.category == 1].index\n cat2 = df[df.category == 0].index\n amount = int(len(df) * .04)\n print(\"amount of rows selected: \", amount)\n\n cat2_selec = np.random.choice(cat2, amount, replace=False)\n\n cat012 = np.concatenate((cat0, cat1, cat2_selec))\n\n df_selection = df.loc[cat012]\n\n return df_selection","def get_data(generator, random, bench_id):\n x_train, y_train, x_test, y_test = generator(random, bench_id)\n x_train = np.c_[np.ones(len(x_train)), x_train]\n x_test = np.c_[np.ones(len(x_test)), x_test]\n return x_train, y_train, x_test, y_test","def shuffle_dataset(self):\n # TODO explain approached used for selecting training and test data\n labels = self.dataset.label.unique()\n good_jobs = self.dataset[self.dataset.label == \"Good\"]\n bad_jobs = self.dataset[self.dataset.label == \"Bad\"]\n\n # TODO n>2 probablly won't work the way it's supposed to currently\n if len(labels) == 2:\n # oversample\n resize = max(len(good_jobs.label),len(bad_jobs.label))\n # undersample\n resize = min(len(good_jobs.label), len(bad_jobs.label))\n good_jobs_re = good_jobs.sample(resize)\n bad_jobs_re = bad_jobs.sample(resize)\n dataset = pd.concat([good_jobs_re, bad_jobs_re])\n elif len(labels) == 3:\n neutral_jobs = self.dataset[self.dataset.label == \"Neutral\"]\n # oversample\n resize = max(len(good_jobs.label), len(bad_jobs.label),len(neutral_jobs.label))\n # undersample\n resize = min(len(good_jobs.label), len(bad_jobs.label),len(neutral_jobs.label))\n\n good_jobs_re = good_jobs.sample(resize, replace=True)\n bad_jobs_re = bad_jobs.sample(resize, replace=True)\n neutral_jobs_re = bad_jobs.sample(resize, replace=True)\n dataset = pd.concat([good_jobs_re, bad_jobs_re,neutral_jobs_re])\n elif len(labels) == 4:\n neutral_jobs = self.dataset[self.dataset.label == \"Neutral\"]\n ideal_jobs = self.dataset[self.dataset.label == \"Ideal\"]\n\n # middle of the road approach\n resize = int(mean([len(good_jobs.label), len(bad_jobs.label),len(neutral_jobs.label),len(ideal_jobs.label)]))\n good_jobs_re = good_jobs.sample(resize, replace=True)\n bad_jobs_re = bad_jobs.sample(resize, replace=True)\n neutral_jobs_re = bad_jobs.sample(resize, replace=True)\n ideal_jobs_re = ideal_jobs.sample(resize,replace=True)\n dataset = pd.concat([good_jobs_re, bad_jobs_re,neutral_jobs_re,ideal_jobs_re])\n\n train,test = train_test_split(dataset,test_size=0.25,stratify = dataset.label,shuffle=True)\n #test = self.dataset[~self.dataset.isin(train)].dropna()\n #test = self.dataset[(~dataset.label.isin(self.dataset.label))&(~dataset.description.isin(self.dataset.description))]\n #0tr_hashes = [hash(tuple(d)) for d in train.description]\n #ytest = [val for iter,val in self.dataset.iterrows() if hash(tuple(val.description)) not in tr_hashes]\n\n self.y_train,self.y_test = train.label.values,test.label.values\n self.X_train,self.X_test = train.description.values,test.description.values","def _get_dataset_node(self, nodes):\n if not nodes:\n raise WNoNodesFound()\n return random.choice(nodes)","def selectRandomFromDict(ddata):\n\tdkeys = list(ddata.keys())\n\tdk = selectRandomFromList(dkeys)\n\tel = (dk, ddata[dk])\n\treturn el","def __call__(self):\n return random.choice(self.fakers)","def select_n_random(data, labels, n=100):\n assert len(data) == len(labels)\n\n # TODO: sort this out for 3D data\n # p1 = torch.randperm(len(data))\n # sample_labels = labels[p1][:n]\n # sample_data = data[p1][:n]\n return data[:n], labels[:n]","def random_sample(self, n):\n indices = random.sample(xrange(np.shape(self.data)[0]), n)\n table = DataTable(self.data[indices], self.dims, self.legends, self.tags.copy())\n return table","def touching_choice(self,p):\n choose = random.sample(part,2)\n\n return choose","def totem_random():\n random_head()\n random_head()\n random_head()","def split_data(data, prob):\n results = [], []\n for row in data:\n results[0 if random.random() < prob else 1].append(row)\n return results","def sample(data, k):\n\n # create random number generator\n r = Random()\n r.seed()\n\n # load all n items into dictionary\n n = len(data)\n data_dict = {i: data[i] for i in range(n)}\n samples = []\n\n for i in range(k):\n # select random item\n rand_i = r.randrange(0, n - 1) if n > 1 else 0 # randrange fails if start==stop\n samples.append(data_dict[rand_i])\n\n # replace selected item with last item and decrement number of items\n # to prevent duplicates\n data_dict[rand_i] = data_dict[n - 1]\n n -= 1\n\n return samples","def _select(self):\n sel = []\n\n # choose randomly while favouring fit individuals\n lp = len(self.population) // 2\n for _ in range(lp):\n idx1 = idx2 = int(math.sqrt(random.randrange(lp**2+1)))\n while idx1 == idx2:\n idx2 = int(math.sqrt(random.randrange(lp**2+1)))\n\n p1, p2 = self.population[idx1], self.population[idx2]\n sel.append((p1, p2))\n\n return sel","def load_data_set(file):\n df = pd.read_csv(file)\n msk = np.random.rand(len(df)) < 0.8\n return df[msk], df[~msk]","def draw_bs_sample(data):\n return rg.choice(data, size=len(data))","def getRandom(self) -> int:\n # print(self.ind)\n return choice(self.items)","def randomLeggings():\n return random.choice(LEGGINGS)","def draw_bs_sample(data):\n return np.random.choice(data, size=len(data))","def getRandom(self) -> int:\n return random.choice(list(self.d.keys()))","def split_data(data, prob):\n\tresults = [], []\n\tfor row in data:\n\t\tresults[0 if random.random() < prob else 1].append(row)\n\treturn results","def split_data(data, prob):\n\tresults = [], []\n\tfor row in data:\n\t\tresults[0 if random.random() < prob else 1].append(row)\n\treturn results","def getRandom(self) -> int:\n return choice(self.arr)","def getRandom(self) -> int:\n return choice(self.arr)","def getRandom(self) -> int:\n return choice(self.arr)","def some_simple_data(length=1000000):\n data = list(range(length))\n random.shuffle(data)\n return data","def random_pick(id_list):\n return random.choice(id_list)","def random(self, af=False):\n rank = randrange(self.order())\n return self.coset_unrank(rank, af)","def sample(self):\n # return [v.sample() for v in self.variables]\n return self.domain[gc.rand_state.choice(len(self.domain))]","def rand(self):\n raise NotImplementedError(\"Not implemented yet.\")","def sample_personas(self):\n persona = self.personas_list\n n = constants.CURATED_PERSONA_CHOICES\n logging.info(\n f'Randomly choosing {n} personas from {len(persona)} available ones.'\n )\n if self.persona_replacement:\n return random.sample(persona, k=n)\n else:\n return [persona.pop() for _ in range(n)]","def sample(self, seed=None):\n raise NotImplementedError()","def getRandom(self) -> int:\n return choice(self.array)","def _get_random_bandit(self)-> Bandit:\n return np.random.choice(self.bandits)","def touching_choice(self,p):\n\n part = ['head', 'foot1', 'foot2', 'foot3', 'foot4', 'back', 'stomach', 'tail']\n if len(self.select[p]) == 0:\n return random.sample(part,2)\n elif len(self.select[p]) == 1:\n part.remove(self.select[p][0])\n c = random.sample(part,1)\n return [self.select[p][0], c[0]]\n else:\n return random.sample(self.select[p],2)","def randomSubData(self, number): \n if number < 0 or number > self.__numExamples: \n raise ValueError(\"Random subset size must be between 0 and \" + str(self.__numExamples))\n \n self.__exampleIndices = array(sample(list(range(0, self.__numExamples)), number))","def generate_data(data, model, samples, targeted=True, target_num=9, start=0, inception=False, seed=3, handpick=False ):\n random.seed(seed)\n inputs = []\n targets = []\n labels = []\n true_ids = []\n sample_set = []\n\n data_d = data.test_data\n labels_d = data.test_labels\n\n if handpick:\n if inception:\n deck = list(range(0, 1500))\n else:\n deck = list(range(0, 10000))\n random.shuffle(deck)\n print('Handpicking')\n\n while (len(sample_set) < samples):\n rand_int = deck.pop()\n pred = model.model.predict(data_d[rand_int:rand_int + 1])\n\n if inception:\n pred = np.reshape(pred, (labels_d[0:1].shape))\n\n if (np.argmax(pred, 1) == np.argmax(labels_d[rand_int:rand_int + 1], 1)):\n sample_set.append(rand_int)\n print('Handpicked')\n else:\n sample_set = random.sample(range(0, 10000), samples)\n\n for i in sample_set:\n if targeted:\n if inception:\n seq = random.sample(range(1, 1001), target_num)\n else:\n seq = range(labels_d.shape[1])\n\n for j in seq:\n if (j == np.argmax(labels_d[start + i])) and (inception == False):\n continue\n inputs.append(data_d[start + i])\n targets.append(np.eye(labels_d.shape[1])[j])\n labels.append(labels_d[start + i])\n true_ids.append(start + i)\n else:\n inputs.append(data_d[start + i])\n targets.append(labels_d[start + i])\n labels.append(labels_d[start + i])\n true_ids.append(start + i)\n\n inputs = np.array(inputs)\n targets = np.array(targets)\n labels = np.array(labels)\n true_ids = np.array(true_ids)\n return inputs, targets, labels, true_ids","def pick(self, mess, args):\n return random.choice(args)","def random_item(self):\n if self.sample_negative_items_empirically:\n # just pick something someone rated!\n # TODO: choose a user randomly\n u = self.uniform_user()\n i = random.choice(self.data[u].indices)\n else:\n i = random.randint(0, self.num_items - 1)\n return i","def _random_subset(seq,m):\n targets=random.sample(seq,m)\n return targets","def randomHelmet():\n return random.choice(HELMETS)","def default_selection(random, population, args):\r\n return population","def getRandom(self) -> int:\n # 此处可以优化\n datas = list(self.data.keys())\n pos = self.rand.randint(0, len(datas) - 1)\n val = datas[pos]\n return val","def random_item(self):\n if self.sample_negative_items_empirically:\n # just pick something someone rated!\n u = self.uniform_user()\n i = random.choice(self.data[u].indices)\n else:\n i = random.randint(0,self.num_items-1)\n return i","def random_item(self):\n if self.sample_negative_items_empirically:\n # just pick something someone rated!\n u = self.uniform_user()\n i = random.choice(self.dataModel.getItemIDsFromUid(u))\n else:\n i = random.randint(0,self.num_items-1)\n return i","def shuffle_data(data):\n idx = np.arange(len(data))\n np.random.shuffle(idx)\n return data[idx, ...]","def get_Sample(self, values, probabilities):\r\n return choices(values,probabilities)\r\n # return np.random.choice(values,p=probabilities)\r","def data(i):\n m = i*100\n return [random.randint(0, m) for j in range(i)]","def computer_random():\r\n ci = random.sample(range(1,43),5)\r\n return ci","def getRandom(self) -> int:\n return random.choice(self.store_list)","def test_0():\n sync.gen_multi_fake_data()#default is only one randomly selected data set\n sync.main(testing=True)","def rs():\n return random.choice([-1,1])","def rs():\n return random.choice([-1,1])","def getRandom(self) -> int:\n return random.choice(self.arr)","def getRandom(self):\n return self.nums[random.randint(0, len(self.nums) - 1)]\n\n # Your RandomizedSet object will be instantiated and called as such:\n # obj = RandomizedSet()\n # param_1 = obj.insert(val)\n # param_2 = obj.remove(val)\n # param_3 = obj.getRandom()","def spinit(list):\n return (random.choice(list))","def getRandom(self) -> int:\n if self.data:\n return self.data[random.randrange(len(self.data))]\n else:\n return None","def computer_generate(self):\n return choice[random.randrange(3)]","def getRandom(self) -> int:\n return random.choice(self.array)","def __randomize_data(self):\n times = map(lambda (t, _): t, self.data)\n coords = map(lambda (_, c): c, self.data)\n return zip(times, map(DataGen.__randomize_coord, coords))","def updateCalculatedDataModelRandomly(self):\n model = self._calculatedDataModel.asDataModel()\n for column_index in range(1, model.columnCount()):\n for row_index in range(model.rowCount()):\n index = model.index(row_index, column_index)\n value = random.randrange(100)\n role = Qt.DisplayRole\n model.setData(index, value, role)","def test_get_random_data_basic(self):\n cdata = random_data(num_features=2,\n num_samples=4,\n labels=None)\n self.assertEqual(cdata.num_features, 2)\n self.assertEqual(cdata.num_samples, 4)","def random_choice(var_name):\r\n return random.choice(var_name)","def sample(self):\n sampleIndices = self.random_state.choice(len(self.X), int(len(self.X)*self.sample_ratio), replace=False)\n\n return self.X[sampleIndices]\n pass","def sample_data(_,\n val,\n sampling_strategy=spec.SamplingStrategy.UNDERSAMPLE,\n side=0):\n\n if sampling_strategy == spec.SamplingStrategy.UNDERSAMPLE:\n random_sample_data = random.sample(val, side)\n elif sampling_strategy == spec.SamplingStrategy.OVERSAMPLE:\n random_sample_data = random.choices(val, k=side)\n else:\n raise ValueError(\"Invalid value for sampling_strategy variable!\")\n\n for item in random_sample_data:\n yield item","def option():\n\toption = df[\"option\"]\n\tprint(\"You can \" + option.sample())","def randomize_soy(soy_data):\n\n print('[ INFO ]: Randomizing soy data...')\n\n np.random.seed(4)\n soy_data['rand'] = np.random.rand(len(soy_data))\n soy_data = soy_data.sort_values(by=['rand']).reset_index()\n soy_data = soy_data.drop(['rand'], axis=1)\n\n return soy_data","def sample_random_architecture(self, dataset_api=None):\n channels = np.random.choice(self.channel_candidates, size=len(self.channels)).tolist()\n self.set_channels(channels)","def _sample_mini_dataset(dataset, num_classes, num_shots):\n shuffled = list(dataset)\n random.shuffle(shuffled)\n for class_idx, class_obj in enumerate(shuffled[:num_classes]):\n for sample in class_obj.sample(num_shots):\n yield (sample, class_idx)","def pick_one(self):\n index = 0\n r = random.random()\n while r >= 0:\n r = r - self.normalised_fitness[index]\n index += 1\n index -= 1\n return self.population[index]"],"string":"[\n \"def getRandom(self):\\n return random.choice(self.data)\",\n \"def data_source():\\n dataset = [0.1, 0.2, 0.3, 0.4, 0.5]\\n while True:\\n time.sleep(2)\\n yield random.choice(dataset)\",\n \"def randomRow(self):\\r\\n l = []\\r\\n for row in self.data:\\r\\n l.append(row)\\r\\n return random.choice(l)\",\n \"def data_feeder_2():\\n return random.sample(range(100), 10)\",\n \"def Chose_rand():\\r\\n total_list=list(range(1,467681))\\r\\n select=13788\\r\\n random_selected= random.sample(total_list,select)\\r\\n return (random_selected)\",\n \"def selectRandomFromList(ldata):\\n\\treturn ldata[randint(0, len(ldata)-1)]\",\n \"def bootstrap_sample(data):\\n return [random.choice(data) for _ in data]\",\n \"def getRandom(self):\\n \\n return self.data[random.randint(0, len(self.data) - 1)]\",\n \"def sample(self):\\n return self.items[self.np_random.choice(len(self.items))]\",\n \"def gen_data(self, amount):\\n\\n return random.choices(self.indices, weights=self.weights, k=amount)\",\n \"def sample_train_data(dataset ,target,data_len, resp = True ):\\r\\n np.random.seed(222)\\r\\n ixes = np.random.choice(dataset.index, data_len, replace = False)\\r\\n print(ixes)\\r\\n under_df = dataset.iloc[ixes]\\r\\n if resp==True:\\r\\n under_target = target.iloc[ixes]\\r\\n return under_df, under_target\\r\\n else:\\r\\n return under_df\",\n \"def post(self, s):\\n return np.random.choice(self.sample_list)\",\n \"def generate_test_set(data, pts): \\n test_set = np.asarray(random.sample(data, pts))\\n \\n return test_set\",\n \"def dataset_choice(self):\\n # while running:\\n\\n # select the dataset file for this cycle\\n dataset = self.which_dataset()\\n # print('A2. dataset = ', dataset)\\n\\n # send to list making function\\n self.data_list = self.dataparsing(dataset)\\n\\n # how long to read a dataset file for this cycle\\n dataset_choice_dur = (random.randrange(6000, 26000) / 1000) * self.glob_speed\\n if self.debug_choose:\\n print(f'A4 dataset choice duration = {dataset_choice_dur} seconds')\\n\\n # wait for this process to timeout 6-26 seconds\\n # time.sleep(dataset_choice_dur)\\n for _ in range (int(dataset_choice_dur) * 100):\\n if config.affect_interrupt:\\n continue\\n else:\\n time.sleep(0.01)\",\n \"def runRandom(self):\\n \\n # Implementing Random Selection\\n\\n N = self.myDS.shape[0] \\n d = self.myDS.shape[1] \\n self.opt_selected = []\\n total_reward = 0\\n for n in range(0, N):\\n ad = random.randrange(d)\\n self.opt_selected.append(ad)\\n reward = self.myDS.values[n, ad]\\n total_reward = total_reward + reward\\n \\n return total_reward\",\n \"def sample(self):\\n return gc.rand_state.choice(self.domain)\",\n \"def getRandom(self):\\r\\n return self.data[rnd.randrange(self.len)]\",\n \"def _choose_sample(self):\\n\\n \\t #periodically generate a new reconstruction for the purposes of sampling\",\n \"def __sample(self, data, los, n: Optional[int], random: bool):\\n if n is None:\\n n = len(data)\\n else:\\n n = min(len(data), n)\\n # Uniform random sampling from our data array\\n indices = list(range(len(data)))\\n if random:\\n np.random.shuffle(indices)\\n indices = indices[:n]\\n data = torch.Tensor(data[indices])\\n los = torch.Tensor(los[indices])\\n if self.device != 'cpu' and 'cuda' in self.device.type:\\n data = data.cuda()\\n los = los.cuda()\\n return data, los\",\n \"def fit(self, data):\\n self.seed = random.choice(range(100))\",\n \"def rand_data():\\n # 100 examples, with seq_len=10, each holding 300 features\\n return torch.randn((100, 10, 300))\",\n \"def getRandom(self) -> int:\\n return random.choice(list(self.set))\",\n \"def sample_data(self):\\n print(\\\"Start data sampling...\\\")\\n positives, negatives = [], []\\n groups = self.group_data()\\n for group in groups:\\n positives.extend(list(combinations(group, 2)))\\n for _ in range(len(positives)):\\n group1, group2 = sample(groups, 2)\\n negatives.append((sample(group1, 1)[0], sample(group2, 1)[0]))\\n print(f\\\"\\\\x1b[32mSuccessfully completed data sampling ({len(positives)} x 2).\\\\x1b[0m\\\")\\n return [negatives, positives]\",\n \"def random(self=None, sample=100, min=0, max=100):\\r\\n\\t\\treturn DataStatistics([randint(min, max) for i in range(sample)])\",\n \"def rand(self):\\n raise NotImplementedError\",\n \"def randomize(data):\\r\\n permutation = np.random.permutation(data.shape[0])\\r\\n shuffled_data = data[permutation, :]\\r\\n # shuffled_y = y[permutation]\\r\\n return shuffled_data\",\n \"def getRandom(self):\\n return random.choice(self.table.keys())\",\n \"def getRandom(self):\\n return random.choice(self.ls)\",\n \"def select_data(datadir, device):\\n images, labels = dataloader.select_n_random('train', datadir, n=2)\\n images, labels = images.to(device), labels.to(device)\\n return images.float(), labels\",\n \"def subsample(self, dataset):\\n sample_idx = np.random.choice(\\n dataset.shape[0], self.sample_size, replace=True)\\n sample = dataset[sample_idx,...]\\n return sample\",\n \"def __call__(self, num_actions):\\n return np.random.choice(num_actions)\",\n \"def get_train_data(df):\\n\\n srch_order = []\\n cat0 = df[df.category == 5].index\\n cat1 = df[df.category == 1].index\\n cat2 = df[df.category == 0].index\\n amount = int(len(df) * .04)\\n print(\\\"amount of rows selected: \\\", amount)\\n\\n cat2_selec = np.random.choice(cat2, amount, replace=False)\\n\\n cat012 = np.concatenate((cat0, cat1, cat2_selec))\\n\\n df_selection = df.loc[cat012]\\n\\n return df_selection\",\n \"def get_data(generator, random, bench_id):\\n x_train, y_train, x_test, y_test = generator(random, bench_id)\\n x_train = np.c_[np.ones(len(x_train)), x_train]\\n x_test = np.c_[np.ones(len(x_test)), x_test]\\n return x_train, y_train, x_test, y_test\",\n \"def shuffle_dataset(self):\\n # TODO explain approached used for selecting training and test data\\n labels = self.dataset.label.unique()\\n good_jobs = self.dataset[self.dataset.label == \\\"Good\\\"]\\n bad_jobs = self.dataset[self.dataset.label == \\\"Bad\\\"]\\n\\n # TODO n>2 probablly won't work the way it's supposed to currently\\n if len(labels) == 2:\\n # oversample\\n resize = max(len(good_jobs.label),len(bad_jobs.label))\\n # undersample\\n resize = min(len(good_jobs.label), len(bad_jobs.label))\\n good_jobs_re = good_jobs.sample(resize)\\n bad_jobs_re = bad_jobs.sample(resize)\\n dataset = pd.concat([good_jobs_re, bad_jobs_re])\\n elif len(labels) == 3:\\n neutral_jobs = self.dataset[self.dataset.label == \\\"Neutral\\\"]\\n # oversample\\n resize = max(len(good_jobs.label), len(bad_jobs.label),len(neutral_jobs.label))\\n # undersample\\n resize = min(len(good_jobs.label), len(bad_jobs.label),len(neutral_jobs.label))\\n\\n good_jobs_re = good_jobs.sample(resize, replace=True)\\n bad_jobs_re = bad_jobs.sample(resize, replace=True)\\n neutral_jobs_re = bad_jobs.sample(resize, replace=True)\\n dataset = pd.concat([good_jobs_re, bad_jobs_re,neutral_jobs_re])\\n elif len(labels) == 4:\\n neutral_jobs = self.dataset[self.dataset.label == \\\"Neutral\\\"]\\n ideal_jobs = self.dataset[self.dataset.label == \\\"Ideal\\\"]\\n\\n # middle of the road approach\\n resize = int(mean([len(good_jobs.label), len(bad_jobs.label),len(neutral_jobs.label),len(ideal_jobs.label)]))\\n good_jobs_re = good_jobs.sample(resize, replace=True)\\n bad_jobs_re = bad_jobs.sample(resize, replace=True)\\n neutral_jobs_re = bad_jobs.sample(resize, replace=True)\\n ideal_jobs_re = ideal_jobs.sample(resize,replace=True)\\n dataset = pd.concat([good_jobs_re, bad_jobs_re,neutral_jobs_re,ideal_jobs_re])\\n\\n train,test = train_test_split(dataset,test_size=0.25,stratify = dataset.label,shuffle=True)\\n #test = self.dataset[~self.dataset.isin(train)].dropna()\\n #test = self.dataset[(~dataset.label.isin(self.dataset.label))&(~dataset.description.isin(self.dataset.description))]\\n #0tr_hashes = [hash(tuple(d)) for d in train.description]\\n #ytest = [val for iter,val in self.dataset.iterrows() if hash(tuple(val.description)) not in tr_hashes]\\n\\n self.y_train,self.y_test = train.label.values,test.label.values\\n self.X_train,self.X_test = train.description.values,test.description.values\",\n \"def _get_dataset_node(self, nodes):\\n if not nodes:\\n raise WNoNodesFound()\\n return random.choice(nodes)\",\n \"def selectRandomFromDict(ddata):\\n\\tdkeys = list(ddata.keys())\\n\\tdk = selectRandomFromList(dkeys)\\n\\tel = (dk, ddata[dk])\\n\\treturn el\",\n \"def __call__(self):\\n return random.choice(self.fakers)\",\n \"def select_n_random(data, labels, n=100):\\n assert len(data) == len(labels)\\n\\n # TODO: sort this out for 3D data\\n # p1 = torch.randperm(len(data))\\n # sample_labels = labels[p1][:n]\\n # sample_data = data[p1][:n]\\n return data[:n], labels[:n]\",\n \"def random_sample(self, n):\\n indices = random.sample(xrange(np.shape(self.data)[0]), n)\\n table = DataTable(self.data[indices], self.dims, self.legends, self.tags.copy())\\n return table\",\n \"def touching_choice(self,p):\\n choose = random.sample(part,2)\\n\\n return choose\",\n \"def totem_random():\\n random_head()\\n random_head()\\n random_head()\",\n \"def split_data(data, prob):\\n results = [], []\\n for row in data:\\n results[0 if random.random() < prob else 1].append(row)\\n return results\",\n \"def sample(data, k):\\n\\n # create random number generator\\n r = Random()\\n r.seed()\\n\\n # load all n items into dictionary\\n n = len(data)\\n data_dict = {i: data[i] for i in range(n)}\\n samples = []\\n\\n for i in range(k):\\n # select random item\\n rand_i = r.randrange(0, n - 1) if n > 1 else 0 # randrange fails if start==stop\\n samples.append(data_dict[rand_i])\\n\\n # replace selected item with last item and decrement number of items\\n # to prevent duplicates\\n data_dict[rand_i] = data_dict[n - 1]\\n n -= 1\\n\\n return samples\",\n \"def _select(self):\\n sel = []\\n\\n # choose randomly while favouring fit individuals\\n lp = len(self.population) // 2\\n for _ in range(lp):\\n idx1 = idx2 = int(math.sqrt(random.randrange(lp**2+1)))\\n while idx1 == idx2:\\n idx2 = int(math.sqrt(random.randrange(lp**2+1)))\\n\\n p1, p2 = self.population[idx1], self.population[idx2]\\n sel.append((p1, p2))\\n\\n return sel\",\n \"def load_data_set(file):\\n df = pd.read_csv(file)\\n msk = np.random.rand(len(df)) < 0.8\\n return df[msk], df[~msk]\",\n \"def draw_bs_sample(data):\\n return rg.choice(data, size=len(data))\",\n \"def getRandom(self) -> int:\\n # print(self.ind)\\n return choice(self.items)\",\n \"def randomLeggings():\\n return random.choice(LEGGINGS)\",\n \"def draw_bs_sample(data):\\n return np.random.choice(data, size=len(data))\",\n \"def getRandom(self) -> int:\\n return random.choice(list(self.d.keys()))\",\n \"def split_data(data, prob):\\n\\tresults = [], []\\n\\tfor row in data:\\n\\t\\tresults[0 if random.random() < prob else 1].append(row)\\n\\treturn results\",\n \"def split_data(data, prob):\\n\\tresults = [], []\\n\\tfor row in data:\\n\\t\\tresults[0 if random.random() < prob else 1].append(row)\\n\\treturn results\",\n \"def getRandom(self) -> int:\\n return choice(self.arr)\",\n \"def getRandom(self) -> int:\\n return choice(self.arr)\",\n \"def getRandom(self) -> int:\\n return choice(self.arr)\",\n \"def some_simple_data(length=1000000):\\n data = list(range(length))\\n random.shuffle(data)\\n return data\",\n \"def random_pick(id_list):\\n return random.choice(id_list)\",\n \"def random(self, af=False):\\n rank = randrange(self.order())\\n return self.coset_unrank(rank, af)\",\n \"def sample(self):\\n # return [v.sample() for v in self.variables]\\n return self.domain[gc.rand_state.choice(len(self.domain))]\",\n \"def rand(self):\\n raise NotImplementedError(\\\"Not implemented yet.\\\")\",\n \"def sample_personas(self):\\n persona = self.personas_list\\n n = constants.CURATED_PERSONA_CHOICES\\n logging.info(\\n f'Randomly choosing {n} personas from {len(persona)} available ones.'\\n )\\n if self.persona_replacement:\\n return random.sample(persona, k=n)\\n else:\\n return [persona.pop() for _ in range(n)]\",\n \"def sample(self, seed=None):\\n raise NotImplementedError()\",\n \"def getRandom(self) -> int:\\n return choice(self.array)\",\n \"def _get_random_bandit(self)-> Bandit:\\n return np.random.choice(self.bandits)\",\n \"def touching_choice(self,p):\\n\\n part = ['head', 'foot1', 'foot2', 'foot3', 'foot4', 'back', 'stomach', 'tail']\\n if len(self.select[p]) == 0:\\n return random.sample(part,2)\\n elif len(self.select[p]) == 1:\\n part.remove(self.select[p][0])\\n c = random.sample(part,1)\\n return [self.select[p][0], c[0]]\\n else:\\n return random.sample(self.select[p],2)\",\n \"def randomSubData(self, number): \\n if number < 0 or number > self.__numExamples: \\n raise ValueError(\\\"Random subset size must be between 0 and \\\" + str(self.__numExamples))\\n \\n self.__exampleIndices = array(sample(list(range(0, self.__numExamples)), number))\",\n \"def generate_data(data, model, samples, targeted=True, target_num=9, start=0, inception=False, seed=3, handpick=False ):\\n random.seed(seed)\\n inputs = []\\n targets = []\\n labels = []\\n true_ids = []\\n sample_set = []\\n\\n data_d = data.test_data\\n labels_d = data.test_labels\\n\\n if handpick:\\n if inception:\\n deck = list(range(0, 1500))\\n else:\\n deck = list(range(0, 10000))\\n random.shuffle(deck)\\n print('Handpicking')\\n\\n while (len(sample_set) < samples):\\n rand_int = deck.pop()\\n pred = model.model.predict(data_d[rand_int:rand_int + 1])\\n\\n if inception:\\n pred = np.reshape(pred, (labels_d[0:1].shape))\\n\\n if (np.argmax(pred, 1) == np.argmax(labels_d[rand_int:rand_int + 1], 1)):\\n sample_set.append(rand_int)\\n print('Handpicked')\\n else:\\n sample_set = random.sample(range(0, 10000), samples)\\n\\n for i in sample_set:\\n if targeted:\\n if inception:\\n seq = random.sample(range(1, 1001), target_num)\\n else:\\n seq = range(labels_d.shape[1])\\n\\n for j in seq:\\n if (j == np.argmax(labels_d[start + i])) and (inception == False):\\n continue\\n inputs.append(data_d[start + i])\\n targets.append(np.eye(labels_d.shape[1])[j])\\n labels.append(labels_d[start + i])\\n true_ids.append(start + i)\\n else:\\n inputs.append(data_d[start + i])\\n targets.append(labels_d[start + i])\\n labels.append(labels_d[start + i])\\n true_ids.append(start + i)\\n\\n inputs = np.array(inputs)\\n targets = np.array(targets)\\n labels = np.array(labels)\\n true_ids = np.array(true_ids)\\n return inputs, targets, labels, true_ids\",\n \"def pick(self, mess, args):\\n return random.choice(args)\",\n \"def random_item(self):\\n if self.sample_negative_items_empirically:\\n # just pick something someone rated!\\n # TODO: choose a user randomly\\n u = self.uniform_user()\\n i = random.choice(self.data[u].indices)\\n else:\\n i = random.randint(0, self.num_items - 1)\\n return i\",\n \"def _random_subset(seq,m):\\n targets=random.sample(seq,m)\\n return targets\",\n \"def randomHelmet():\\n return random.choice(HELMETS)\",\n \"def default_selection(random, population, args):\\r\\n return population\",\n \"def getRandom(self) -> int:\\n # 此处可以优化\\n datas = list(self.data.keys())\\n pos = self.rand.randint(0, len(datas) - 1)\\n val = datas[pos]\\n return val\",\n \"def random_item(self):\\n if self.sample_negative_items_empirically:\\n # just pick something someone rated!\\n u = self.uniform_user()\\n i = random.choice(self.data[u].indices)\\n else:\\n i = random.randint(0,self.num_items-1)\\n return i\",\n \"def random_item(self):\\n if self.sample_negative_items_empirically:\\n # just pick something someone rated!\\n u = self.uniform_user()\\n i = random.choice(self.dataModel.getItemIDsFromUid(u))\\n else:\\n i = random.randint(0,self.num_items-1)\\n return i\",\n \"def shuffle_data(data):\\n idx = np.arange(len(data))\\n np.random.shuffle(idx)\\n return data[idx, ...]\",\n \"def get_Sample(self, values, probabilities):\\r\\n return choices(values,probabilities)\\r\\n # return np.random.choice(values,p=probabilities)\\r\",\n \"def data(i):\\n m = i*100\\n return [random.randint(0, m) for j in range(i)]\",\n \"def computer_random():\\r\\n ci = random.sample(range(1,43),5)\\r\\n return ci\",\n \"def getRandom(self) -> int:\\n return random.choice(self.store_list)\",\n \"def test_0():\\n sync.gen_multi_fake_data()#default is only one randomly selected data set\\n sync.main(testing=True)\",\n \"def rs():\\n return random.choice([-1,1])\",\n \"def rs():\\n return random.choice([-1,1])\",\n \"def getRandom(self) -> int:\\n return random.choice(self.arr)\",\n \"def getRandom(self):\\n return self.nums[random.randint(0, len(self.nums) - 1)]\\n\\n # Your RandomizedSet object will be instantiated and called as such:\\n # obj = RandomizedSet()\\n # param_1 = obj.insert(val)\\n # param_2 = obj.remove(val)\\n # param_3 = obj.getRandom()\",\n \"def spinit(list):\\n return (random.choice(list))\",\n \"def getRandom(self) -> int:\\n if self.data:\\n return self.data[random.randrange(len(self.data))]\\n else:\\n return None\",\n \"def computer_generate(self):\\n return choice[random.randrange(3)]\",\n \"def getRandom(self) -> int:\\n return random.choice(self.array)\",\n \"def __randomize_data(self):\\n times = map(lambda (t, _): t, self.data)\\n coords = map(lambda (_, c): c, self.data)\\n return zip(times, map(DataGen.__randomize_coord, coords))\",\n \"def updateCalculatedDataModelRandomly(self):\\n model = self._calculatedDataModel.asDataModel()\\n for column_index in range(1, model.columnCount()):\\n for row_index in range(model.rowCount()):\\n index = model.index(row_index, column_index)\\n value = random.randrange(100)\\n role = Qt.DisplayRole\\n model.setData(index, value, role)\",\n \"def test_get_random_data_basic(self):\\n cdata = random_data(num_features=2,\\n num_samples=4,\\n labels=None)\\n self.assertEqual(cdata.num_features, 2)\\n self.assertEqual(cdata.num_samples, 4)\",\n \"def random_choice(var_name):\\r\\n return random.choice(var_name)\",\n \"def sample(self):\\n sampleIndices = self.random_state.choice(len(self.X), int(len(self.X)*self.sample_ratio), replace=False)\\n\\n return self.X[sampleIndices]\\n pass\",\n \"def sample_data(_,\\n val,\\n sampling_strategy=spec.SamplingStrategy.UNDERSAMPLE,\\n side=0):\\n\\n if sampling_strategy == spec.SamplingStrategy.UNDERSAMPLE:\\n random_sample_data = random.sample(val, side)\\n elif sampling_strategy == spec.SamplingStrategy.OVERSAMPLE:\\n random_sample_data = random.choices(val, k=side)\\n else:\\n raise ValueError(\\\"Invalid value for sampling_strategy variable!\\\")\\n\\n for item in random_sample_data:\\n yield item\",\n \"def option():\\n\\toption = df[\\\"option\\\"]\\n\\tprint(\\\"You can \\\" + option.sample())\",\n \"def randomize_soy(soy_data):\\n\\n print('[ INFO ]: Randomizing soy data...')\\n\\n np.random.seed(4)\\n soy_data['rand'] = np.random.rand(len(soy_data))\\n soy_data = soy_data.sort_values(by=['rand']).reset_index()\\n soy_data = soy_data.drop(['rand'], axis=1)\\n\\n return soy_data\",\n \"def sample_random_architecture(self, dataset_api=None):\\n channels = np.random.choice(self.channel_candidates, size=len(self.channels)).tolist()\\n self.set_channels(channels)\",\n \"def _sample_mini_dataset(dataset, num_classes, num_shots):\\n shuffled = list(dataset)\\n random.shuffle(shuffled)\\n for class_idx, class_obj in enumerate(shuffled[:num_classes]):\\n for sample in class_obj.sample(num_shots):\\n yield (sample, class_idx)\",\n \"def pick_one(self):\\n index = 0\\n r = random.random()\\n while r >= 0:\\n r = r - self.normalised_fitness[index]\\n index += 1\\n index -= 1\\n return self.population[index]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73725927","0.7179318","0.70049816","0.6915993","0.68809456","0.6742614","0.66800225","0.6568194","0.65536875","0.65441173","0.6533348","0.652268","0.65050435","0.64911234","0.6435912","0.64282745","0.6402564","0.6368382","0.63608557","0.6303325","0.6302801","0.62998617","0.62880856","0.6250222","0.624839","0.6236472","0.62349945","0.6219508","0.62085956","0.61937565","0.6189435","0.61823297","0.6164767","0.6163929","0.615513","0.61492723","0.61439776","0.6142531","0.6142359","0.6141548","0.61395425","0.61358666","0.61274236","0.6121665","0.61080223","0.61031336","0.60894674","0.60773265","0.6075797","0.60743284","0.6069612","0.6069612","0.60661846","0.60661846","0.60661846","0.6051552","0.60457903","0.6045385","0.6040441","0.6039906","0.6039411","0.6036293","0.60356456","0.6024902","0.60219955","0.60195047","0.60191023","0.60077506","0.6006434","0.6002031","0.59929985","0.59919196","0.59907913","0.5990753","0.5982621","0.59733653","0.597189","0.596615","0.59644896","0.59607834","0.59520566","0.5949235","0.5949235","0.5946438","0.59451884","0.5939399","0.5936389","0.59337395","0.5932308","0.59195036","0.59171987","0.591682","0.59149593","0.5910622","0.5910393","0.5905551","0.5898947","0.58953226","0.58860445","0.58803594"],"string":"[\n \"0.73725927\",\n \"0.7179318\",\n \"0.70049816\",\n \"0.6915993\",\n \"0.68809456\",\n \"0.6742614\",\n \"0.66800225\",\n \"0.6568194\",\n \"0.65536875\",\n \"0.65441173\",\n \"0.6533348\",\n \"0.652268\",\n \"0.65050435\",\n \"0.64911234\",\n \"0.6435912\",\n \"0.64282745\",\n \"0.6402564\",\n \"0.6368382\",\n \"0.63608557\",\n \"0.6303325\",\n \"0.6302801\",\n \"0.62998617\",\n \"0.62880856\",\n \"0.6250222\",\n \"0.624839\",\n \"0.6236472\",\n \"0.62349945\",\n \"0.6219508\",\n \"0.62085956\",\n \"0.61937565\",\n \"0.6189435\",\n \"0.61823297\",\n \"0.6164767\",\n \"0.6163929\",\n \"0.615513\",\n \"0.61492723\",\n \"0.61439776\",\n \"0.6142531\",\n \"0.6142359\",\n \"0.6141548\",\n \"0.61395425\",\n \"0.61358666\",\n \"0.61274236\",\n \"0.6121665\",\n \"0.61080223\",\n \"0.61031336\",\n \"0.60894674\",\n \"0.60773265\",\n \"0.6075797\",\n \"0.60743284\",\n \"0.6069612\",\n \"0.6069612\",\n \"0.60661846\",\n \"0.60661846\",\n \"0.60661846\",\n \"0.6051552\",\n \"0.60457903\",\n \"0.6045385\",\n \"0.6040441\",\n \"0.6039906\",\n \"0.6039411\",\n \"0.6036293\",\n \"0.60356456\",\n \"0.6024902\",\n \"0.60219955\",\n \"0.60195047\",\n \"0.60191023\",\n \"0.60077506\",\n \"0.6006434\",\n \"0.6002031\",\n \"0.59929985\",\n \"0.59919196\",\n \"0.59907913\",\n \"0.5990753\",\n \"0.5982621\",\n \"0.59733653\",\n \"0.597189\",\n \"0.596615\",\n \"0.59644896\",\n \"0.59607834\",\n \"0.59520566\",\n \"0.5949235\",\n \"0.5949235\",\n \"0.5946438\",\n \"0.59451884\",\n \"0.5939399\",\n \"0.5936389\",\n \"0.59337395\",\n \"0.5932308\",\n \"0.59195036\",\n \"0.59171987\",\n \"0.591682\",\n \"0.59149593\",\n \"0.5910622\",\n \"0.5910393\",\n \"0.5905551\",\n \"0.5898947\",\n \"0.58953226\",\n \"0.58860445\",\n \"0.58803594\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65095335"},"document_rank":{"kind":"string","value":"12"}}},{"rowIdx":9097,"cells":{"query":{"kind":"string","value":"__init__(self, filename) Create a configparser object and store config values in class variables for later retrieval"},"document":{"kind":"string","value":"def __init__(self, filename=\"config.ini\"):\n if not os.path.isfile(filename):\n self.set_default_config(filename)\n\n self.config = configparser.ConfigParser()\n self.config.read(filename)\n\n self.filename = filename\n self.database_name = self.config.get('config',\n 'database_name',\n fallback='manga.db')\n self.volume_limit = self.config.getint('config',\n 'volume_limit',\n fallback=128)\n self.series_per_page = self.config.getint('config',\n 'series_per_page',\n fallback=0)\n self.compact_list = self.config.getboolean('config',\n 'compact_list',\n fallback=False)\n self.show_empty_series = self.config.getboolean('config',\n 'show_empty_series',\n fallback=False)\n self.default_to_gui = self.config.getboolean('config',\n 'default_to_gui',\n fallback=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 __init__(self, filename, dirname='~'):\n self.config = configparser.ConfigParser()\n\n expanded_dirname = os.path.expanduser(dirname)\n self.configuration_filename = os.path.join(expanded_dirname, filename)\n if os.path.isfile(self.configuration_filename):\n self.config.read(self.configuration_filename)","def __init__(self):\n\n self.path = os.path.dirname(os.path.realpath(__file__)) + '/config.ini'\n self.config = configparser.ConfigParser()\n self.config.read(self.path)","def __init__(self):\n self.filename = pathlib.Path(__file__).parent.absolute().__str__() + '/../../data/config.ini'\n self.data = ConfigParser()\n self.data.read(self.filename)","def __init__(self, ini_file):\n self.config = configparser.ConfigParser()\n self.config.read(ini_file)","def __init__(self, ini_file):\n self.config = configparser.ConfigParser()\n self.config.read(ini_file)\n #print(self.config)","def __init__(self, config_file):\n \n self.log = logging.getLogger(__name__)\n\n self.parser = ConfigParser.ConfigParser()\n if os.path.exists(config_file) and os.path.isfile(config_file):\n self.parser.read(config_file)\n self.log.debug(\"opened configuration '%s'\" % config_file)\n else:\n raise ConfigError(\"Config file missing\", \"File '%s' doesn't exist.\" % (config_file))\n\n self.config_file = config_file\n self.check_config()","def __init__(self, config_file_name=\"config.json\"):\n self.config_file_name = config_file_name\n self._config = self._open_config_file()","def __init__(self, filepath=None):\n self.path = self.__default_filepath if filepath is None else filepath\n self.parser = configparser.ConfigParser()\n if self.__section_default not in self.parser.sections():\n self.parser.add_section(self.__section_default)\n\n self.parser.read(self.path)","def __init__(self, filename):\n self.cfg_spec = ConfigObj(config_spec_text.splitlines(), list_values=False)\n self.cfg_filename = filename\n valid = Validator()\n if not os.path.exists(self.cfg_filename):\n #no configuration file found\n logger.info(\"File %s not found, so creating one from you from defaults\" % self.cfg_filename)\n cfg = ConfigObj(configspec=self.cfg_spec, stringify=True, list_values=True)\n cfg.filename = self.cfg_filename\n test = cfg.validate(valid, copy=True)\n cfg.write()\n self.cfg = ConfigObj(self.cfg_filename, configspec=self.cfg_spec)\n rtn = self.cfg.validate(valid, preserve_errors=True)\n if type(rtn) == types.BooleanType and rtn:\n logger.info(\"Config file validated\")\n self.tested = True\n else:\n self.tested = False\n res = flatten_errors(self.cfg, rtn)\n self.errortxt = ''\n for row in res:\n self.errortxt += 'In Section %s, key %s has error: %s' % (row[0], row[1], row[2])\n logger.error(self.errortxt)","def __init__(self, path_to_config_file):\n self.file_path = path_to_config_file","def __init__(self, file_handle):\n config = ConfigParser.ConfigParser()\n config.readfp(file_handle)\n self.database_address_ = config.get('General', 'database_address')\n self.google_developer_key_ = config.get('Google', 'developer_key')\n self.google_cref_ = config.get('Google', 'cref')","def __init__(self, __file):\n\n\t\tself.fileName = __file\n\t\tif (os.path.isfile(self.fileName)):\n\t\t\t# config.ini found, load it\n\t\t\tself.config.read(self.fileName)\n\t\t\tself.default = False\n\t\telse:\n\t\t\t# config.ini not found, generate a default one\n\t\t\tself.generateDefaultConfig()\n\t\t\tself.default = True","def __init__(self, config_file=None):\n self.file = config_file\n self.parser = SafeConfigParser()\n if isinstance(self.file, (str, list)):\n self.parser.read(self.file)\n else: # assume file object was given instead\n self.parser.read_file(self.file)\n self._flask_cache = None\n self._assets_cache = None\n self._gridrealm_cache = None","def __init__(self, config_file=None):\n\t\tself.options = {}\n\n\t\tif config_file:\n\t\t\tself.set_file(config_file)","def __init__(self, config_file = 'config.yaml'):\n\n self.name = ''\n self.img_dir = ''\n self.out_dir = ''\n self.cam_file = ''\n self.options_file = ''\n self.output_xml_file = ''\n\n # If there is an options file, it will overwrite the defaults \n if config_file is not None:\n self.load(config_file)","def __init__(self, config_file, verbose):\r\n self.loadConfig(config_file)\r\n self.verbose = verbose","def __init__(self, filename=None):\n if filename:\n if not os.path.exists(filename):\n raise Exception(\"No configuration found at %s\" % filename)\n super(Configuration, self).__init__(filename)","def __init__(self, config_file):\n with open(config_file, 'r') as file:\n self.config = json.load(file)\n self.set_config(self.config)","def __init__(self):\n # Read configuration into dictionary\n self.directories = general.config_directories()\n self.config = general.read_yaml_files(self.directories)","def __init__(self, file):\n self.file = file\n self.config = self.__analyze_config()","def __init__(self, config_file):\n Config = ConfigParser.ConfigParser()\n Config.read(config_file)\n \n self.port_id = Config.get(\"SerialPortSection\", \"ComPort\")\n self.baud_rate = Config.get(\"SerialPortSection\", \"BaudRate\")\n self. timeout = Config.get(\"SerialPortSection\", \"TimeOut\")\n self.config_file = config_file","def __init__(self):\n ConfigParser.RawConfigParser.OPTCRE = re.compile(r'(?P<option>[^=\\s][^=]*)\\s*(?P<vi>[=])\\s*(?P<value>.*)$')\n self.CONFIG = ConfigParser.ConfigParser()\n self.CONFIG.read(os.path.join(os.path.dirname(__file__)))\n self.IPS = []","def __init__(self):\n\t\t\n\t\tsettings = configparser.SafeConfigParser(allow_no_value=True)\n\t\tlist=settings.read('data/settings.cfg')\n\t\tif not 'data/settings.cfg' in list:\n\t\t\tprint('no configuration file present.. making one')\n\t\t\tself.makeConfigFile(settings)\n\t\t\tshare = ['']\n\t\t\tself.nodes = []\n\t\telse:\n\t\t\tshare, nodes = self.openConfig(settings)\n\t\t\tself.nodes = nodes\n\t\t\n\t\t\n\t\tself.files = self.loadFiles(share)\t\t\n\t\tself.share = share\n\t\tself.kill= False\n\t\tself.downloads = {}\n\t\tself.currentVersion = (0,2,1)\n\t\tself.totalDownloads = 0\n\t\tself.current = 0\n\t\tself.config = settings","def __init__(self, filename=None):\r\n self._specs = self._load_spec(filename)\r\n self._properties = {}\r\n self._names = []\r\n self._defaults = {}","def __init__(self, config_file: str = \"config.json\"):\n path_to_config = (Path(sys.modules[self.__module__].__file__).parent\n / config_file)\n with open(path_to_config, \"r\") as f:\n self.options = json.load(f)","def __init__(self, filepath):\n try:\n config_file_r = open(filepath)\n self.sim_parametres = yaml.load(config_file_r, Loader=yaml.FullLoader)\n except:\n raise Exception(\"Le fichier de configuration n'a pas été atteint ou n'a pas pu être lu. Veuillez vérifier \"\n \"qu'il n'y ait aucune erreur de syntaxe.\")","def __init__(self, config_file_name=\"config.json\"):\n with open(config_file_name, \"r\") as config:\n f = dict(json.load(config))\n for key, value in f.items():\n setattr(self, key, value)","def __init__(self, filename):\n if filename is None:\n self.config = toml.load('configs/default.conf')\n return\n self.config = toml.load(filename)\n self.config['directory'] = {}\n self.config['directory']['root'] = os.path.dirname(\n os.path.realpath(__file__))\n self.config['directory']['datasets'] = os.path.join(\n self.config['directory']['root'], 'datasets')","def __init__(self):\n cfg = ConfigParser.ConfigParser()\n\n if sys.executable == sys.argv[0]: # Windows binary\n self.VISIONEGG_SYSTEM_DIR = os.curdir\n self.VISIONEGG_USER_DIR = os.curdir\n else:\n # non-standard VisionEgg installations\n try:\n self.VISIONEGG_SYSTEM_DIR = os.environ['VISIONEGG_SYSTEM_DIR']\n except KeyError:\n self.VISIONEGG_SYSTEM_DIR = os.path.split(__file__)[0]\n user_dir = os.path.expanduser(\"~\")\n self.VISIONEGG_USER_DIR = os.path.join(user_dir,\"VisionEgg\")\n\n # See if there's an environment variable for the config file\n if 'VISIONEGG_CONFIG_FILE' in os.environ.keys():\n configFile = os.environ['VISIONEGG_CONFIG_FILE']\n else:\n # Is there one in VISIONEGG_USER_DIR?\n configFile = os.path.join(self.VISIONEGG_USER_DIR,\"VisionEgg.cfg\")\n if not os.path.isfile(configFile):\n configFile = os.path.join(self.VISIONEGG_SYSTEM_DIR,\"VisionEgg.cfg\")\n if not os.path.isfile(configFile):\n configFile = None # No file, use defaults specified in environment variables then here\n\n if configFile:\n cfg.read(configFile)\n else:\n # pretend we have a config file\n cfg.add_section('General')\n for key in defaults.keys():\n cfg.set('General',key,str(defaults[key]))\n if sys.platform == 'darwin':\n cfg.add_section('darwin')\n for key in extra_darwin_defaults.keys():\n cfg.set('darwin',key,str(extra_darwin_defaults[key]))\n\n # Do the general stuff first\n # Set the default values\n for name in defaults.keys():\n if name in os.environ.keys():\n value = os.environ[name]\n else:\n value = defaults[name]\n if isinstance(defaults[name], int):\n\t\tif value == 'False':\n\t\t value = 0\n\t\telif value == 'True':\n\t\t value = 1\n setattr(self,name,int(value))\n elif isinstance(defaults[name], float):\n setattr(self,name,float(value))\n else:\n setattr(self,name,value)\n\n # Get the values from the configFile\n general_options = cfg.options('General')\n\n self._delayed_configuration_log_warnings = [] # chick and egg problem\n # set defaults from config file\n for option in general_options:\n name = option.upper()\n if name not in defaults.keys():\n self._delayed_configuration_log_warnings.append(\n \"While reading %s: The variable \\\"%s\\\" is not (anymore) a Vision Egg variable.\"%(os.path.abspath(configFile),option))\n continue\n value = cfg.get('General',option)\n if name in os.environ.keys():\n value = os.environ[name]\n if isinstance(defaults[name], int):\n\t\tif value == 'False':\n\t\t value = 0\n\t\telif value == 'True':\n\t\t value = 1\n setattr(self,name,int(value))\n elif isinstance(defaults[name], float):\n setattr(self,name,float(value))\n else:\n setattr(self,name,value)\n\n # Do platform specific stuff\n # Set the default values\n platform_name = sys.platform\n extra_name = \"extra_%s_defaults\"%(platform_name,)\n if extra_name in globals().keys():\n extra_defaults = globals()[extra_name]\n for name in extra_defaults.keys():\n setattr(self,name,extra_defaults[name])\n\n # Get the values from the configFile\n platform_options = cfg.options(platform_name)\n for option in platform_options:\n name = option.upper()\n if name not in extra_defaults.keys():\n raise KeyError(\"No Vision Egg configuration variable \\\"%s\\\"\"%option)\n value = cfg.get(platform_name,option)\n if name in os.environ.keys():\n value = os.environ[name]\n if isinstance(extra_defaults[name], int):\n\t\t if value == 'False':\n\t\t value = 0\n \t\t elif value == 'True':\n\t\t value = 1\n setattr(self,name,int(value))\n elif isinstance(extra_defaults[name], float):\n setattr(self,name,float(value))\n else:\n setattr(self,name,value)\n\n if(configFile):\n self.VISIONEGG_CONFIG_FILE = os.path.abspath(configFile)\n else:\n self.VISIONEGG_CONFIG_FILE = None","def __init__(self, settings):\n self._read_config(settings)","def __init__(self, conf_file_location: str, template_dir: str, target_dir: str, hard_reset: bool):\n self.config: Config = yaml_loader.load(conf_file_location, Config)\n self.massage_config_file()\n self.config_dict: Dict = as_dict(self.config)\n self.template_dir = template_dir\n self.target_dir = target_dir\n self.hard_reset = hard_reset","def __init__(self, config_file='/etc/sfa/ldap_config.py'):\n\n try:\n execfile(config_file, self.__dict__)\n\n self.config_file = config_file\n # path to configuration data\n self.config_path = os.path.dirname(config_file)\n except IOError:\n raise IOError, \"Could not find or load the configuration file: %s\" \\\n % config_file","def __init__(self, default_cfg='default.ini', argv=None):\n\n # Read the default settings\n self.config = configparser.ConfigParser()\n self.config.read(default_cfg)\n # Check for a command line config argument\n if argv is not None and '--config_fn' in argv:\n # Get the config filename\n config_fn = argv[argv.index('--config_fn') + 1]\n argv.remove('--config_fn')\n argv.remove(config_fn)\n # Read the new config file\n new_cfg = configparser.ConfigParser()\n new_cfg.read(config_fn)\n # Overwrite the default values\n self._overwrite_with_config(new_cfg)\n if argv is not None:\n self._parse_arguments(argv)\n self._update()","def __init__(self, rootdir, filename, clean=False):\n self._autoconfig_filename = rootdir + filename\n self._rootdir = rootdir\n self._metadata = {}\n self._nodes = {}\n self._vpp_devices_node = {}\n self._hugepage_config = \"\"\n self._clean = clean\n self._loadconfig()\n self._sockfilename = \"\"","def __init__(self, file):\n self.__config = file\n with open(self.__config) as json_file:\n data = json.load(json_file)\n self.__data = data","def __init__(self, name, defaults = {} ):\n self.defaults = defaults\n self.filename = os.path.expanduser(name)+\".ini\"\n self.conf = {}\n self.reset()\n if os.path.exists(self.filename):\n self.load()","def __init__(self, paths=('',), global_paths=()):\n config = RawConfigParser()\n\n def _search(paths, filename):\n for path in paths:\n path = os.path.join(path, filename)\n if os.path.exists(path):\n self.paths.append(path)\n try:\n config.read(path)\n except ConfigParser.ParsingError as e:\n raise ValidationError('%s: %s' % (path, e))\n\n self.paths = []\n _search(global_paths, self.GLOBAL_FILENAME)\n _search(paths, self.FILENAME)\n\n self.config = config\n\n self._validate()","def __init__(self):\n\n if Config._instance:\n raise Exception('Config singleton is already instantiated. User Config.get_instance() obtain it.')\n\n parser = configparser.ConfigParser()\n parser.read('C:\\\\Users\\\\Akatosh\\\\PythonProjects\\\\note-it\\\\config\\\\config.ini')\n\n self.sections = {}\n\n for section in parser:\n self.sections[section] = _Section(parser[section])\n\n Config._instance = self","def __init__(self, config_directory: Optional[pathlib.Path] = None):\n self._config_parser = configparser.ConfigParser()\n # Preserve case for keys.\n self._config_parser.optionxform = lambda x: x\n\n if config_directory is None:\n self._config_filepath = pathlib.Path(_KFP_CONFIG_FILE)\n else:\n self._config_filepath = config_directory / _KFP_CONFIG_FILE\n\n try:\n with open(str(self._config_filepath), 'r') as f:\n self._config_parser.read_file(f)\n except IOError:\n warnings.warn('No existing KFP Config file found')\n\n if not self._config_parser.has_section(_COMPONENTS_SECTION):\n self._config_parser.add_section(_COMPONENTS_SECTION)\n\n self._components = {}","def _init_config(self, configPath=None):\n # TODO: The SafeConfigParser class has been renamed to ConfigParser in Python 3.2.\n # This alias will be removed in future versions.\n # We still use SafeConfigParser for backwards compatibility with Python 2.\n self.config = SafeConfigParser()\n # Make option names case sensitive\n self.config.optionxform = str\n\n if configPath and os.path.isdir(configPath):\n configDir = configPath\n else:\n configDir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'conf')\n\n # List filenames in configDir alphabetically\n _, _, configFiles = next(os.walk(configDir))\n configFiles = sorted(configFiles, key=str.lower)\n\n # Read configuration pipeline\n for f in configFiles:\n with open(os.path.join(configDir, f)) as configFile:\n self.config.readfp(configFile)\n self._store_config_pass()\n\n if configPath and os.path.isfile(configPath):\n self.config.read(configPath)\n self._store_config_pass()\n\n appSection = 'application'\n self.appName = self._get_option_value(appSection, 'appName')\n self.appResource = self._get_option_value(appSection, 'appResource')\n self.appArgs = []\n appArgs = self._get_option_value(appSection, 'appArgs')\n if appArgs:\n self.appArgs = appArgs.split(' ')\n self.mainClass = self._get_option_value(appSection, 'mainClass')","def __init__(self):\n\n self.root_path = os.path.dirname(os.path.abspath(__file__))[:-5]\n self.config_path = os.path.join(self.root_path, \"files\\\\CONFIG.txt\")\n self.metrics_path = os.path.join(self.root_path, \"files\\\\metrics.txt\")\n\n self.setup_metrics_file()\n\n if self.check_configuration() is False:\n self.setup_configuration_file()","def __init__(self, file):\n\n self.read(file)\n\n for key in [\"sqlite3dir\", \"htmldir\"]:\n print(key)\n if not hasattr(self, \"_{:s}\".format(key)):\n raise ValueError(\"misspecification in config file for \\\"{:s}\\\"\".format(key) + \\\n \" in [observations] section\")","def __init__(self, name=None):\n self.name = name or \"default\"\n config_path = os.path.join(get_config_directory(), self.name + JSON)\n try:\n with open(config_path, mode='r') as config_file:\n self.config_dict = json.load(config_file)\n except Exception as ex:\n raise ColinConfigException(\"Config file '{}' cannot be loaded.\".format(config_path))","def __init__(self, configfile_name):\n assert os.path.exists(configfile_name), \\\n 'Config file %s does not exist' % (configfile_name)\n\n correct_param_load = self.load_config_file(configfile_name)\n assert correct_param_load,\\\n 'Config params could not be loaded from file'\n\n self.fullpath_input_configfile = configfile_name\n self.word_det_rfc = None\n self.reg_coeffs = None\n self.bb_reg = None\n self.img_files = None","def __init__(self, config_file):\n defaults = {'kmsauth_user_key': None, 'logging_level_option': 'INFO'}\n ConfigParser.RawConfigParser.__init__(self, defaults=defaults)\n self.read(config_file)\n\n if not self.has_section(SECTION):\n raise ValueError(\n \"Missing {0} configuration section.\".format(SECTION)\n )\n\n for option in ['kmsauth_key', 'kmsauth_to_context']:\n if not self.has_option(SECTION, option):\n raise ValueError(\"{0} not set.\".format(option))","def load_config(cls, config_file = None):\n config = ConfigParser()\n \n files = [\"/etc/imp.cfg\", os.path.expanduser(\"~/.imp.cfg\"), \".wm\", \".imp\"]\n if config_file is not None:\n files.append(config_file)\n \n config.read(files)\n cls.__instance = config","def _new():\n\treturn ConfigParser(\n\tdelimiters = ('=',),\n\tcomment_prefixes = ('#', ';'),\n\tdefault_section = 'default',\n\tallow_no_value = False,\n\tstrict = False,\n\tinterpolation = ExtendedInterpolation(),\n\tdefaults = {\n\t\t'debug': False,\n\t\t'datadir': path.join(path.expanduser('~'), '.local', 'rosshm'),\n\t\t'log.level': 'warn',\n\t\t'core.enable': True,\n\t\t'db.driver': 'sqlite',\n\t\t'db.name': 'rosshmdb',\n\t\t'db.config': '',\n\t\t'static.enable': True,\n\t\t'web.enable': True,\n\t},\n)","def __init__(self, filename='', complement='', silent=True, config='config.txt'):\n # load preferences\n if config is not None:\n if config == 'config.txt':\n config = os.path.join(os.path.dirname(os.path.realpath(__file__)), config)\n if Graph.CONFIG_GRAPH is not None and Graph.CONFIG_FILENAME == config:\n self._config = Graph.CONFIG_GRAPH\n else:\n self._config = Graph(config, complement={'readas': 'database'},\n config=None)\n if self.CONFIG_FILENAME is None:\n Graph.CONFIG_FILENAME = config\n Graph.CONFIG_GRAPH = self._config\n # actually load the file\n self.reset(filename, complement=complement, silent=silent)","def __init__(self, *args, **kwargs):\r\n super().__init__()\r\n self._cfg = ConfigDict() # current configuration\r\n self._default_config = ConfigDict() # default configuration\r\n self._temp_config = OrderedDict() # temporary configuration\r\n self._path = Path() # current configuration path\r\n self._default_path = Path() # default configuration path\r\n self._conversion_dict = None\r\n self._auto_cast = None\r\n self._write_flags = None\r\n self._force_load = None\r\n self._load_empty = None\r\n self._ask_path = None\r\n self._search_in_default_config = None\r\n self._init_count = 0\r\n self._policies = defaultdict(bool) # by default every modification is forbidden # WIP\r\n if args or kwargs:\r\n self.init(*args, **kwargs)\r\n logger.debug(\"Config object created.\")","def __init__(self, filename):\n\n parser = Parser(filename=filename)\n self.uuid = parser.segregated(parser.read(),'UUID')\n self.id = parser.segregated(parser.read(),'ID')\n self.rate = parser.segregated(parser.read(),'RATE')\n self.gpio = parser.segregated(parser.read(),'GPIO')\n self.ddl = parser.segregated(parser.read(),'DATA_DELIVERY_LOCATION')","def readConfigFile(self):\n self.config_obj = ConfigParser.ConfigParser()\n self.config_obj.readfp(open(self.configfile))\n\n # Set the log file\n if (not self.args_obj.log_file and self.config_obj.has_option('DEFAULT','logfile')):\n self.logfile = self.config_obj.get('DEFAULT', 'logfile')\n\n # Set the baud rate\n if (not self.args_obj.baud_rate and self.config_obj.has_option('DEFAULT','baud')):\n self.baudrate = self.config_obj.get('DEFAULT', 'baud')\n\n # Set the device port \n if (not self.args_obj.device and self.config_obj.has_option('DEFAULT','device')):\n self.device = self.config_obj.get('DEFAULT', 'device')\n\n # Set the connection timeout\n if (not self.args_obj.timeout and self.config_obj.has_option('DEFAULT','timeout')):\n self.timeout = self.config_obj.get('DEFAULT','timeout')\n\n if DEBUG:\n print('(DEBUG) Config Options:')\n self.pp.pprint(self.config_obj.sections())","def __init__(self, filename=None, use_argv=True):\n self._init_filename = filename\n if use_argv:\n self.options, self.args = [self.get_parser().parse_args()] * 2\n else:\n self.options = self.args = None\n self._wrapped = self.load(file=self.settings_file)\n # build a special dynamic section for things the user wants,\n # ie, things that have been passed into the option\n # parser but are not useful in the .ini\n if not self.get_section('user'):\n self['user'] = {}\n if self.options is not None:\n self['user']['shell'] = self.options.shell and 'true' or ''\n else:\n self['user']['shell'] = ''","def __init__ (self, fileName : String):\n\n Logging.trace(\">>: %r\", fileName)\n\n self._keyToValueMap = {}\n self._keyToStringValueMap = {}\n visitedFileNameSet = set()\n lineList = []\n isOkay = self._readFile(\"\", fileName, lineList, visitedFileNameSet)\n self._parseConfiguration(lineList)\n\n Logging.trace(\"<<: %s\",\n _reprOfStringToValueMap(self._keyToValueMap))","def __init__(self):\n\n # open json config file that reads in information\n config_path = open(\"config.json\", \"r\")\n config_json = config_path.read()\n config_dict = json.loads(config_json)\n\n # assign object variables\n self.project_id = config_dict[\"project-id\"]\n self.bucket_name = config_dict[\"bucket-name\"]\n self.location_id = config_dict[\"key-location\"]\n self.key_ring_id = config_dict[\"key-ring-id\"]\n self.crypto_key_id = config_dict[\"crypto-key-id\"]\n self.service_account_email = config_dict[\"service-account-email\"]\n\n # close the file\n config_path.close()","def __init__(self):\n self.options, self.args = self.get_parser().parse_args()\n\n # special case\n self.done=False\n if self.options.encode:\n print generate_password_hash(self.options.encode)\n self.doit()\n self.done=True\n return\n\n self._settings = {}\n if self.options.config:\n _file = self.options.config\n else:\n report(\"You did not pass in a config file with --config, assuming you want %s\"%self.default_file)\n _file = self.default_file\n self._settings.update(self.load(file=_file))\n\n # a few command line options are allowed to override the .ini\n if self.options.port:\n self._settings.update({'flask.port':self.options.port})\n\n # build a special section for things the user wants,\n # ie, things that have been passed into the option\n # parser but are not useful in the .ini\n self._settings.update({'user.shell' : self.options.shell and 'true' or ''})\n self._settings.update({'user.encode_password':self.options.encode})\n def prepare(k,v):\n \"\"\" allow pythonic comments in the .ini files,\n and strip any trailing whitespace.\n\n TODO: move this to ConfigParser subclass.\n \"\"\"\n self._settings[k]=v.strip()\n if '#' in v:\n self._settings[k]=v[:v.find('#')]\n\n [ prepare(k,v) for k,v in self._settings.items() ]\n\n self.doit()","def __init__(self):\n\t\tConfigFile.__init__(self)\n\t\tself.created_by = None\n\t\tself.created_on = None\n\t\tself.definition = None\n\t\tself.note = None\n\t\tself.rejected_by = None\n\t\tself.rejected_on = None\n\t\tself.replaced_by = None\n\t\tself.status = 'elaboration'\n\t\tself.status_reason = None\n\t\tself.term = None\n\t\tself.todo = None\n\t\tself._valid_file_extension = 'def'","def __init__(self, custom_file=None):\n self.home = os.path.abspath(os.path.expanduser('~'))\n # Static Defaults\n defaults = \\\n {\n 'cfg_sn_username' : '',\n 'cfg_sn_password' : '',\n 'cfg_nt_ext' : 'txt',\n 'cfg_nt_path' : os.path.join(self.home, 'Simplenote'),\n 'cfg_nt_trashpath' : '.trash',\n 'cfg_nt_filenamelen' : '60',\n 'cfg_log_level' : 'info'\n }\n\n cp = configparser.SafeConfigParser(defaults)\n if custom_file is not None:\n self.configs_read = cp.read([custom_file])\n else:\n self.configs_read = cp.read([os.path.join(self.home, '.snsync')])\n\n cfg_sec = 'snsync'\n\n if not cp.has_section(cfg_sec):\n cp.add_section(cfg_sec)\n\n self.configs = collections.OrderedDict()\n\n #\n # Environment Varialbles over-ride config file settings.\n # Config files are cfg_abc\n # Envs are sn_abc\n #\n\n if os.environ.get('sn_username') is None:\n val_sn_username = cp.get(cfg_sec, 'cfg_sn_username', raw=True)\n else:\n val_sn_username = os.environ.get('sn_username')\n self.configs['sn_username'] = [val_sn_username, 'Simplenote Username']\n\n if os.environ.get('sn_password') is None:\n val_sn_passowrd = cp.get(cfg_sec, 'cfg_sn_password', raw=True)\n else:\n val_sn_passowrd = os.environ.get('sn_password')\n self.configs['sn_password'] = [val_sn_passowrd, 'Simplenote Password']\n\n if os.environ.get('sn_nt_ext') is None:\n val_sn_nt_ext = cp.get(cfg_sec, 'cfg_nt_ext')\n else:\n val_sn_nt_ext = os.environ.get('sn_nt_ext')\n self.configs['cfg_nt_ext'] = [val_sn_nt_ext, 'Note file extension']\n\n if os.environ.get('sn_nt_path') is None:\n val_sn_nt_path = cp.get(cfg_sec, 'cfg_nt_path')\n else:\n val_sn_nt_path = os.environ.get('sn_nt_path')\n self.configs['cfg_nt_path'] = [val_sn_nt_path, 'Note storage path']\n\n if os.environ.get('sn_nt_trashpath') is None:\n val_sn_nt_trashpath = cp.get(cfg_sec, 'cfg_nt_trashpath')\n else:\n val_sn_nt_trashpath = os.environ.get('sn_nt_trashpath')\n self.configs['cfg_nt_trashpath'] = [val_sn_nt_trashpath, 'Note Trash Bin Folder for deleted notes']\n\n if os.environ.get('sn_nt_filenamelen') is None:\n val_sn_nt_filenamelen = cp.get(cfg_sec, 'cfg_nt_filenamelen')\n else:\n val_sn_nt_filenamelen = os.environ.get('sn_nt_filenamelen')\n self.configs['cfg_nt_filenamelen'] = [val_sn_nt_filenamelen, 'Length of Filename']\n\n if os.environ.get('sn_log_level') is None:\n val_sn_log_level = cp.get(cfg_sec, 'cfg_log_level')\n else:\n val_sn_log_level = os.environ.get('sn_log_level')\n self.configs['cfg_log_level'] = [val_sn_log_level, 'snsync log level']\n\n # Dynamic Defaults\n if os.environ.get('sn_db_path') is None:\n if cp.has_option(cfg_sec, 'cfg_db_path'):\n val_sn_db_path = cp.get(cfg_sec, 'cfg_db_path')\n else:\n val_sn_db_path = os.path.join(cp.get(cfg_sec, 'cfg_nt_path'), '.snsync.sqlite')\n else:\n val_sn_db_path = os.environ.get('sn_db_path')\n self.configs['cfg_db_path'] = [val_sn_db_path, 'snsync database location']\n\n if os.environ.get('sn_log_path') is None:\n if cp.has_option(cfg_sec, 'cfg_log_path'):\n val_sn_log_path = cp.get(cfg_sec, 'cfg_log_path')\n else:\n val_sn_log_path = os.path.join(cp.get(cfg_sec, 'cfg_nt_path'), '.snsync.log')\n else:\n val_sn_log_path = os.environ.get('sn_log_path')\n self.configs['cfg_log_path'] = [val_sn_log_path, 'snsync log location']","def __init__(self, int_conf_file):\n self.fname = int_conf_file\n with open(int_conf_file) as fin:\n self.cfg = cfg = json.load(fin)\n self.probes = cfg['all_probes']\n self.state = None\n self.queue = None\n self.notifiers = {}\n self.notif_cfg = cfg.get('notifiers', [])\n self.users = users = cfg.get('users') or {}\n for name, userinfo in users.items():\n if 'name' not in userinfo:\n userinfo['name'] = name","def load_config(self, config_file):\n self.config = ConfigParser.ConfigParser()\n self.config.read(config_file)","def __init__(self,filename):\n\n\t\tself.filename = filename","def __init__(self, fileName = \"netspy.conf\"):\n\t\tself.options = {'port' : '', 'server_port' : '', 'server_ip': '', 'service_list': [] }\n\t\tself.fileName = fileName\n\t\tself.loadFromFile(self.fileName)","def build_config_parser(filename='GradientOneAuthConfig.txt'):\n cfg = ConfigParser(dict_type=dict)\n cfg.optionxform = str\n cfgfile = None\n try:\n cfgfile = find_file(filename)\n except IOError:\n raise ValueError(\"Could not find a {} file. Please download \"\n \"one for this machine.\".format(filename))\n try:\n cfg.read(cfgfile)\n except IOError:\n raise ValueError(\"Could not read the {} file. Please download a \"\n \"valid config file for this machine.\"\n .format(filename))\n return cfg","def create_from_config_file(cls, filename: str):\n return cls(load_yaml_config(filename))","def __init__(self, filepath):\n self.filepath = filepath","def __init__(self, *args, **kwargs):\n # This is a non-positional argument parser that can be used for\n # --config processing\n self.parser = argparse.ArgumentParser(*args, **kwargs)\n self.parser.add_argument(\"--config\", metavar=\"FILE\",\n help=\"specify a configuration file\")\n self.parser.add_argument(\"--log\", metavar=\"FILE\",\n help=\"specify a log file\")\n self.parser.add_argument(\"--log-level\", metavar=\"LEVEL\",\n choices=[\"DEBUG\", \"INFO\", \"WARNING\", \"ERROR\",\n \"CRITICAL\"],\n default=\"INFO\",\n help=\"{DEBUG,INFO,WARNING,ERROR,CRITICAL} \"\n \"(default=INFO)\")\n\n # Save in case they are needed for reinitialization\n self.kwargs = kwargs\n self.kwargs['add_help'] = False\n self.kwargs['parents'] = [self.parser]\n argparse.ArgumentParser.__init__(self, *args, **self.kwargs)","def __init__(self, filename):\n self.filename = filename","def __init__(self):\n with open('config.json', encoding='UTF-8') as json_data_file:\n self.config = json.load(json_data_file)\n self._get_credential()\n self.file_tree = [{}] * 100","def __init__(self, cooper_config_file):\n\t\t# Determine if the default config file will be used or a user-defined file\n\t\ttry:\n\t\t\tif cooper_config_file is None:\n\t\t\t\tprint(\"[+] Using the default config file: {}\".format(self.cooper_config_file))\n\t\t\telse:\n\t\t\t\tself.cooper_config_file = cooper_config_file\n\t\t\t\tprint(\"[+] Alternate config file identified: {}\".format(self.cooper_config_file))\n\t\texcept Exception as err:\n\t\t\tprint(\"[!] \")\n\t\t\tprint(\"L.. Details: {}\".format())\n\t\t# Open the config file for parsing\n\t\ttry:\n\t\t\tself.config_parser = configparser.ConfigParser()\n\t\t\tself.config_parser.read(self.cooper_config_file)\n\t\texcept Exception as err:\n\t\t\tprint(\"[!] Could not open the config file -- make sure it exists and is readable.\")\n\t\t\tprint(\"L.. Details: {}\".format(err))\n\t\t# Parse the config file's values\n\t\ttry:\n\t\t\tself.landing_page_url_replacement = self.config_section_map(\"Replacement URLs\")[\"landing_page_url_replacement\"]\n\t\t\tself.landing_page_form_action = self.config_section_map(\"Replacement URLs\")[\"landing_page_form_action\"]\n\t\t\tself.email_replacement_url = self.config_section_map(\"Replacement URLs\")[\"email_replacement_url\"]\n\t\t\tself.email_tracker_url = self.config_section_map(\"Replacement URLs\")[\"email_tracker_url\"]\n\t\t\tself.path_to_chromedriver = self.config_section_map(\"Browser\")[\"driver_path\"]\n\t\t\tif self.config_section_map(\"Browser\")[\"user_agent\"] == \"\":\n\t\t\t\tself.user_agent = \"(Mozilla/5.0 (Windows; U; Windows NT 6.0;en-US; rv:1.9.2) Gecko/20100115 Firefox/3.6\"\n\t\t\telse:\n\t\t\t\tself.user_agent = self.config_section_map(\"Browser\")[\"user_agent\"]\n\t\texcept Exception as err:\n\t\t\tprint(\"[!] Failed to read all values from the config file! Exiting...\")\n\t\t\tprint(\"L.. Details: {}\".format(err))\n\t\t\tsys.exit()","def __init__(self, appname):\n self.exepath = '%s' % (os.path.dirname(os.path.realpath(__file__)))\n self.cnfgfile = '%s/versions.cfg' % self.exepath\n self.static_path = '%s/app/static' % self.exepath\n self.config = ConfigParser.RawConfigParser()","def __init__(self, filename):\r\n self._results = SpecParser(filename).parse()","def __init__(self, filename):\n self._filename = filename\n pass","def __init__(self, mbox_file, configs):\n self.filename = mbox_file\n if os.path.isfile(mbox_file):\n self.mbox = mailbox.mbox(mbox_file)\n else:\n raise IOError(\"Can't find that file\")\n\n self.config = dict()\n cfg_file = file(configs, 'r')\n for line in cfg_file:\n if line[0] != '#':\n parsed = line.strip().split(\"=\")\n if len(parsed) != 2:\n raise ValueError(\"Bad config file.\")\n else:\n self.config[parsed[0]] = parsed[1]\n self.messages = list()","def init_config(filename):\n config = configparser.ConfigParser()\n try:\n with open(filename, 'r') as config_file:\n config.read(config_file)\n except EnvironmentError:\n print(\"FATAL ERROR: Failed to open config file at \" + filename)\n sys.exit(1)\n return config","def __init__(self, conf=None):\n # set interpolation to None so you can supply filename template\n # that contain % to config.set\n conf = ConfigParser(strict=False,\n inline_comment_prefixes=(';',),\n interpolation=None) if (conf is None) else conf\n super().__init__(conf)\n self._cycle = None\n self._logger = logging.getLogger('metplus')\n # config.logger is called in wrappers, so set this name\n # so the code doesn't break\n self.logger = self._logger\n\n # get the OS environment and store it\n self.env = os.environ.copy()\n\n # add section to hold environment variables defined by the user\n self.add_section('user_env_vars')","def __init__(self, cfg=None, **kwargs):\n self.__dir = KITConfig.configDir\n self.__cfgFile = \"\"\n\n self.__cfg = {}\n self.__default = KITConfig.defaultConfig\n\n self.__setupLogger()\n\n if cfg is not None:\n self.__cfgFile = cfg\n self.load(cfg)","def __init__(self, config_path: str = \"config.json\"):\n # Change here if you want to relocate you config file\n self.config = {}\n self.load_configuration(config_path)\n self.app_name = self.config.get('app_name', self.APP_NAME)","def __init__(self, filename, registry):\n self.filename = filename\n self.registry = registry","def __init__(self, filename):\r\n\r\n self.filename = filename","def __init__(self, settings_file_name):\n with open(settings_file_name, 'r') as f:\n # load config file\n self.settings = yaml.load(f)\n\n # get key values\n sit_names = self.settings[HNF.Consts.SIT_NAMES]\n row_action_names = self.settings[HNF.Consts.ROW_ACT_NAMES]\n column_action_names = self.settings[HNF.Consts.COL_ACT_NAMES]\n name = self.settings[HNF.Consts.NAME]\n\n # init HNG object\n self.HNFOut = HNF.HNFInstance(sit_names, row_action_names, column_action_names, name)\n\n # set the values found in the settings\n self.__initFromFile()\n\n # calc the summary and expected utility\n self.HNFOut.initSummaryBelief()\n self.HNFOut.initExpectedUtility()\n self.HNFOut.calcHypergameExpectedUtility()\n self.HNFOut.calcModelingOpponentUtility()","def __init__(self, filename=None):\n if filename:\n dict.__init__(self, self.read_file(filename))\n else:\n dict.__init__(self)\n self.new_plist()","def __init__(self, filename=None):\n self._filename = filename","def __init__(self, filename):\n self.from_file(filename)\n self.parse_cell()\n self.parse_atom()\n self.apply_symops()","def __init__(self, cfg_path):\n\t\tself.cfg_path = cfg_path\n\t\tself.cfg_root = self.load_cfg(self.cfg_path)","def __init__(self):\n if not os.path.isfile(CONFIG_FILENAME):\n first_time_run()\n raise SystemExit()\n\n \"\"\"\n Init file is present, read and parse it:\n \"\"\"\n conf = configparser.ConfigParser(interpolation=configparser.ExtendedInterpolation(), inline_comment_prefixes='#')\n conf.read(CONFIG_FILENAME)\n \"\"\"\n Process certain paths:\n \"\"\"\n\n path = conf['Paths']\n self.ffc_dir = path['FlatFieldCalDir']\n self.capture_dir = path['CaptureDir']\n self.image_dir = path['ImageDir']\n\n \"\"\"\n Process options\n \"\"\"\n\n self.cal_auto_save = conf.getboolean('Options', 'CalAutoSave', fallback=True)\n self.cal_auto_load = conf.getboolean('Options', 'CalAutoLoad', fallback=True)\n self.sound_on_capture = conf.getboolean('Options', 'SoundOnCapture', fallback=True)\n self.exp_init1 = conf.getint('Options', 'ExpInit1', fallback=100)\n self.exp_init2 = conf.getint('Options', 'ExpInit2', fallback=100)\n self.black_correct = conf.getboolean('Options', 'BlackCorrect', fallback=True)\n # Setup square window, default of full-screen height\n self.tiff_seq_x_window = conf.getint('Options', 'TiffSeqXWindow', fallback=cameras.FRAME_HEIGHT)\n self.tiff_seq_y_window = conf.getint('Options', 'TiffSeqYWindow', fallback=cameras.FRAME_HEIGHT)\n self.tiff_seq_rebin = conf.getint('Options', 'TiffSeqRebin', fallback = 2)","def __init__(self):\n self.storefn = Config.getConfigFnPath()\n\n # Load the configuration file file\n self.load()","def __init__(self, environment):\n with open('config.json') as f:\n self.config = eval(f.read())\n self.config = self.config[environment]","def __init__(self, config):\n\n self.root = config.root\n self.pidfile = config.pidfile\n self.log_conf = config.logging","def _get_config(self, unit, filename):\n file_contents = unit.file_contents(filename)\n config = ConfigParser.ConfigParser()\n config.readfp(io.StringIO(file_contents))\n return config","def __init__(self, config_path, normalize=False):\n self.config = {}\n _config_dict = {}\n self._config_path = Utils.expand_path(config_path)\n self.update = None\n self.normalize = normalize","def load_configuration(self) -> None:\n config_file = self.default_config_file\n if self.config_file:\n config_file = self.config_file\n self.config = configparser.ConfigParser(delimiters=\"=\")\n # mypy is unhappy with us assigning to a method - (monkeypatching?)\n self.config.optionxform = lambda option: option # type: ignore\n self.config.read(config_file)","def __init__(self, configfile='settings.cfg'):\n \n self.configfile = configfile\n \n # Load parameters from config file\n config = ConfigParser.RawConfigParser()\n config.read(self.configfile)\n \n # Set parameters to default if not in config file \n self.title=config.get('Settings','title') if config.has_option(\n 'Settings','title') else 'REDPy Catalog'\n self.filename=config.get('Settings','filename') if config.has_option(\n 'Settings','filename') else 'redpytable.h5'\n self.groupName=config.get('Settings','groupName') if config.has_option(\n 'Settings','groupName') else 'default'\n self.groupDesc=config.get('Settings','groupDesc') if config.has_option(\n 'Settings','groupDesc') else 'Default Test Run'\n self.nsta=config.getint('Settings','nsta') if config.has_option(\n 'Settings','nsta') else 8 \n self.station=config.get('Settings','station') if config.has_option(\n 'Settings','station') else 'SEP,YEL,HSR,SHW,EDM,STD,JUN,SOS'\n self.channel=config.get('Settings','channel') if config.has_option(\n 'Settings','channel') else 'EHZ,EHZ,EHZ,EHZ,EHZ,EHZ,EHZ,EHZ'\n self.network=config.get('Settings','network') if config.has_option(\n 'Settings','network') else 'UW,UW,UW,UW,UW,UW,UW,UW'\n self.location=config.get('Settings','location') if config.has_option(\n 'Settings','location') else '--,--,--,--,--,--,--,--'\n self.samprate=config.getfloat('Settings','samprate') if config.has_option(\n 'Settings','samprate') else 100.\n self.nstaC=config.getint('Settings','nstaC') if config.has_option(\n 'Settings','nstaC') else 5\n self.printsta=config.getint('Settings','printsta') if config.has_option(\n 'Settings','printsta') else 2\n self.server=config.get('Settings','server') if config.has_option(\n 'Settings','server') else 'IRIS'\n self.port=config.getint('Settings','port') if config.has_option(\n 'Settings','port') else 16017\n self.nsec=config.getint('Settings','nsec') if config.has_option(\n 'Settings','nsec') else 3600\n self.lwin=config.getfloat('Settings','lwin') if config.has_option(\n 'Settings','lwin') else 7.\n self.swin=config.getfloat('Settings','swin') if config.has_option(\n 'Settings','swin') else 0.8\n self.trigon=config.getfloat('Settings','trigon') if config.has_option(\n 'Settings','trigon') else 3.\n self.trigoff=config.getfloat('Settings','trigoff') if config.has_option(\n 'Settings','trigoff') else 2.\n self.kurtmax=config.getfloat('Settings','kurtmax') if config.has_option(\n 'Settings','kurtmax') else 80.\n self.kurtfmax=config.getfloat('Settings','kurtfmax') if config.has_option(\n 'Settings','kurtfmax') else 150.\n self.oratiomax=config.getfloat('Settings','oratiomax') if config.has_option(\n 'Settings','oratiomax') else 0.06\n self.kurtwin=config.getfloat('Settings','kurtwin') if config.has_option(\n 'Settings','kurtwin') else 5.\n self.winlen=config.getint('Settings','winlen') if config.has_option(\n 'Settings','winlen') else 1024\n self.fmin=config.getfloat('Settings','fmin') if config.has_option(\n 'Settings','fmin') else 1.\n self.fmax=config.getfloat('Settings','fmax') if config.has_option(\n 'Settings','fmax') else 10.\n self.filomin=config.getfloat('Settings','filomin') if config.has_option(\n 'Settings','filomin') else 1.\n self.filomax=config.getfloat('Settings','filomax') if config.has_option(\n 'Settings','filomax') else 2.5\n self.fiupmin=config.getfloat('Settings','fiupmin') if config.has_option(\n 'Settings','fiupmin') else 5.\n self.fiupmax=config.getfloat('Settings','fiupmax') if config.has_option(\n 'Settings','fiupmax') else 10.\n self.telefi=config.getfloat('Settings','telefi') if config.has_option(\n 'Settings','telefi') else -1.\n self.teleok=config.getint('Settings','teleok') if config.has_option(\n 'Settings','teleok') else 1 \n self.cmin=config.getfloat('Settings','cmin') if config.has_option(\n 'Settings','cmin') else 0.7\n self.ncor=config.getint('Settings','ncor') if config.has_option(\n 'Settings','ncor') else 4\n self.minorph=config.getfloat('Settings','minorph') if config.has_option(\n 'Settings','minorph') else 0.05\n self.maxorph=config.getfloat('Settings','maxorph') if config.has_option(\n 'Settings','maxorph') else 7.\n self.minplot=config.getint('Settings','minplot') if config.has_option(\n 'Settings','minplot') else 3\n self.dybin=config.getfloat('Settings','dybin') if config.has_option(\n 'Settings','dybin') else 1.\n self.hrbin=config.getfloat('Settings','hrbin') if config.has_option(\n 'Settings','hrbin') else 1.\n self.recplot=config.getfloat('Settings','recplot') if config.has_option(\n 'Settings','recplot') else 14.\n \n # Derived Settings\n self.ptrig=1.5*self.winlen/self.samprate\n self.atrig=3*self.winlen/self.samprate\n self.mintrig=self.winlen/self.samprate\n self.wshape = int((self.ptrig + self.atrig)*self.samprate) + 1","def __init__(self, path_to_the_file):","def __init__(self, path_to_the_file):","def initialize_from_config(self):","def __init__(self, defaults=None):\n self._configFileName = None\n if defaults is None:\n self._defaults = ConfigDict()\n else:\n self._defaults = ConfigDict(copy.deepcopy(defaults))\n self.importedFiles = []\n self.includedFiles = []\n self.missingFiles = []","def __init__(self, environment='develop'):\n\n cwd = path.dirname(path.abspath(__file__))\n config_dir = path.join(cwd, 'configs')\n\n config_files = []\n for (root, _, file_names) in walk(config_dir):\n for file_name in file_names:\n config_files.append(path.join(root, file_name))\n config_files = sorted(config_files)\n\n for config_file in config_files:\n config = anyconfig.load(config_file)\n for key in config:\n self[key] = config[key]\n\n if environment in config_file:\n break","def __init__(self, filename=None):\n self.content = dict()\n if filename and os.path.exists(filename):\n self.parse(filename)\n elif filename:\n self.new(filename)","def __init__(self, config: str) -> None:\n self.configuration = config","def __init__(self, config: str) -> None:\n self.configuration = config","def read_config(self, config_filename):"],"string":"[\n \"def __init__(self, filename, dirname='~'):\\n self.config = configparser.ConfigParser()\\n\\n expanded_dirname = os.path.expanduser(dirname)\\n self.configuration_filename = os.path.join(expanded_dirname, filename)\\n if os.path.isfile(self.configuration_filename):\\n self.config.read(self.configuration_filename)\",\n \"def __init__(self):\\n\\n self.path = os.path.dirname(os.path.realpath(__file__)) + '/config.ini'\\n self.config = configparser.ConfigParser()\\n self.config.read(self.path)\",\n \"def __init__(self):\\n self.filename = pathlib.Path(__file__).parent.absolute().__str__() + '/../../data/config.ini'\\n self.data = ConfigParser()\\n self.data.read(self.filename)\",\n \"def __init__(self, ini_file):\\n self.config = configparser.ConfigParser()\\n self.config.read(ini_file)\",\n \"def __init__(self, ini_file):\\n self.config = configparser.ConfigParser()\\n self.config.read(ini_file)\\n #print(self.config)\",\n \"def __init__(self, config_file):\\n \\n self.log = logging.getLogger(__name__)\\n\\n self.parser = ConfigParser.ConfigParser()\\n if os.path.exists(config_file) and os.path.isfile(config_file):\\n self.parser.read(config_file)\\n self.log.debug(\\\"opened configuration '%s'\\\" % config_file)\\n else:\\n raise ConfigError(\\\"Config file missing\\\", \\\"File '%s' doesn't exist.\\\" % (config_file))\\n\\n self.config_file = config_file\\n self.check_config()\",\n \"def __init__(self, config_file_name=\\\"config.json\\\"):\\n self.config_file_name = config_file_name\\n self._config = self._open_config_file()\",\n \"def __init__(self, filepath=None):\\n self.path = self.__default_filepath if filepath is None else filepath\\n self.parser = configparser.ConfigParser()\\n if self.__section_default not in self.parser.sections():\\n self.parser.add_section(self.__section_default)\\n\\n self.parser.read(self.path)\",\n \"def __init__(self, filename):\\n self.cfg_spec = ConfigObj(config_spec_text.splitlines(), list_values=False)\\n self.cfg_filename = filename\\n valid = Validator()\\n if not os.path.exists(self.cfg_filename):\\n #no configuration file found\\n logger.info(\\\"File %s not found, so creating one from you from defaults\\\" % self.cfg_filename)\\n cfg = ConfigObj(configspec=self.cfg_spec, stringify=True, list_values=True)\\n cfg.filename = self.cfg_filename\\n test = cfg.validate(valid, copy=True)\\n cfg.write()\\n self.cfg = ConfigObj(self.cfg_filename, configspec=self.cfg_spec)\\n rtn = self.cfg.validate(valid, preserve_errors=True)\\n if type(rtn) == types.BooleanType and rtn:\\n logger.info(\\\"Config file validated\\\")\\n self.tested = True\\n else:\\n self.tested = False\\n res = flatten_errors(self.cfg, rtn)\\n self.errortxt = ''\\n for row in res:\\n self.errortxt += 'In Section %s, key %s has error: %s' % (row[0], row[1], row[2])\\n logger.error(self.errortxt)\",\n \"def __init__(self, path_to_config_file):\\n self.file_path = path_to_config_file\",\n \"def __init__(self, file_handle):\\n config = ConfigParser.ConfigParser()\\n config.readfp(file_handle)\\n self.database_address_ = config.get('General', 'database_address')\\n self.google_developer_key_ = config.get('Google', 'developer_key')\\n self.google_cref_ = config.get('Google', 'cref')\",\n \"def __init__(self, __file):\\n\\n\\t\\tself.fileName = __file\\n\\t\\tif (os.path.isfile(self.fileName)):\\n\\t\\t\\t# config.ini found, load it\\n\\t\\t\\tself.config.read(self.fileName)\\n\\t\\t\\tself.default = False\\n\\t\\telse:\\n\\t\\t\\t# config.ini not found, generate a default one\\n\\t\\t\\tself.generateDefaultConfig()\\n\\t\\t\\tself.default = True\",\n \"def __init__(self, config_file=None):\\n self.file = config_file\\n self.parser = SafeConfigParser()\\n if isinstance(self.file, (str, list)):\\n self.parser.read(self.file)\\n else: # assume file object was given instead\\n self.parser.read_file(self.file)\\n self._flask_cache = None\\n self._assets_cache = None\\n self._gridrealm_cache = None\",\n \"def __init__(self, config_file=None):\\n\\t\\tself.options = {}\\n\\n\\t\\tif config_file:\\n\\t\\t\\tself.set_file(config_file)\",\n \"def __init__(self, config_file = 'config.yaml'):\\n\\n self.name = ''\\n self.img_dir = ''\\n self.out_dir = ''\\n self.cam_file = ''\\n self.options_file = ''\\n self.output_xml_file = ''\\n\\n # If there is an options file, it will overwrite the defaults \\n if config_file is not None:\\n self.load(config_file)\",\n \"def __init__(self, config_file, verbose):\\r\\n self.loadConfig(config_file)\\r\\n self.verbose = verbose\",\n \"def __init__(self, filename=None):\\n if filename:\\n if not os.path.exists(filename):\\n raise Exception(\\\"No configuration found at %s\\\" % filename)\\n super(Configuration, self).__init__(filename)\",\n \"def __init__(self, config_file):\\n with open(config_file, 'r') as file:\\n self.config = json.load(file)\\n self.set_config(self.config)\",\n \"def __init__(self):\\n # Read configuration into dictionary\\n self.directories = general.config_directories()\\n self.config = general.read_yaml_files(self.directories)\",\n \"def __init__(self, file):\\n self.file = file\\n self.config = self.__analyze_config()\",\n \"def __init__(self, config_file):\\n Config = ConfigParser.ConfigParser()\\n Config.read(config_file)\\n \\n self.port_id = Config.get(\\\"SerialPortSection\\\", \\\"ComPort\\\")\\n self.baud_rate = Config.get(\\\"SerialPortSection\\\", \\\"BaudRate\\\")\\n self. timeout = Config.get(\\\"SerialPortSection\\\", \\\"TimeOut\\\")\\n self.config_file = config_file\",\n \"def __init__(self):\\n ConfigParser.RawConfigParser.OPTCRE = re.compile(r'(?P<option>[^=\\\\s][^=]*)\\\\s*(?P<vi>[=])\\\\s*(?P<value>.*)$')\\n self.CONFIG = ConfigParser.ConfigParser()\\n self.CONFIG.read(os.path.join(os.path.dirname(__file__)))\\n self.IPS = []\",\n \"def __init__(self):\\n\\t\\t\\n\\t\\tsettings = configparser.SafeConfigParser(allow_no_value=True)\\n\\t\\tlist=settings.read('data/settings.cfg')\\n\\t\\tif not 'data/settings.cfg' in list:\\n\\t\\t\\tprint('no configuration file present.. making one')\\n\\t\\t\\tself.makeConfigFile(settings)\\n\\t\\t\\tshare = ['']\\n\\t\\t\\tself.nodes = []\\n\\t\\telse:\\n\\t\\t\\tshare, nodes = self.openConfig(settings)\\n\\t\\t\\tself.nodes = nodes\\n\\t\\t\\n\\t\\t\\n\\t\\tself.files = self.loadFiles(share)\\t\\t\\n\\t\\tself.share = share\\n\\t\\tself.kill= False\\n\\t\\tself.downloads = {}\\n\\t\\tself.currentVersion = (0,2,1)\\n\\t\\tself.totalDownloads = 0\\n\\t\\tself.current = 0\\n\\t\\tself.config = settings\",\n \"def __init__(self, filename=None):\\r\\n self._specs = self._load_spec(filename)\\r\\n self._properties = {}\\r\\n self._names = []\\r\\n self._defaults = {}\",\n \"def __init__(self, config_file: str = \\\"config.json\\\"):\\n path_to_config = (Path(sys.modules[self.__module__].__file__).parent\\n / config_file)\\n with open(path_to_config, \\\"r\\\") as f:\\n self.options = json.load(f)\",\n \"def __init__(self, filepath):\\n try:\\n config_file_r = open(filepath)\\n self.sim_parametres = yaml.load(config_file_r, Loader=yaml.FullLoader)\\n except:\\n raise Exception(\\\"Le fichier de configuration n'a pas été atteint ou n'a pas pu être lu. Veuillez vérifier \\\"\\n \\\"qu'il n'y ait aucune erreur de syntaxe.\\\")\",\n \"def __init__(self, config_file_name=\\\"config.json\\\"):\\n with open(config_file_name, \\\"r\\\") as config:\\n f = dict(json.load(config))\\n for key, value in f.items():\\n setattr(self, key, value)\",\n \"def __init__(self, filename):\\n if filename is None:\\n self.config = toml.load('configs/default.conf')\\n return\\n self.config = toml.load(filename)\\n self.config['directory'] = {}\\n self.config['directory']['root'] = os.path.dirname(\\n os.path.realpath(__file__))\\n self.config['directory']['datasets'] = os.path.join(\\n self.config['directory']['root'], 'datasets')\",\n \"def __init__(self):\\n cfg = ConfigParser.ConfigParser()\\n\\n if sys.executable == sys.argv[0]: # Windows binary\\n self.VISIONEGG_SYSTEM_DIR = os.curdir\\n self.VISIONEGG_USER_DIR = os.curdir\\n else:\\n # non-standard VisionEgg installations\\n try:\\n self.VISIONEGG_SYSTEM_DIR = os.environ['VISIONEGG_SYSTEM_DIR']\\n except KeyError:\\n self.VISIONEGG_SYSTEM_DIR = os.path.split(__file__)[0]\\n user_dir = os.path.expanduser(\\\"~\\\")\\n self.VISIONEGG_USER_DIR = os.path.join(user_dir,\\\"VisionEgg\\\")\\n\\n # See if there's an environment variable for the config file\\n if 'VISIONEGG_CONFIG_FILE' in os.environ.keys():\\n configFile = os.environ['VISIONEGG_CONFIG_FILE']\\n else:\\n # Is there one in VISIONEGG_USER_DIR?\\n configFile = os.path.join(self.VISIONEGG_USER_DIR,\\\"VisionEgg.cfg\\\")\\n if not os.path.isfile(configFile):\\n configFile = os.path.join(self.VISIONEGG_SYSTEM_DIR,\\\"VisionEgg.cfg\\\")\\n if not os.path.isfile(configFile):\\n configFile = None # No file, use defaults specified in environment variables then here\\n\\n if configFile:\\n cfg.read(configFile)\\n else:\\n # pretend we have a config file\\n cfg.add_section('General')\\n for key in defaults.keys():\\n cfg.set('General',key,str(defaults[key]))\\n if sys.platform == 'darwin':\\n cfg.add_section('darwin')\\n for key in extra_darwin_defaults.keys():\\n cfg.set('darwin',key,str(extra_darwin_defaults[key]))\\n\\n # Do the general stuff first\\n # Set the default values\\n for name in defaults.keys():\\n if name in os.environ.keys():\\n value = os.environ[name]\\n else:\\n value = defaults[name]\\n if isinstance(defaults[name], int):\\n\\t\\tif value == 'False':\\n\\t\\t value = 0\\n\\t\\telif value == 'True':\\n\\t\\t value = 1\\n setattr(self,name,int(value))\\n elif isinstance(defaults[name], float):\\n setattr(self,name,float(value))\\n else:\\n setattr(self,name,value)\\n\\n # Get the values from the configFile\\n general_options = cfg.options('General')\\n\\n self._delayed_configuration_log_warnings = [] # chick and egg problem\\n # set defaults from config file\\n for option in general_options:\\n name = option.upper()\\n if name not in defaults.keys():\\n self._delayed_configuration_log_warnings.append(\\n \\\"While reading %s: The variable \\\\\\\"%s\\\\\\\" is not (anymore) a Vision Egg variable.\\\"%(os.path.abspath(configFile),option))\\n continue\\n value = cfg.get('General',option)\\n if name in os.environ.keys():\\n value = os.environ[name]\\n if isinstance(defaults[name], int):\\n\\t\\tif value == 'False':\\n\\t\\t value = 0\\n\\t\\telif value == 'True':\\n\\t\\t value = 1\\n setattr(self,name,int(value))\\n elif isinstance(defaults[name], float):\\n setattr(self,name,float(value))\\n else:\\n setattr(self,name,value)\\n\\n # Do platform specific stuff\\n # Set the default values\\n platform_name = sys.platform\\n extra_name = \\\"extra_%s_defaults\\\"%(platform_name,)\\n if extra_name in globals().keys():\\n extra_defaults = globals()[extra_name]\\n for name in extra_defaults.keys():\\n setattr(self,name,extra_defaults[name])\\n\\n # Get the values from the configFile\\n platform_options = cfg.options(platform_name)\\n for option in platform_options:\\n name = option.upper()\\n if name not in extra_defaults.keys():\\n raise KeyError(\\\"No Vision Egg configuration variable \\\\\\\"%s\\\\\\\"\\\"%option)\\n value = cfg.get(platform_name,option)\\n if name in os.environ.keys():\\n value = os.environ[name]\\n if isinstance(extra_defaults[name], int):\\n\\t\\t if value == 'False':\\n\\t\\t value = 0\\n \\t\\t elif value == 'True':\\n\\t\\t value = 1\\n setattr(self,name,int(value))\\n elif isinstance(extra_defaults[name], float):\\n setattr(self,name,float(value))\\n else:\\n setattr(self,name,value)\\n\\n if(configFile):\\n self.VISIONEGG_CONFIG_FILE = os.path.abspath(configFile)\\n else:\\n self.VISIONEGG_CONFIG_FILE = None\",\n \"def __init__(self, settings):\\n self._read_config(settings)\",\n \"def __init__(self, conf_file_location: str, template_dir: str, target_dir: str, hard_reset: bool):\\n self.config: Config = yaml_loader.load(conf_file_location, Config)\\n self.massage_config_file()\\n self.config_dict: Dict = as_dict(self.config)\\n self.template_dir = template_dir\\n self.target_dir = target_dir\\n self.hard_reset = hard_reset\",\n \"def __init__(self, config_file='/etc/sfa/ldap_config.py'):\\n\\n try:\\n execfile(config_file, self.__dict__)\\n\\n self.config_file = config_file\\n # path to configuration data\\n self.config_path = os.path.dirname(config_file)\\n except IOError:\\n raise IOError, \\\"Could not find or load the configuration file: %s\\\" \\\\\\n % config_file\",\n \"def __init__(self, default_cfg='default.ini', argv=None):\\n\\n # Read the default settings\\n self.config = configparser.ConfigParser()\\n self.config.read(default_cfg)\\n # Check for a command line config argument\\n if argv is not None and '--config_fn' in argv:\\n # Get the config filename\\n config_fn = argv[argv.index('--config_fn') + 1]\\n argv.remove('--config_fn')\\n argv.remove(config_fn)\\n # Read the new config file\\n new_cfg = configparser.ConfigParser()\\n new_cfg.read(config_fn)\\n # Overwrite the default values\\n self._overwrite_with_config(new_cfg)\\n if argv is not None:\\n self._parse_arguments(argv)\\n self._update()\",\n \"def __init__(self, rootdir, filename, clean=False):\\n self._autoconfig_filename = rootdir + filename\\n self._rootdir = rootdir\\n self._metadata = {}\\n self._nodes = {}\\n self._vpp_devices_node = {}\\n self._hugepage_config = \\\"\\\"\\n self._clean = clean\\n self._loadconfig()\\n self._sockfilename = \\\"\\\"\",\n \"def __init__(self, file):\\n self.__config = file\\n with open(self.__config) as json_file:\\n data = json.load(json_file)\\n self.__data = data\",\n \"def __init__(self, name, defaults = {} ):\\n self.defaults = defaults\\n self.filename = os.path.expanduser(name)+\\\".ini\\\"\\n self.conf = {}\\n self.reset()\\n if os.path.exists(self.filename):\\n self.load()\",\n \"def __init__(self, paths=('',), global_paths=()):\\n config = RawConfigParser()\\n\\n def _search(paths, filename):\\n for path in paths:\\n path = os.path.join(path, filename)\\n if os.path.exists(path):\\n self.paths.append(path)\\n try:\\n config.read(path)\\n except ConfigParser.ParsingError as e:\\n raise ValidationError('%s: %s' % (path, e))\\n\\n self.paths = []\\n _search(global_paths, self.GLOBAL_FILENAME)\\n _search(paths, self.FILENAME)\\n\\n self.config = config\\n\\n self._validate()\",\n \"def __init__(self):\\n\\n if Config._instance:\\n raise Exception('Config singleton is already instantiated. User Config.get_instance() obtain it.')\\n\\n parser = configparser.ConfigParser()\\n parser.read('C:\\\\\\\\Users\\\\\\\\Akatosh\\\\\\\\PythonProjects\\\\\\\\note-it\\\\\\\\config\\\\\\\\config.ini')\\n\\n self.sections = {}\\n\\n for section in parser:\\n self.sections[section] = _Section(parser[section])\\n\\n Config._instance = self\",\n \"def __init__(self, config_directory: Optional[pathlib.Path] = None):\\n self._config_parser = configparser.ConfigParser()\\n # Preserve case for keys.\\n self._config_parser.optionxform = lambda x: x\\n\\n if config_directory is None:\\n self._config_filepath = pathlib.Path(_KFP_CONFIG_FILE)\\n else:\\n self._config_filepath = config_directory / _KFP_CONFIG_FILE\\n\\n try:\\n with open(str(self._config_filepath), 'r') as f:\\n self._config_parser.read_file(f)\\n except IOError:\\n warnings.warn('No existing KFP Config file found')\\n\\n if not self._config_parser.has_section(_COMPONENTS_SECTION):\\n self._config_parser.add_section(_COMPONENTS_SECTION)\\n\\n self._components = {}\",\n \"def _init_config(self, configPath=None):\\n # TODO: The SafeConfigParser class has been renamed to ConfigParser in Python 3.2.\\n # This alias will be removed in future versions.\\n # We still use SafeConfigParser for backwards compatibility with Python 2.\\n self.config = SafeConfigParser()\\n # Make option names case sensitive\\n self.config.optionxform = str\\n\\n if configPath and os.path.isdir(configPath):\\n configDir = configPath\\n else:\\n configDir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'conf')\\n\\n # List filenames in configDir alphabetically\\n _, _, configFiles = next(os.walk(configDir))\\n configFiles = sorted(configFiles, key=str.lower)\\n\\n # Read configuration pipeline\\n for f in configFiles:\\n with open(os.path.join(configDir, f)) as configFile:\\n self.config.readfp(configFile)\\n self._store_config_pass()\\n\\n if configPath and os.path.isfile(configPath):\\n self.config.read(configPath)\\n self._store_config_pass()\\n\\n appSection = 'application'\\n self.appName = self._get_option_value(appSection, 'appName')\\n self.appResource = self._get_option_value(appSection, 'appResource')\\n self.appArgs = []\\n appArgs = self._get_option_value(appSection, 'appArgs')\\n if appArgs:\\n self.appArgs = appArgs.split(' ')\\n self.mainClass = self._get_option_value(appSection, 'mainClass')\",\n \"def __init__(self):\\n\\n self.root_path = os.path.dirname(os.path.abspath(__file__))[:-5]\\n self.config_path = os.path.join(self.root_path, \\\"files\\\\\\\\CONFIG.txt\\\")\\n self.metrics_path = os.path.join(self.root_path, \\\"files\\\\\\\\metrics.txt\\\")\\n\\n self.setup_metrics_file()\\n\\n if self.check_configuration() is False:\\n self.setup_configuration_file()\",\n \"def __init__(self, file):\\n\\n self.read(file)\\n\\n for key in [\\\"sqlite3dir\\\", \\\"htmldir\\\"]:\\n print(key)\\n if not hasattr(self, \\\"_{:s}\\\".format(key)):\\n raise ValueError(\\\"misspecification in config file for \\\\\\\"{:s}\\\\\\\"\\\".format(key) + \\\\\\n \\\" in [observations] section\\\")\",\n \"def __init__(self, name=None):\\n self.name = name or \\\"default\\\"\\n config_path = os.path.join(get_config_directory(), self.name + JSON)\\n try:\\n with open(config_path, mode='r') as config_file:\\n self.config_dict = json.load(config_file)\\n except Exception as ex:\\n raise ColinConfigException(\\\"Config file '{}' cannot be loaded.\\\".format(config_path))\",\n \"def __init__(self, configfile_name):\\n assert os.path.exists(configfile_name), \\\\\\n 'Config file %s does not exist' % (configfile_name)\\n\\n correct_param_load = self.load_config_file(configfile_name)\\n assert correct_param_load,\\\\\\n 'Config params could not be loaded from file'\\n\\n self.fullpath_input_configfile = configfile_name\\n self.word_det_rfc = None\\n self.reg_coeffs = None\\n self.bb_reg = None\\n self.img_files = None\",\n \"def __init__(self, config_file):\\n defaults = {'kmsauth_user_key': None, 'logging_level_option': 'INFO'}\\n ConfigParser.RawConfigParser.__init__(self, defaults=defaults)\\n self.read(config_file)\\n\\n if not self.has_section(SECTION):\\n raise ValueError(\\n \\\"Missing {0} configuration section.\\\".format(SECTION)\\n )\\n\\n for option in ['kmsauth_key', 'kmsauth_to_context']:\\n if not self.has_option(SECTION, option):\\n raise ValueError(\\\"{0} not set.\\\".format(option))\",\n \"def load_config(cls, config_file = None):\\n config = ConfigParser()\\n \\n files = [\\\"/etc/imp.cfg\\\", os.path.expanduser(\\\"~/.imp.cfg\\\"), \\\".wm\\\", \\\".imp\\\"]\\n if config_file is not None:\\n files.append(config_file)\\n \\n config.read(files)\\n cls.__instance = config\",\n \"def _new():\\n\\treturn ConfigParser(\\n\\tdelimiters = ('=',),\\n\\tcomment_prefixes = ('#', ';'),\\n\\tdefault_section = 'default',\\n\\tallow_no_value = False,\\n\\tstrict = False,\\n\\tinterpolation = ExtendedInterpolation(),\\n\\tdefaults = {\\n\\t\\t'debug': False,\\n\\t\\t'datadir': path.join(path.expanduser('~'), '.local', 'rosshm'),\\n\\t\\t'log.level': 'warn',\\n\\t\\t'core.enable': True,\\n\\t\\t'db.driver': 'sqlite',\\n\\t\\t'db.name': 'rosshmdb',\\n\\t\\t'db.config': '',\\n\\t\\t'static.enable': True,\\n\\t\\t'web.enable': True,\\n\\t},\\n)\",\n \"def __init__(self, filename='', complement='', silent=True, config='config.txt'):\\n # load preferences\\n if config is not None:\\n if config == 'config.txt':\\n config = os.path.join(os.path.dirname(os.path.realpath(__file__)), config)\\n if Graph.CONFIG_GRAPH is not None and Graph.CONFIG_FILENAME == config:\\n self._config = Graph.CONFIG_GRAPH\\n else:\\n self._config = Graph(config, complement={'readas': 'database'},\\n config=None)\\n if self.CONFIG_FILENAME is None:\\n Graph.CONFIG_FILENAME = config\\n Graph.CONFIG_GRAPH = self._config\\n # actually load the file\\n self.reset(filename, complement=complement, silent=silent)\",\n \"def __init__(self, *args, **kwargs):\\r\\n super().__init__()\\r\\n self._cfg = ConfigDict() # current configuration\\r\\n self._default_config = ConfigDict() # default configuration\\r\\n self._temp_config = OrderedDict() # temporary configuration\\r\\n self._path = Path() # current configuration path\\r\\n self._default_path = Path() # default configuration path\\r\\n self._conversion_dict = None\\r\\n self._auto_cast = None\\r\\n self._write_flags = None\\r\\n self._force_load = None\\r\\n self._load_empty = None\\r\\n self._ask_path = None\\r\\n self._search_in_default_config = None\\r\\n self._init_count = 0\\r\\n self._policies = defaultdict(bool) # by default every modification is forbidden # WIP\\r\\n if args or kwargs:\\r\\n self.init(*args, **kwargs)\\r\\n logger.debug(\\\"Config object created.\\\")\",\n \"def __init__(self, filename):\\n\\n parser = Parser(filename=filename)\\n self.uuid = parser.segregated(parser.read(),'UUID')\\n self.id = parser.segregated(parser.read(),'ID')\\n self.rate = parser.segregated(parser.read(),'RATE')\\n self.gpio = parser.segregated(parser.read(),'GPIO')\\n self.ddl = parser.segregated(parser.read(),'DATA_DELIVERY_LOCATION')\",\n \"def readConfigFile(self):\\n self.config_obj = ConfigParser.ConfigParser()\\n self.config_obj.readfp(open(self.configfile))\\n\\n # Set the log file\\n if (not self.args_obj.log_file and self.config_obj.has_option('DEFAULT','logfile')):\\n self.logfile = self.config_obj.get('DEFAULT', 'logfile')\\n\\n # Set the baud rate\\n if (not self.args_obj.baud_rate and self.config_obj.has_option('DEFAULT','baud')):\\n self.baudrate = self.config_obj.get('DEFAULT', 'baud')\\n\\n # Set the device port \\n if (not self.args_obj.device and self.config_obj.has_option('DEFAULT','device')):\\n self.device = self.config_obj.get('DEFAULT', 'device')\\n\\n # Set the connection timeout\\n if (not self.args_obj.timeout and self.config_obj.has_option('DEFAULT','timeout')):\\n self.timeout = self.config_obj.get('DEFAULT','timeout')\\n\\n if DEBUG:\\n print('(DEBUG) Config Options:')\\n self.pp.pprint(self.config_obj.sections())\",\n \"def __init__(self, filename=None, use_argv=True):\\n self._init_filename = filename\\n if use_argv:\\n self.options, self.args = [self.get_parser().parse_args()] * 2\\n else:\\n self.options = self.args = None\\n self._wrapped = self.load(file=self.settings_file)\\n # build a special dynamic section for things the user wants,\\n # ie, things that have been passed into the option\\n # parser but are not useful in the .ini\\n if not self.get_section('user'):\\n self['user'] = {}\\n if self.options is not None:\\n self['user']['shell'] = self.options.shell and 'true' or ''\\n else:\\n self['user']['shell'] = ''\",\n \"def __init__ (self, fileName : String):\\n\\n Logging.trace(\\\">>: %r\\\", fileName)\\n\\n self._keyToValueMap = {}\\n self._keyToStringValueMap = {}\\n visitedFileNameSet = set()\\n lineList = []\\n isOkay = self._readFile(\\\"\\\", fileName, lineList, visitedFileNameSet)\\n self._parseConfiguration(lineList)\\n\\n Logging.trace(\\\"<<: %s\\\",\\n _reprOfStringToValueMap(self._keyToValueMap))\",\n \"def __init__(self):\\n\\n # open json config file that reads in information\\n config_path = open(\\\"config.json\\\", \\\"r\\\")\\n config_json = config_path.read()\\n config_dict = json.loads(config_json)\\n\\n # assign object variables\\n self.project_id = config_dict[\\\"project-id\\\"]\\n self.bucket_name = config_dict[\\\"bucket-name\\\"]\\n self.location_id = config_dict[\\\"key-location\\\"]\\n self.key_ring_id = config_dict[\\\"key-ring-id\\\"]\\n self.crypto_key_id = config_dict[\\\"crypto-key-id\\\"]\\n self.service_account_email = config_dict[\\\"service-account-email\\\"]\\n\\n # close the file\\n config_path.close()\",\n \"def __init__(self):\\n self.options, self.args = self.get_parser().parse_args()\\n\\n # special case\\n self.done=False\\n if self.options.encode:\\n print generate_password_hash(self.options.encode)\\n self.doit()\\n self.done=True\\n return\\n\\n self._settings = {}\\n if self.options.config:\\n _file = self.options.config\\n else:\\n report(\\\"You did not pass in a config file with --config, assuming you want %s\\\"%self.default_file)\\n _file = self.default_file\\n self._settings.update(self.load(file=_file))\\n\\n # a few command line options are allowed to override the .ini\\n if self.options.port:\\n self._settings.update({'flask.port':self.options.port})\\n\\n # build a special section for things the user wants,\\n # ie, things that have been passed into the option\\n # parser but are not useful in the .ini\\n self._settings.update({'user.shell' : self.options.shell and 'true' or ''})\\n self._settings.update({'user.encode_password':self.options.encode})\\n def prepare(k,v):\\n \\\"\\\"\\\" allow pythonic comments in the .ini files,\\n and strip any trailing whitespace.\\n\\n TODO: move this to ConfigParser subclass.\\n \\\"\\\"\\\"\\n self._settings[k]=v.strip()\\n if '#' in v:\\n self._settings[k]=v[:v.find('#')]\\n\\n [ prepare(k,v) for k,v in self._settings.items() ]\\n\\n self.doit()\",\n \"def __init__(self):\\n\\t\\tConfigFile.__init__(self)\\n\\t\\tself.created_by = None\\n\\t\\tself.created_on = None\\n\\t\\tself.definition = None\\n\\t\\tself.note = None\\n\\t\\tself.rejected_by = None\\n\\t\\tself.rejected_on = None\\n\\t\\tself.replaced_by = None\\n\\t\\tself.status = 'elaboration'\\n\\t\\tself.status_reason = None\\n\\t\\tself.term = None\\n\\t\\tself.todo = None\\n\\t\\tself._valid_file_extension = 'def'\",\n \"def __init__(self, custom_file=None):\\n self.home = os.path.abspath(os.path.expanduser('~'))\\n # Static Defaults\\n defaults = \\\\\\n {\\n 'cfg_sn_username' : '',\\n 'cfg_sn_password' : '',\\n 'cfg_nt_ext' : 'txt',\\n 'cfg_nt_path' : os.path.join(self.home, 'Simplenote'),\\n 'cfg_nt_trashpath' : '.trash',\\n 'cfg_nt_filenamelen' : '60',\\n 'cfg_log_level' : 'info'\\n }\\n\\n cp = configparser.SafeConfigParser(defaults)\\n if custom_file is not None:\\n self.configs_read = cp.read([custom_file])\\n else:\\n self.configs_read = cp.read([os.path.join(self.home, '.snsync')])\\n\\n cfg_sec = 'snsync'\\n\\n if not cp.has_section(cfg_sec):\\n cp.add_section(cfg_sec)\\n\\n self.configs = collections.OrderedDict()\\n\\n #\\n # Environment Varialbles over-ride config file settings.\\n # Config files are cfg_abc\\n # Envs are sn_abc\\n #\\n\\n if os.environ.get('sn_username') is None:\\n val_sn_username = cp.get(cfg_sec, 'cfg_sn_username', raw=True)\\n else:\\n val_sn_username = os.environ.get('sn_username')\\n self.configs['sn_username'] = [val_sn_username, 'Simplenote Username']\\n\\n if os.environ.get('sn_password') is None:\\n val_sn_passowrd = cp.get(cfg_sec, 'cfg_sn_password', raw=True)\\n else:\\n val_sn_passowrd = os.environ.get('sn_password')\\n self.configs['sn_password'] = [val_sn_passowrd, 'Simplenote Password']\\n\\n if os.environ.get('sn_nt_ext') is None:\\n val_sn_nt_ext = cp.get(cfg_sec, 'cfg_nt_ext')\\n else:\\n val_sn_nt_ext = os.environ.get('sn_nt_ext')\\n self.configs['cfg_nt_ext'] = [val_sn_nt_ext, 'Note file extension']\\n\\n if os.environ.get('sn_nt_path') is None:\\n val_sn_nt_path = cp.get(cfg_sec, 'cfg_nt_path')\\n else:\\n val_sn_nt_path = os.environ.get('sn_nt_path')\\n self.configs['cfg_nt_path'] = [val_sn_nt_path, 'Note storage path']\\n\\n if os.environ.get('sn_nt_trashpath') is None:\\n val_sn_nt_trashpath = cp.get(cfg_sec, 'cfg_nt_trashpath')\\n else:\\n val_sn_nt_trashpath = os.environ.get('sn_nt_trashpath')\\n self.configs['cfg_nt_trashpath'] = [val_sn_nt_trashpath, 'Note Trash Bin Folder for deleted notes']\\n\\n if os.environ.get('sn_nt_filenamelen') is None:\\n val_sn_nt_filenamelen = cp.get(cfg_sec, 'cfg_nt_filenamelen')\\n else:\\n val_sn_nt_filenamelen = os.environ.get('sn_nt_filenamelen')\\n self.configs['cfg_nt_filenamelen'] = [val_sn_nt_filenamelen, 'Length of Filename']\\n\\n if os.environ.get('sn_log_level') is None:\\n val_sn_log_level = cp.get(cfg_sec, 'cfg_log_level')\\n else:\\n val_sn_log_level = os.environ.get('sn_log_level')\\n self.configs['cfg_log_level'] = [val_sn_log_level, 'snsync log level']\\n\\n # Dynamic Defaults\\n if os.environ.get('sn_db_path') is None:\\n if cp.has_option(cfg_sec, 'cfg_db_path'):\\n val_sn_db_path = cp.get(cfg_sec, 'cfg_db_path')\\n else:\\n val_sn_db_path = os.path.join(cp.get(cfg_sec, 'cfg_nt_path'), '.snsync.sqlite')\\n else:\\n val_sn_db_path = os.environ.get('sn_db_path')\\n self.configs['cfg_db_path'] = [val_sn_db_path, 'snsync database location']\\n\\n if os.environ.get('sn_log_path') is None:\\n if cp.has_option(cfg_sec, 'cfg_log_path'):\\n val_sn_log_path = cp.get(cfg_sec, 'cfg_log_path')\\n else:\\n val_sn_log_path = os.path.join(cp.get(cfg_sec, 'cfg_nt_path'), '.snsync.log')\\n else:\\n val_sn_log_path = os.environ.get('sn_log_path')\\n self.configs['cfg_log_path'] = [val_sn_log_path, 'snsync log location']\",\n \"def __init__(self, int_conf_file):\\n self.fname = int_conf_file\\n with open(int_conf_file) as fin:\\n self.cfg = cfg = json.load(fin)\\n self.probes = cfg['all_probes']\\n self.state = None\\n self.queue = None\\n self.notifiers = {}\\n self.notif_cfg = cfg.get('notifiers', [])\\n self.users = users = cfg.get('users') or {}\\n for name, userinfo in users.items():\\n if 'name' not in userinfo:\\n userinfo['name'] = name\",\n \"def load_config(self, config_file):\\n self.config = ConfigParser.ConfigParser()\\n self.config.read(config_file)\",\n \"def __init__(self,filename):\\n\\n\\t\\tself.filename = filename\",\n \"def __init__(self, fileName = \\\"netspy.conf\\\"):\\n\\t\\tself.options = {'port' : '', 'server_port' : '', 'server_ip': '', 'service_list': [] }\\n\\t\\tself.fileName = fileName\\n\\t\\tself.loadFromFile(self.fileName)\",\n \"def build_config_parser(filename='GradientOneAuthConfig.txt'):\\n cfg = ConfigParser(dict_type=dict)\\n cfg.optionxform = str\\n cfgfile = None\\n try:\\n cfgfile = find_file(filename)\\n except IOError:\\n raise ValueError(\\\"Could not find a {} file. Please download \\\"\\n \\\"one for this machine.\\\".format(filename))\\n try:\\n cfg.read(cfgfile)\\n except IOError:\\n raise ValueError(\\\"Could not read the {} file. Please download a \\\"\\n \\\"valid config file for this machine.\\\"\\n .format(filename))\\n return cfg\",\n \"def create_from_config_file(cls, filename: str):\\n return cls(load_yaml_config(filename))\",\n \"def __init__(self, filepath):\\n self.filepath = filepath\",\n \"def __init__(self, *args, **kwargs):\\n # This is a non-positional argument parser that can be used for\\n # --config processing\\n self.parser = argparse.ArgumentParser(*args, **kwargs)\\n self.parser.add_argument(\\\"--config\\\", metavar=\\\"FILE\\\",\\n help=\\\"specify a configuration file\\\")\\n self.parser.add_argument(\\\"--log\\\", metavar=\\\"FILE\\\",\\n help=\\\"specify a log file\\\")\\n self.parser.add_argument(\\\"--log-level\\\", metavar=\\\"LEVEL\\\",\\n choices=[\\\"DEBUG\\\", \\\"INFO\\\", \\\"WARNING\\\", \\\"ERROR\\\",\\n \\\"CRITICAL\\\"],\\n default=\\\"INFO\\\",\\n help=\\\"{DEBUG,INFO,WARNING,ERROR,CRITICAL} \\\"\\n \\\"(default=INFO)\\\")\\n\\n # Save in case they are needed for reinitialization\\n self.kwargs = kwargs\\n self.kwargs['add_help'] = False\\n self.kwargs['parents'] = [self.parser]\\n argparse.ArgumentParser.__init__(self, *args, **self.kwargs)\",\n \"def __init__(self, filename):\\n self.filename = filename\",\n \"def __init__(self):\\n with open('config.json', encoding='UTF-8') as json_data_file:\\n self.config = json.load(json_data_file)\\n self._get_credential()\\n self.file_tree = [{}] * 100\",\n \"def __init__(self, cooper_config_file):\\n\\t\\t# Determine if the default config file will be used or a user-defined file\\n\\t\\ttry:\\n\\t\\t\\tif cooper_config_file is None:\\n\\t\\t\\t\\tprint(\\\"[+] Using the default config file: {}\\\".format(self.cooper_config_file))\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.cooper_config_file = cooper_config_file\\n\\t\\t\\t\\tprint(\\\"[+] Alternate config file identified: {}\\\".format(self.cooper_config_file))\\n\\t\\texcept Exception as err:\\n\\t\\t\\tprint(\\\"[!] \\\")\\n\\t\\t\\tprint(\\\"L.. Details: {}\\\".format())\\n\\t\\t# Open the config file for parsing\\n\\t\\ttry:\\n\\t\\t\\tself.config_parser = configparser.ConfigParser()\\n\\t\\t\\tself.config_parser.read(self.cooper_config_file)\\n\\t\\texcept Exception as err:\\n\\t\\t\\tprint(\\\"[!] Could not open the config file -- make sure it exists and is readable.\\\")\\n\\t\\t\\tprint(\\\"L.. Details: {}\\\".format(err))\\n\\t\\t# Parse the config file's values\\n\\t\\ttry:\\n\\t\\t\\tself.landing_page_url_replacement = self.config_section_map(\\\"Replacement URLs\\\")[\\\"landing_page_url_replacement\\\"]\\n\\t\\t\\tself.landing_page_form_action = self.config_section_map(\\\"Replacement URLs\\\")[\\\"landing_page_form_action\\\"]\\n\\t\\t\\tself.email_replacement_url = self.config_section_map(\\\"Replacement URLs\\\")[\\\"email_replacement_url\\\"]\\n\\t\\t\\tself.email_tracker_url = self.config_section_map(\\\"Replacement URLs\\\")[\\\"email_tracker_url\\\"]\\n\\t\\t\\tself.path_to_chromedriver = self.config_section_map(\\\"Browser\\\")[\\\"driver_path\\\"]\\n\\t\\t\\tif self.config_section_map(\\\"Browser\\\")[\\\"user_agent\\\"] == \\\"\\\":\\n\\t\\t\\t\\tself.user_agent = \\\"(Mozilla/5.0 (Windows; U; Windows NT 6.0;en-US; rv:1.9.2) Gecko/20100115 Firefox/3.6\\\"\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.user_agent = self.config_section_map(\\\"Browser\\\")[\\\"user_agent\\\"]\\n\\t\\texcept Exception as err:\\n\\t\\t\\tprint(\\\"[!] Failed to read all values from the config file! Exiting...\\\")\\n\\t\\t\\tprint(\\\"L.. Details: {}\\\".format(err))\\n\\t\\t\\tsys.exit()\",\n \"def __init__(self, appname):\\n self.exepath = '%s' % (os.path.dirname(os.path.realpath(__file__)))\\n self.cnfgfile = '%s/versions.cfg' % self.exepath\\n self.static_path = '%s/app/static' % self.exepath\\n self.config = ConfigParser.RawConfigParser()\",\n \"def __init__(self, filename):\\r\\n self._results = SpecParser(filename).parse()\",\n \"def __init__(self, filename):\\n self._filename = filename\\n pass\",\n \"def __init__(self, mbox_file, configs):\\n self.filename = mbox_file\\n if os.path.isfile(mbox_file):\\n self.mbox = mailbox.mbox(mbox_file)\\n else:\\n raise IOError(\\\"Can't find that file\\\")\\n\\n self.config = dict()\\n cfg_file = file(configs, 'r')\\n for line in cfg_file:\\n if line[0] != '#':\\n parsed = line.strip().split(\\\"=\\\")\\n if len(parsed) != 2:\\n raise ValueError(\\\"Bad config file.\\\")\\n else:\\n self.config[parsed[0]] = parsed[1]\\n self.messages = list()\",\n \"def init_config(filename):\\n config = configparser.ConfigParser()\\n try:\\n with open(filename, 'r') as config_file:\\n config.read(config_file)\\n except EnvironmentError:\\n print(\\\"FATAL ERROR: Failed to open config file at \\\" + filename)\\n sys.exit(1)\\n return config\",\n \"def __init__(self, conf=None):\\n # set interpolation to None so you can supply filename template\\n # that contain % to config.set\\n conf = ConfigParser(strict=False,\\n inline_comment_prefixes=(';',),\\n interpolation=None) if (conf is None) else conf\\n super().__init__(conf)\\n self._cycle = None\\n self._logger = logging.getLogger('metplus')\\n # config.logger is called in wrappers, so set this name\\n # so the code doesn't break\\n self.logger = self._logger\\n\\n # get the OS environment and store it\\n self.env = os.environ.copy()\\n\\n # add section to hold environment variables defined by the user\\n self.add_section('user_env_vars')\",\n \"def __init__(self, cfg=None, **kwargs):\\n self.__dir = KITConfig.configDir\\n self.__cfgFile = \\\"\\\"\\n\\n self.__cfg = {}\\n self.__default = KITConfig.defaultConfig\\n\\n self.__setupLogger()\\n\\n if cfg is not None:\\n self.__cfgFile = cfg\\n self.load(cfg)\",\n \"def __init__(self, config_path: str = \\\"config.json\\\"):\\n # Change here if you want to relocate you config file\\n self.config = {}\\n self.load_configuration(config_path)\\n self.app_name = self.config.get('app_name', self.APP_NAME)\",\n \"def __init__(self, filename, registry):\\n self.filename = filename\\n self.registry = registry\",\n \"def __init__(self, filename):\\r\\n\\r\\n self.filename = filename\",\n \"def __init__(self, settings_file_name):\\n with open(settings_file_name, 'r') as f:\\n # load config file\\n self.settings = yaml.load(f)\\n\\n # get key values\\n sit_names = self.settings[HNF.Consts.SIT_NAMES]\\n row_action_names = self.settings[HNF.Consts.ROW_ACT_NAMES]\\n column_action_names = self.settings[HNF.Consts.COL_ACT_NAMES]\\n name = self.settings[HNF.Consts.NAME]\\n\\n # init HNG object\\n self.HNFOut = HNF.HNFInstance(sit_names, row_action_names, column_action_names, name)\\n\\n # set the values found in the settings\\n self.__initFromFile()\\n\\n # calc the summary and expected utility\\n self.HNFOut.initSummaryBelief()\\n self.HNFOut.initExpectedUtility()\\n self.HNFOut.calcHypergameExpectedUtility()\\n self.HNFOut.calcModelingOpponentUtility()\",\n \"def __init__(self, filename=None):\\n if filename:\\n dict.__init__(self, self.read_file(filename))\\n else:\\n dict.__init__(self)\\n self.new_plist()\",\n \"def __init__(self, filename=None):\\n self._filename = filename\",\n \"def __init__(self, filename):\\n self.from_file(filename)\\n self.parse_cell()\\n self.parse_atom()\\n self.apply_symops()\",\n \"def __init__(self, cfg_path):\\n\\t\\tself.cfg_path = cfg_path\\n\\t\\tself.cfg_root = self.load_cfg(self.cfg_path)\",\n \"def __init__(self):\\n if not os.path.isfile(CONFIG_FILENAME):\\n first_time_run()\\n raise SystemExit()\\n\\n \\\"\\\"\\\"\\n Init file is present, read and parse it:\\n \\\"\\\"\\\"\\n conf = configparser.ConfigParser(interpolation=configparser.ExtendedInterpolation(), inline_comment_prefixes='#')\\n conf.read(CONFIG_FILENAME)\\n \\\"\\\"\\\"\\n Process certain paths:\\n \\\"\\\"\\\"\\n\\n path = conf['Paths']\\n self.ffc_dir = path['FlatFieldCalDir']\\n self.capture_dir = path['CaptureDir']\\n self.image_dir = path['ImageDir']\\n\\n \\\"\\\"\\\"\\n Process options\\n \\\"\\\"\\\"\\n\\n self.cal_auto_save = conf.getboolean('Options', 'CalAutoSave', fallback=True)\\n self.cal_auto_load = conf.getboolean('Options', 'CalAutoLoad', fallback=True)\\n self.sound_on_capture = conf.getboolean('Options', 'SoundOnCapture', fallback=True)\\n self.exp_init1 = conf.getint('Options', 'ExpInit1', fallback=100)\\n self.exp_init2 = conf.getint('Options', 'ExpInit2', fallback=100)\\n self.black_correct = conf.getboolean('Options', 'BlackCorrect', fallback=True)\\n # Setup square window, default of full-screen height\\n self.tiff_seq_x_window = conf.getint('Options', 'TiffSeqXWindow', fallback=cameras.FRAME_HEIGHT)\\n self.tiff_seq_y_window = conf.getint('Options', 'TiffSeqYWindow', fallback=cameras.FRAME_HEIGHT)\\n self.tiff_seq_rebin = conf.getint('Options', 'TiffSeqRebin', fallback = 2)\",\n \"def __init__(self):\\n self.storefn = Config.getConfigFnPath()\\n\\n # Load the configuration file file\\n self.load()\",\n \"def __init__(self, environment):\\n with open('config.json') as f:\\n self.config = eval(f.read())\\n self.config = self.config[environment]\",\n \"def __init__(self, config):\\n\\n self.root = config.root\\n self.pidfile = config.pidfile\\n self.log_conf = config.logging\",\n \"def _get_config(self, unit, filename):\\n file_contents = unit.file_contents(filename)\\n config = ConfigParser.ConfigParser()\\n config.readfp(io.StringIO(file_contents))\\n return config\",\n \"def __init__(self, config_path, normalize=False):\\n self.config = {}\\n _config_dict = {}\\n self._config_path = Utils.expand_path(config_path)\\n self.update = None\\n self.normalize = normalize\",\n \"def load_configuration(self) -> None:\\n config_file = self.default_config_file\\n if self.config_file:\\n config_file = self.config_file\\n self.config = configparser.ConfigParser(delimiters=\\\"=\\\")\\n # mypy is unhappy with us assigning to a method - (monkeypatching?)\\n self.config.optionxform = lambda option: option # type: ignore\\n self.config.read(config_file)\",\n \"def __init__(self, configfile='settings.cfg'):\\n \\n self.configfile = configfile\\n \\n # Load parameters from config file\\n config = ConfigParser.RawConfigParser()\\n config.read(self.configfile)\\n \\n # Set parameters to default if not in config file \\n self.title=config.get('Settings','title') if config.has_option(\\n 'Settings','title') else 'REDPy Catalog'\\n self.filename=config.get('Settings','filename') if config.has_option(\\n 'Settings','filename') else 'redpytable.h5'\\n self.groupName=config.get('Settings','groupName') if config.has_option(\\n 'Settings','groupName') else 'default'\\n self.groupDesc=config.get('Settings','groupDesc') if config.has_option(\\n 'Settings','groupDesc') else 'Default Test Run'\\n self.nsta=config.getint('Settings','nsta') if config.has_option(\\n 'Settings','nsta') else 8 \\n self.station=config.get('Settings','station') if config.has_option(\\n 'Settings','station') else 'SEP,YEL,HSR,SHW,EDM,STD,JUN,SOS'\\n self.channel=config.get('Settings','channel') if config.has_option(\\n 'Settings','channel') else 'EHZ,EHZ,EHZ,EHZ,EHZ,EHZ,EHZ,EHZ'\\n self.network=config.get('Settings','network') if config.has_option(\\n 'Settings','network') else 'UW,UW,UW,UW,UW,UW,UW,UW'\\n self.location=config.get('Settings','location') if config.has_option(\\n 'Settings','location') else '--,--,--,--,--,--,--,--'\\n self.samprate=config.getfloat('Settings','samprate') if config.has_option(\\n 'Settings','samprate') else 100.\\n self.nstaC=config.getint('Settings','nstaC') if config.has_option(\\n 'Settings','nstaC') else 5\\n self.printsta=config.getint('Settings','printsta') if config.has_option(\\n 'Settings','printsta') else 2\\n self.server=config.get('Settings','server') if config.has_option(\\n 'Settings','server') else 'IRIS'\\n self.port=config.getint('Settings','port') if config.has_option(\\n 'Settings','port') else 16017\\n self.nsec=config.getint('Settings','nsec') if config.has_option(\\n 'Settings','nsec') else 3600\\n self.lwin=config.getfloat('Settings','lwin') if config.has_option(\\n 'Settings','lwin') else 7.\\n self.swin=config.getfloat('Settings','swin') if config.has_option(\\n 'Settings','swin') else 0.8\\n self.trigon=config.getfloat('Settings','trigon') if config.has_option(\\n 'Settings','trigon') else 3.\\n self.trigoff=config.getfloat('Settings','trigoff') if config.has_option(\\n 'Settings','trigoff') else 2.\\n self.kurtmax=config.getfloat('Settings','kurtmax') if config.has_option(\\n 'Settings','kurtmax') else 80.\\n self.kurtfmax=config.getfloat('Settings','kurtfmax') if config.has_option(\\n 'Settings','kurtfmax') else 150.\\n self.oratiomax=config.getfloat('Settings','oratiomax') if config.has_option(\\n 'Settings','oratiomax') else 0.06\\n self.kurtwin=config.getfloat('Settings','kurtwin') if config.has_option(\\n 'Settings','kurtwin') else 5.\\n self.winlen=config.getint('Settings','winlen') if config.has_option(\\n 'Settings','winlen') else 1024\\n self.fmin=config.getfloat('Settings','fmin') if config.has_option(\\n 'Settings','fmin') else 1.\\n self.fmax=config.getfloat('Settings','fmax') if config.has_option(\\n 'Settings','fmax') else 10.\\n self.filomin=config.getfloat('Settings','filomin') if config.has_option(\\n 'Settings','filomin') else 1.\\n self.filomax=config.getfloat('Settings','filomax') if config.has_option(\\n 'Settings','filomax') else 2.5\\n self.fiupmin=config.getfloat('Settings','fiupmin') if config.has_option(\\n 'Settings','fiupmin') else 5.\\n self.fiupmax=config.getfloat('Settings','fiupmax') if config.has_option(\\n 'Settings','fiupmax') else 10.\\n self.telefi=config.getfloat('Settings','telefi') if config.has_option(\\n 'Settings','telefi') else -1.\\n self.teleok=config.getint('Settings','teleok') if config.has_option(\\n 'Settings','teleok') else 1 \\n self.cmin=config.getfloat('Settings','cmin') if config.has_option(\\n 'Settings','cmin') else 0.7\\n self.ncor=config.getint('Settings','ncor') if config.has_option(\\n 'Settings','ncor') else 4\\n self.minorph=config.getfloat('Settings','minorph') if config.has_option(\\n 'Settings','minorph') else 0.05\\n self.maxorph=config.getfloat('Settings','maxorph') if config.has_option(\\n 'Settings','maxorph') else 7.\\n self.minplot=config.getint('Settings','minplot') if config.has_option(\\n 'Settings','minplot') else 3\\n self.dybin=config.getfloat('Settings','dybin') if config.has_option(\\n 'Settings','dybin') else 1.\\n self.hrbin=config.getfloat('Settings','hrbin') if config.has_option(\\n 'Settings','hrbin') else 1.\\n self.recplot=config.getfloat('Settings','recplot') if config.has_option(\\n 'Settings','recplot') else 14.\\n \\n # Derived Settings\\n self.ptrig=1.5*self.winlen/self.samprate\\n self.atrig=3*self.winlen/self.samprate\\n self.mintrig=self.winlen/self.samprate\\n self.wshape = int((self.ptrig + self.atrig)*self.samprate) + 1\",\n \"def __init__(self, path_to_the_file):\",\n \"def __init__(self, path_to_the_file):\",\n \"def initialize_from_config(self):\",\n \"def __init__(self, defaults=None):\\n self._configFileName = None\\n if defaults is None:\\n self._defaults = ConfigDict()\\n else:\\n self._defaults = ConfigDict(copy.deepcopy(defaults))\\n self.importedFiles = []\\n self.includedFiles = []\\n self.missingFiles = []\",\n \"def __init__(self, environment='develop'):\\n\\n cwd = path.dirname(path.abspath(__file__))\\n config_dir = path.join(cwd, 'configs')\\n\\n config_files = []\\n for (root, _, file_names) in walk(config_dir):\\n for file_name in file_names:\\n config_files.append(path.join(root, file_name))\\n config_files = sorted(config_files)\\n\\n for config_file in config_files:\\n config = anyconfig.load(config_file)\\n for key in config:\\n self[key] = config[key]\\n\\n if environment in config_file:\\n break\",\n \"def __init__(self, filename=None):\\n self.content = dict()\\n if filename and os.path.exists(filename):\\n self.parse(filename)\\n elif filename:\\n self.new(filename)\",\n \"def __init__(self, config: str) -> None:\\n self.configuration = config\",\n \"def __init__(self, config: str) -> None:\\n self.configuration = config\",\n \"def read_config(self, config_filename):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8556377","0.8332688","0.83071285","0.83033603","0.80947435","0.80304974","0.79447347","0.7944664","0.7938114","0.79321945","0.7806958","0.77945864","0.7792556","0.777831","0.7728286","0.7725837","0.77198017","0.7715732","0.7694171","0.768226","0.76366454","0.7546511","0.75385946","0.75208086","0.74739563","0.74458665","0.73782194","0.73237413","0.7302583","0.72780174","0.72639775","0.7252057","0.72406894","0.7188388","0.71810293","0.7151967","0.713625","0.71339357","0.7132767","0.7095283","0.7095253","0.70670336","0.7056573","0.70538825","0.7051931","0.7040554","0.70366794","0.7032364","0.7027211","0.7008821","0.7001761","0.69970655","0.6974757","0.6970606","0.69627404","0.6956133","0.69378626","0.693469","0.6905583","0.6901588","0.6898062","0.6897036","0.68939626","0.68938994","0.6881193","0.6867148","0.6865259","0.6853059","0.68496436","0.6843709","0.6839659","0.68377066","0.6837166","0.68365985","0.68356586","0.6830307","0.68239677","0.68226403","0.68214494","0.6821217","0.68175465","0.6813035","0.68124145","0.6788772","0.6775822","0.6774666","0.6761457","0.67582625","0.6744345","0.67383134","0.6724691","0.6720834","0.6720834","0.6708601","0.67050993","0.6700591","0.6695053","0.6688623","0.6688623","0.6687822"],"string":"[\n \"0.8556377\",\n \"0.8332688\",\n \"0.83071285\",\n \"0.83033603\",\n \"0.80947435\",\n \"0.80304974\",\n \"0.79447347\",\n \"0.7944664\",\n \"0.7938114\",\n \"0.79321945\",\n \"0.7806958\",\n \"0.77945864\",\n \"0.7792556\",\n \"0.777831\",\n \"0.7728286\",\n \"0.7725837\",\n \"0.77198017\",\n \"0.7715732\",\n \"0.7694171\",\n \"0.768226\",\n \"0.76366454\",\n \"0.7546511\",\n \"0.75385946\",\n \"0.75208086\",\n \"0.74739563\",\n \"0.74458665\",\n \"0.73782194\",\n \"0.73237413\",\n \"0.7302583\",\n \"0.72780174\",\n \"0.72639775\",\n \"0.7252057\",\n \"0.72406894\",\n \"0.7188388\",\n \"0.71810293\",\n \"0.7151967\",\n \"0.713625\",\n \"0.71339357\",\n \"0.7132767\",\n \"0.7095283\",\n \"0.7095253\",\n \"0.70670336\",\n \"0.7056573\",\n \"0.70538825\",\n \"0.7051931\",\n \"0.7040554\",\n \"0.70366794\",\n \"0.7032364\",\n \"0.7027211\",\n \"0.7008821\",\n \"0.7001761\",\n \"0.69970655\",\n \"0.6974757\",\n \"0.6970606\",\n \"0.69627404\",\n \"0.6956133\",\n \"0.69378626\",\n \"0.693469\",\n \"0.6905583\",\n \"0.6901588\",\n \"0.6898062\",\n \"0.6897036\",\n \"0.68939626\",\n \"0.68938994\",\n \"0.6881193\",\n \"0.6867148\",\n \"0.6865259\",\n \"0.6853059\",\n \"0.68496436\",\n \"0.6843709\",\n \"0.6839659\",\n \"0.68377066\",\n \"0.6837166\",\n \"0.68365985\",\n \"0.68356586\",\n \"0.6830307\",\n \"0.68239677\",\n \"0.68226403\",\n \"0.68214494\",\n \"0.6821217\",\n \"0.68175465\",\n \"0.6813035\",\n \"0.68124145\",\n \"0.6788772\",\n \"0.6775822\",\n \"0.6774666\",\n \"0.6761457\",\n \"0.67582625\",\n \"0.6744345\",\n \"0.67383134\",\n \"0.6724691\",\n \"0.6720834\",\n \"0.6720834\",\n \"0.6708601\",\n \"0.67050993\",\n \"0.6700591\",\n \"0.6695053\",\n \"0.6688623\",\n \"0.6688623\",\n \"0.6687822\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.792374"},"document_rank":{"kind":"string","value":"10"}}},{"rowIdx":9098,"cells":{"query":{"kind":"string","value":"set_property(self, prop_name, prop_value) Set a config property to a new value. Checks to ensure that prop_name refers to a valid property, and prop_value is a valid value for that property"},"document":{"kind":"string","value":"def set_property(self, prop_name, prop_value):\n if prop_name == \"database_name\":\n if (prop_value and isinstance(prop_value, str)\n and prop_value[-3:] == \".db\"):\n self.config[\"config\"][\"database_name\"] = prop_value\n self.database_name = prop_value\n elif prop_name == \"volume_limit\":\n if isinstance(prop_value, int) and prop_value > 0:\n self.config[\"config\"][\"volume_limit\"] = str(prop_value)\n self.volume_limit = prop_value\n elif prop_name == \"series_per_page\":\n if isinstance(prop_value, int) and prop_value >= 0:\n self.config[\"config\"][\"series_per_page\"] = str(prop_value)\n self.series_per_page = prop_value\n elif prop_name == \"compact_list\":\n if ((isinstance(prop_value, int) and prop_value in [0, 1])\n or isinstance(prop_value, bool)):\n self.config[\"config\"][\"compact_list\"] = str(prop_value)\n self.compact_list = prop_value\n elif prop_name == \"show_empty_series\":\n if ((isinstance(prop_value, int) and prop_value in [0, 1])\n or isinstance(prop_value, bool)):\n self.config[\"config\"][\"show_empty_series\"] = str(prop_value)\n self.show_empty_series = prop_value\n elif prop_name == \"default_to_gui\":\n if ((isinstance(prop_value, int) and prop_value in [0, 1])\n or isinstance(prop_value, bool)):\n self.config[\"config\"][\"default_to_gui\"] = str(prop_value)\n self.default_to_gui = prop_value\n with open(self.filename, 'w') as config_ini:\n self.config.write(config_ini)"},"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 SetProp(self, name, value):\n self._props[name] = value\n self._changed(name, value)","def set_prop(prop, value, config_type=\"\", config_path=\"\"):\n\n path = get_config_path(config_type, config_path)\n set_property_value(prop, value, path)","def set_property(self, name, value):\n self.properties[name] = value","def do_set_property(self, spec, value):\n attribute = self.find_attribute(spec.name)\n if attribute is not None and isinstance(attribute, property):\n attribute.fset(self, value)\n else:\n raise ValueError(\"No such property\", spec.name)","def set_property(self, key, value):\n if not key:\n raise Exception('A key should be provided.')\n if not value:\n raise Exception('A value should be provided.')\n self._properties[key] = value","def setprop(name, value):\n _slp.setprop(name, value)","def set_property(self, name, prop_name, prop_value, ignore_items=False):\n valid_props = ['base_text', '_no_valid_items', '_no_valid_values']\n if prop_name not in valid_props:\n raise ValueError(\"'prop_name' must be one of {}\".format(valid_props))\n self._set_property(name, prop_name, prop_value, ignore_items)\n return None","def SetProperty(self, propertyname, value):\n if self.serviceimplementation == 'basic':\n flag = self.vbLet\n if isinstance(value, datetime.datetime):\n value = SFScriptForge.SF_Basic.CDateToUnoDateTime(value)\n flag += self.flgDateArg\n if repr(type(value)) == \"<class 'pyuno'>\":\n flag += self.flgUno\n return self.EXEC(self.objectreference, flag, propertyname, value)","def set_role_property(self, obj, property_name, property_value): # pylint: disable=no-self-use\n if isinstance(obj, dict):\n if 'properties' in obj:\n obj = obj['properties']\n obj[property_name] = property_value\n else:\n if hasattr(obj, 'properties'):\n obj = obj.properties\n obj.property_name = property_value","def setProp(self, name, value):\n ret = libxml2mod.xmlSetProp(self._o, name, value)\n if ret is None:raise treeError('xmlSetProp() failed')\n __tmp = xmlAttr(_obj=ret)\n return __tmp","def set_property_value(prop, value, path):\n\n if not isfile(path):\n raise ConfigFileNotCreatedException(path)\n\n content = \"\"\n updated = False\n\n try:\n with open(path, \"r+\") as f:\n for line in f:\n m = _search_pattern.search(line)\n\n if m:\n result = m.groupdict()\n\n # check if the found property matches with the wanted property\n if result[\"key\"] == prop:\n content += \"{}={}\\n\".format(prop, value)\n updated = True\n continue\n\n content += line\n\n # if the last character is a newline, remove it\n if len(content) and content[-1] == \"\\n\":\n content = content[:-1]\n\n # create a new entry if we property does not yet exist\n if not updated:\n content += \"\\n{}={}\".format(prop, value)\n\n # overwrite old config file content\n f.seek(0)\n f.truncate()\n f.write(content)\n except PermissionError:\n raise ConfigFilePermissionErrorException(path)","def set_user_property(self, property, value):\n self._user_properties.update({property: value})","def set(self, attr_name, value):\n\n get_logger().debug('Going to set XML attribute property: %s', attr_name)\n\n if self.textproperty is not None:\n # TODO: potentially programming error\n raise MarshallingError()\n\n try:\n # pylint: disable=unnecessary-dunder-call\n self.attributes[attr_name].__set__(self.obj, value)\n get_logger().debug('Set XML attribute property: %s', attr_name)\n except AttributeError as ex:\n get_logger().error('XML property %s: %s', attr_name, str(ex))\n except KeyError:\n get_logger().debug('Not an XML attribute property: %s', attr_name)","def set_property(self, key: str, value: Any):\n if not key:\n raise ValueError(\"Key is required\")\n\n if value is None:\n raise ValueError(\"Value is required\")\n\n self._node[\"app_data\"][\"properties\"][key] = value","def add_property(self, name, value=None):\n self.properties[name] = value","def set_property(key, value):\n return impl.set_property(**locals())","def set(self, database_name, property_, value):\n return isempty(self._send_command(database_name, \"%s=%s\" % (property_, value)))","def set_property(self, key, value):\n self.properties[key] = value\n return self.properties[key]","def prop_set(prop, value, extra_args=None, cibfile=None):\n return item_create(\n item=\"property\",\n item_id=\"{}={}\".format(prop, value),\n item_type=None,\n create=\"set\",\n extra_args=extra_args,\n cibfile=cibfile,\n )","def do_set_property(self, pspec, val):\n # FIXME: need an asynchronous API to set these properties,\n # particularly 'private'\n\n if pspec.name == 'name':\n self._name = val\n elif pspec.name == 'color':\n self._color = val\n elif pspec.name == 'tags':\n self._tags = val\n elif pspec.name == 'private':\n self._private = val\n else:\n raise ValueError('Unknown property %r', pspec.name)\n\n self._publish_properties()","def set_property(self, name, value, persist_changes=True):\n self._properties_metadata[name] = {'readonly': not persist_changes}\n self._properties[name] = value","def set_property(wellorcontainer, property_name, value):\n wells = convert_to_wellgroup(wellorcontainer)\n \n if not isinstance(value, str):\n value = str(value)\n \n for well in wells:\n assert isinstance(well, Well)\n well.properties[property_name] = value","def setDynamicProperty(self, widget, property_name, property_value):\n\n\t\twidget.setProperty(property_name, property_value)\n\t\twidget.style().unpolish(widget)\n\t\twidget.style().polish(widget)","def put_prop(self, obj_type, obj_id, prop_name, value):\n ierr = exolib.py_expp(self.exoid, obj_type, obj_id, prop_name, value)\n if ierr:\n raise ExodusIIWriterError(\"Error putting prop value\")","def addPropertie(self, propname, value):\n if isinstance(propname, types.IntType) or isinstance(propname, types.StringType):\n self.properties[propname] = value\n else:\n raise Exception(\"la propiedad debe ser de tipo int o string\")","def __setattr__(self, name, value):\n if self.serviceimplementation == 'basic':\n if name in ('serviceproperties', 'localProperties', 'internal_attributes', 'propertysynonyms',\n 'forceGetProperty'):\n pass\n elif name[0:2] == '__' or name in self.internal_attributes or name in self.localProperties:\n pass\n elif name in self.serviceproperties or name in self.propertysynonyms:\n if name in self.propertysynonyms: # Reset real name if argument provided in lower or camel case\n name = self.propertysynonyms[name]\n if self.internal: # internal = True forces property local setting even if property is read-only\n pass\n elif self.serviceproperties[name] is True: # True == Editable\n self.SetProperty(name, value)\n return\n else:\n raise AttributeError(\n \"type object '\" + self.objecttype + \"' has no editable property '\" + name + \"'\")\n else:\n raise AttributeError(\"type object '\" + self.objecttype + \"' has no property '\" + name + \"'\")\n object.__setattr__(self, name, value)\n return","def changeProperty(self, node, name, propertyName, value, setIfNotExist=False):","def set_property_value(self, name, value, dry_run=False):\n raise DAVError(\n HTTP_FORBIDDEN, err_condition=PRECONDITION_CODE_ProtectedProperty\n )","def set_property(self,obj_property,value):\n existing_properties = self.get_property(obj_property)\n if existing_properties is None:\n if type(value) == list:\n if len(value) == 1:\n self.redis_server.hset(self.frbr_key,\n obj_property,\n value[0])\n else:\n new_redis_key = \"%s:%s\" % (self.frbr_key,\n obj_property)\n for row in value:\n self.redis_server.sadd(new_redis_key,\n row)\n self.redis_server.hset(self.frbr_key,\n obj_property,\n new_redis_key)\n else:\n self.redis_server.hset(self.frbr_key,\n obj_property,\n value)","def setProperty(self, path, key, value):\n \n try:\n self._client.propset(key, value, self._workingCopyPath + path)\n self.checkin(path)\n except ClientError, error:\n raise SubversionError(error)","def add_property_setting(self, key, prop):\n\n setting = self.settings().new_property(key, prop)\n self._add_to_list_field(\"settings\", setting)","def run_setprop(self, expanded, unexpanded) :\n\t\toptions, args = self.getopt([\"name=\", \"value=\"], expanded)\n\t\tif (options is None) and (args is None) :\n\t\t\treturn -1\t# message was already displayed in self.getopt()\n\t\tif not args :\n\t\t\treturn self.errormessage(\"Needs at least one object to change this property\")\n\t\tif not (options.has_key(\"name\") and options.has_key(\"value\")) :\n\t\t\treturn self.errormessage(\"You must supply a property name and value\")\n\t\tproperty = options[\"name\"]\n\t\tif options.has_key(\"value\") :\n\t\t\tpropvalue = options[\"value\"]\n\t\t\ttry :\n\t\t\t\t# maybe it's a list in a string, e.g. \"['e', 'f']\"\n\t\t\t\t# or something like that\n\t\t\t\tnewvalue = eval(propvalue)\n\t\t\t\tif (type(newvalue) != type(0)) and (type(newvalue) != type(0.0)) :\n\t\t\t\t\t# we mustn't convert numeric to string\n\t\t\t\t\tpropvalue = newvalue\n\t\t\texcept NameError :\n\t\t\t\tpass\t# normal string\n\t\telse :\n\t\t\tpropvalue = \"\"\n\n\t\tstatus = 0\n\t\tfor arg in args :\n\t\t\tobject = self.toObject(self.__context, arg)\n\t\t\tif object is not None :\n\t\t\t\tif not self.HasPerms(object, 'Manage properties') :\n\t\t\t\t\tstatus = status - 1\n\t\t\t\telif hasattr(object, 'hasProperty') :\n\t\t\t\t\tif not object.hasProperty(property) :\n\t\t\t\t\t\tstatus = status + self.errormessage(\"Object %s has no property %s\" % (self.ObjectPath(object), property))\n\t\t\t\t\telse :\n\t\t\t\t\t\t# in the following lines the absence of a _updateProperty\n\t\t\t\t\t\t# attribute indicates an object without properties (e.g. a method)\n\t\t\t\t\t\t# which indicates an object for which setting properties is a nonsense\n\t\t\t\t\t\tif hasattr(object, \"_updateProperty\") :\n\t\t\t\t\t\t\tobject._updateProperty(property, propvalue)\n\t\t\t\t\t\t\tself.htmlmessage(\"Object %s property %s was modified to %s\" % (self.ObjectPath(object), property, str(propvalue)))\n\t\treturn status","def put_prop(self, obj_type, obj_id, prop_name, value):\n ierr = exolib.py_expp(self.exoid, obj_type, obj_id, prop_name, value)\n if ierr:\n raise ExodusIIWriterError(\"Error putting prop\")","def persist_cluster_config_environment_prop(cluster_config, property_name, value, property_name_check=True):\n\n if property_name_check is True:\n valid_props = [\"cbs_ssl_enabled\", \"xattrs_enabled\", \"sg_lb_enabled\", \"sync_gateway_version\", \"server_version\",\n \"no_conflicts_enabled\", \"sync_gateway_ssl\", \"sg_use_views\", \"number_replicas\",\n \"delta_sync_enabled\", \"x509_certs\", \"hide_product_version\", \"cbs_developer_preview\", \"disable_persistent_config\",\n \"server_tls_skip_verify\", \"disable_tls_server\", \"disable_admin_auth\", \"trace_logs\"]\n if property_name not in valid_props:\n raise ProvisioningError(\"Make sure the property you are trying to change is one of: {}\".format(valid_props))\n\n # Write property = value in the cluster_config.json\n cluster_config_json = \"{}.json\".format(cluster_config)\n with open(cluster_config_json) as f:\n cluster = json.loads(f.read())\n\n cluster[\"environment\"][property_name] = value\n with open(cluster_config_json, \"w\") as f:\n json.dump(cluster, f, indent=4)\n\n # Write [section] property = value in the cluster_config\n config = CustomConfigParser()\n config.read(cluster_config)\n config.set('environment', property_name, str(value))\n\n with open(cluster_config, 'w') as f:\n config.write(f)","def set(settingName, value):\n if settingName not in _loaded:\n raise ValueError(\"Specified configuration setting \\\"%s\\\" does not exist\" % settingName)\n \n _loaded[settingName] = value","def set(node_key:str, property_name:str, value):\r\n node_names = split_node_key(node_key)\r\n node = root\r\n for node_name in node_names:\r\n node = node.nodes[node_name]\r\n node.properties[property_name] = value","def set(self, key: str, value) -> 'Property':\n\n if not hasattr(self, key):\n if key in LIMB_KEY_LOOKUP:\n key = LIMB_KEY_LOOKUP[key]\n else:\n raise KeyError('\"{}\" not a valid Property key'.format(key))\n setattr(self, key, value)\n\n return self","def set_property(self, client, key, value):\r\n client.setProperty(key, value)\r\n return True","def properties_set(self, properties):\n self._put('properties', properties)","def XPSetWidgetProperty(inWidget, inProperty, inValue):\n pass","def SetWirelessProperty(self, networkid, prop, value):\n if (prop.strip()).endswith(\"script\"):\n print \"Setting script properties through the daemon is not\" \\\n + \" permitted.\"\n return False\n self.LastScan[networkid][prop] = misc.Noneify(value)","def _update_property(self, field, value):\n if value is not None:\n self.properties[field] = value\n elif field in self.properties:\n del self.properties[field]","def set(self, prop, value):\r\n\r\n prop_parts = prop.split(\".\")\r\n if self.copy_dict:\r\n new_dict = copy.deepcopy(self.obj)\r\n else:\r\n new_dict = self.obj\r\n pointer = None\r\n parts_length = len(prop_parts) - 1\r\n for i, part in enumerate(prop_parts):\r\n if pointer is None and i == parts_length:\r\n new_dict[part] = value\r\n elif pointer is None:\r\n pointer = new_dict.get(part)\r\n elif i == parts_length:\r\n pointer[part] = value\r\n else:\r\n pointer = pointer.get(part)\r\n return new_dict","def __setitem__(self, name, value):\n datastore_types.ValidateProperty(name, value)\n dict.__setitem__(self, name, value)","def config_set(self, name, value):\n self.redis_config[name] = value","def object_property_name(self, object_property_name):\n\n self._object_property_name = object_property_name","def _set_property(self, name, prop_name, prop_value, ignore_items=False):\n prop_update = {prop_name: prop_value}\n for n in name:\n collection = 'masks' if self.is_array(n) else 'columns'\n if not 'properties' in self._meta[collection][n]:\n self._meta[collection][n]['properties'] = {}\n self._meta[collection][n]['properties'].update(prop_update)\n if ignore_items: continue\n for s in self.sources(n):\n self._set_property(s, prop_name, prop_value)\n return None","def property_name(self, name: str) -> None:\n name = str(name)\n if len(name) > 100:\n name = name[:100]\n self.prop_name = name","def autoprops_generated_setter(self, **kwargs):\n setattr(self, private_property_name, kwargs[property_name])","def set(self, key, value):\n if key == key.upper():\n if key not in self.config:\n self.__log(f'Error when setting configuration variable \"{key}\", it does not exist', 'error')\n raise KeyError\n self.__log(f'Setting configuration variable \"{key}\" to \"{value}\"')\n self.config[key] = value\n else:\n if key not in self.options:\n self.__log(f'Error when setting option \"{key}\", it does not exist.', 'error')\n raise KeyError\n self.__log(f'Setting option \"{key}\" to \"{value}\"')\n self.options[key] = value","def property_id(self, property_id):\n\n self._property_id = property_id","def SetWiredProperty(self, prop, value):\n if self.WiredNetwork:\n if (prop.strip()).endswith(\"script\"):\n print \"Setting script properties through the daemon\" \\\n + \" is not permitted.\"\n return False\n self.WiredNetwork[prop] = misc.Noneify(value)\n return True\n else:\n print 'SetWiredProperty: WiredNetwork does not exist'\n return False","def migrate_property ( self, name, property, property_info, class_dict ):\n get = _property_method( class_dict, '_get_' + name )\n set = _property_method( class_dict, '_set_' + name )\n val = _property_method( class_dict,\n '_validate_' + name )\n if ((get is not None) or (set is not None) or (val is not None)):\n old_get, old_set, old_val = property_info\n return Property( get or old_get, set or old_set, val or old_val,\n True, **property.__dict__ )\n return property","def __process_property(self, element, property_name):\n try:\n expected_value = element.properties[property_name]\n except KeyError:\n return\n\n value_changed = self.__check_property_changed(element, property_name)\n if isinstance(expected_value, svgelements.svgelements.Color):\n if value_changed or expected_value.opacity:\n self.path_began = False\n elif not value_changed:\n return\n\n if property_name == 'fill':\n if value_changed:\n self.generator.fill_color(expected_value)\n if expected_value.opacity:\n self.generator.fill()\n elif property_name == 'linecap':\n self.generator.line_cap(expected_value)\n elif property_name == 'linejoin':\n self.generator.line_join(expected_value)\n elif property_name == 'miterlimit':\n self.generator.miter_limit(expected_value)\n elif property_name == 'stroke':\n if value_changed:\n self.generator.stroke_color(expected_value)\n if expected_value.opacity:\n self.generator.stroke()\n elif property_name == 'stroke_width':\n self.generator.stroke_width(expected_value)\n elif property_name == 'transform':\n self.__save(element)\n self.generator.transform(expected_value[0], expected_value[1],\n expected_value[2], expected_value[3],\n expected_value[4], expected_value[5])\n\n self.properties[-1][property_name] = expected_value","def set(key: str, value: Any):\n _check_key(key)\n config = _read_config()\n config[key] = value\n _write_config(config)","def __setattr__(self, name, value):\n # Can't set namespace variables\n if name.startswith('_'):\n raise ValueError('Settings cannot start with an underscore')\n\n if name in self._settings:\n # Set an existing setting's value\n if isinstance(value, Setting):\n raise ValueError('Settings cannot be redefined')\n self._settings[name].set(value)\n else:\n # Create a new setting\n if not isinstance(value, Setting):\n raise ValueError(\n 'Settings must be defined before they can be assigned',\n )\n self._settings[name] = value","def _write_node_property(self, new_property, property_name):\n self.graph.vertex_properties[property_name] = new_property","def __setattr__(self,name,value):\n # Assignment during initialisation\n if not self.__dict__.has_key('_PreferencesSection__initialised'):\n self.__dict__[name]=value\n return self.__dict__[name]\n # Assignment after initialisation\n if name not in ['_PreferencesSection__section','_PreferencesSection__options',\n '_PreferencesSection__config','_PreferencesSection__initialised','__get_option','__set_option']:\n # Set option value\n return self.set_option(name,value)\n else:\n # Call original __setattr__ method\n raise Exception('(EVOGTK - Preferences Helper) Trying to set protected \"%s\" property' % name)","def update(name, value, config_dir=None):\n if name not in Config.__ALLOWED:\n msg = f'Cannot update configuration; value \"{name}\" is not allowed.'\n raise ConfigurationError(msg)\n config_dir = Config.resolve_config_dir(config_dir)\n config_dat, config_file = Config.get_config_file(\n config_dir,\n round_trip_load=True,\n quiet=True,\n )\n config_dat.update({name: value})\n Config.write_config_file(config_dat, config_file)\n if Config.is_set:\n Config.__conf[name] = value","def _setPropertyValue(self, name, value, typeString = ''):\n method = getattr(self.__class__, \"_setPropertyValue\" + getTypeString(value))\n return method(self, name, value, typeString)","def test_set_property_success(self):\r\n self.config.option1 = 9001\r\n self.assertEqual(self.config.values['option1'], 9001)\r\n\r\n self.config.option2 = 'bar'\r\n self.assertEqual(self.config.values['option2'], 'bar')","def setProperty(self, newProp, objectID=0):\n\n # Set the new property to container\n key = (newProp.getPropertyID(),\n newProp.getObjectID(),\n newProp.getTime())\n self.properties.set_value(key, newProp)","def set(self, name, value):\n pass","async def set_property(self, product_type: ProductType, serial_no: str, name: str, value: Any) -> None:\n await self._send_message_get_response(OutgoingMessage(OutgoingMessageType.set_property, domain=product_type.name, serial_no=serial_no, name=name, value=value))","def set_value(self, section_name: str, attr_name: str, value: str) -> None:\n config = ConfigParser(allow_no_value=True)\n if value is not None:\n value = str(value)\n if self.is_section_exist(section_name=section_name) is True:\n if self.is_attr_exist(section_name=section_name, attr_name=attr_name) is True:\n config.read(self.connection_string)\n for section in config.sections():\n if section.lower().replace(' ', '_') == section_name.lower().replace(' ', '_'):\n for attr in config[section]:\n if attr.lower().replace(' ', '_') == attr_name.lower().replace(' ', '_'):\n config.set(section=section, option=attr, value=value)\n with open(file=self.connection_string, mode='w') as file:\n config.write(fp=file)\n else:\n self.add_attr(section_name=section_name, attr_name=attr_name, value=value)","def test_set_new_property():\n\n value = '1'\n contents = (\"[info]\\n\"\n \"real = not_real\")\n\n testutils.deploy_config_raw(contents)\n\n prop.set_prop('info', 'sdk', value)\n assert prop.get_prop('info', 'sdk') == value\n\n testutils.undeploy()","def set_value(self, _, prop_value_pair):\n (prop, val) = prop_value_pair\n\n _, _, obj = self.popup_data\n if not isinstance(obj, value_model.Value):\n raise TypeError(\"Expected %s\" % type(value_model.Value))\n\n if not prop == obj.parent:\n raise ValueError(\"Property '%s' is not the parent of '%s'\" % (prop, obj))\n\n # To enable undo redo for this we need a bit of trickery\n new_prop = prop.clone(keep_id=True)\n create_pseudo_values([new_prop])\n if new_prop.pseudo_values[obj.index].pseudo_values != obj.pseudo_values:\n raise ValueError(\"Cannot find replacement value\")\n\n # Update the value in the new property\n new_prop.pseudo_values[obj.index].pseudo_values = val\n\n # Lets replace the old property with the new and updated one\n cmd = commands.ReplaceObject(obj=prop, repl=new_prop)\n self.execute(cmd)\n\n # Reset the view to make sure the changes are properly displayed.\n self.select_object(new_prop)\n self.reset_value_view(None)","def setValue(self, valueName, valueSetting):\n\t\tself.settings[valueName][0] = valueSetting","def test_set_existing_property():\n\n value = 'new'\n\n contents = (\"[Info]\\n\"\n \"sdk = old\")\n\n testutils.deploy_config_raw(contents)\n\n prop.set_prop('info', 'sdk', value)\n assert prop.get_prop('info', 'sdk') == value\n\n testutils.undeploy()\n\n return 0","def update(self, **kwargs):\n for key, value in kwargs.items():\n try:\n is_property = isinstance(getattr(self.__class__, key), property)\n except AttributeError:\n continue\n\n if is_property:\n setattr(self, key, value)","def write_property(self, td, name, value, timeout=None):\n\n raise NotImplementedError()","def SetParserProp(self, prop, value):\n ret = libxml2mod.xmlTextReaderSetParserProp(self._o, prop, value)\n return ret","def set_config(self, attr, value):\n setattr(self.config, attr, value)","def set_config(self, attr, value):\n setattr(self.config, attr, value)","def setconfig(self, key, value):\n self.config[key] = value","def __setitem__(self, name : str, value : object) -> None:\n self._client.set_config(name, value)","def SetProperties(self, prop_lst):\n # Parses Property list, ignoring all bad values\n for prop in prop_lst:\n if len(prop) != 2:\n continue\n else:\n if not isinstance(prop[0], basestring) or not \\\n isinstance(prop[1], basestring):\n continue\n else:\n self.SetProperty(prop[0], prop[1])\n return True","def set(self, properties):\n raise NotImplementedError","def set_attribute(self, name, value):\n setattr(self, '%s__' % name, value_or_none(value))","def declare_property(self, name): # noqa: E501 # The links in the docstring above are too long to wrap to 120 chars.\n\n self.forced_properties.add(name)","def set(self, attribute_name, value_name):\n self.__set[attribute_name] = value_name\n return self","def set_attribute(self, name, value):\n\n pass","def __setattr__(self, name, value):\n self.set(**{name: value})","def set_property(self, vtk_property):\n self.vtk_act.SetProperty(vtk_property)","def set(self, name, val, section=section_default):\n if section not in self.config.sections():\n self.config.add_section(section)\n\n self.config.set(section, name, val)\n self.save()","def set_system_config_property(connection, config_key, value):\n\n body = {\n 'key': config_key,\n 'value': value,\n }\n response = connection.post_obj_as_json('system/config', body).json()\n config_value = response.get('result')\n if config_value is None:\n raise SAPCliError(\"gCTS response does not contain 'result'\")\n\n return config_value","def __setattr__(self, key, value):\n self._config.__setitem__(key, value)","def propset(self, name, value, *args):\r\n d = py.path.local.mkdtemp() \r\n try: \r\n p = d.join('value') \r\n p.write(value) \r\n self._svn('propset', name, '--file', str(p), *args)\r\n finally: \r\n d.remove()","def set_variable(self, name, value):\n self.send_to_backend('set', name=name, value=value)\n self.refresh_variable(name)","def setProperty(*args):","def setProperty(*args):","def setProperty(*args):","def setProperty(*args):","def setProperty(*args):","def __property_config__(self, model_class, property_name):\n super(MemcacheReferenceProperty, self).__property_config__(model_class, property_name)\n\n if self.reference_class is _SELF_REFERENCE:\n self.reference_class = self.data_type = model_class\n\n if self.collection_name is None:\n self.collection_name = '%s_set' % (model_class.__name__.lower())\n existing_prop = getattr(self.reference_class, self.collection_name, None)\n if existing_prop is not None:\n if not (isinstance(existing_prop, db._ReverseReferenceProperty) and\n existing_prop._prop_name == property_name and\n existing_prop._model.__name__ == model_class.__name__ and\n existing_prop._model.__module__ == model_class.__module__):\n raise DuplicatePropertyError('Class %s already has property %s '\n % (self.reference_class.__name__,\n self.collection_name))\n setattr(self.reference_class,\n self.collection_name,\n db._ReverseReferenceProperty(model_class, property_name))","def __setattr__ (self, name, value):\n\t\ttry:\n\t\t\tself.__dict__[name] # Do not delete this line (it verifies the existence of an attribute)\n\t\t\t# Positioning of the existing attribute\n\t\t\tself.__dict__[name] = value\n\t\texcept KeyError:\n\t\t\t# The attribute does not exist is probably value of the structure\n\t\t\tself.__dict__[\"value\"][name] = value","def setProperty(self,prop=None):\n objects = self.check()\n if objects:\n if prop is None:\n res = askItems([['property',0]],\n caption = 'Set Property Number for Selection (negative value to remove)')\n if res:\n prop = int(res['property'])\n if prop < 0:\n prop = None\n for o in objects:\n if hasattr(o,'setProp'):\n o.setProp(prop)\n self.draw()","def set(self, name, value, autosave=True, override=True):\n if self._is_section(name) and not isinstance(value, _Section):\n raise SectionError(\"Cannot override section with value.\")\n if isinstance(value, _Section):\n if override:\n self._config_obj[name] = {}\n for key, _value in value._config_obj.items():\n self[name].set(key, _value, autosave, override)\n elif name not in self._config_obj or override:\n self._config_obj[name] = value\n if autosave:\n self.save()","def setValue(self, name, value):\n values = self.__get('values')\n values[name] = value\n self.__set('values', values)","def add_property(self, property):\n # check input data type\n if not isinstance(property, dict):\n raise TypeError\n # check data types of keys in dict\n if not all([isinstance(key, str) for key in property.keys()]):\n raise TypeError\n # check that values are lists of strings\n for key, value in property.items():\n if isinstance(value, str):\n property[key] = [value]\n elif not isinstance(value, list):\n raise TypeError\n else:\n if not all([isinstance(val, str) for val in value]):\n raise TypeError\n\n # add properties to the dict\n for key, value in property.items():\n if key not in self.properties:\n self.properties[key] = value\n else:\n self.properties[key] += value\n self.properties[key] = list(set(self.properties[key]))"],"string":"[\n \"def SetProp(self, name, value):\\n self._props[name] = value\\n self._changed(name, value)\",\n \"def set_prop(prop, value, config_type=\\\"\\\", config_path=\\\"\\\"):\\n\\n path = get_config_path(config_type, config_path)\\n set_property_value(prop, value, path)\",\n \"def set_property(self, name, value):\\n self.properties[name] = value\",\n \"def do_set_property(self, spec, value):\\n attribute = self.find_attribute(spec.name)\\n if attribute is not None and isinstance(attribute, property):\\n attribute.fset(self, value)\\n else:\\n raise ValueError(\\\"No such property\\\", spec.name)\",\n \"def set_property(self, key, value):\\n if not key:\\n raise Exception('A key should be provided.')\\n if not value:\\n raise Exception('A value should be provided.')\\n self._properties[key] = value\",\n \"def setprop(name, value):\\n _slp.setprop(name, value)\",\n \"def set_property(self, name, prop_name, prop_value, ignore_items=False):\\n valid_props = ['base_text', '_no_valid_items', '_no_valid_values']\\n if prop_name not in valid_props:\\n raise ValueError(\\\"'prop_name' must be one of {}\\\".format(valid_props))\\n self._set_property(name, prop_name, prop_value, ignore_items)\\n return None\",\n \"def SetProperty(self, propertyname, value):\\n if self.serviceimplementation == 'basic':\\n flag = self.vbLet\\n if isinstance(value, datetime.datetime):\\n value = SFScriptForge.SF_Basic.CDateToUnoDateTime(value)\\n flag += self.flgDateArg\\n if repr(type(value)) == \\\"<class 'pyuno'>\\\":\\n flag += self.flgUno\\n return self.EXEC(self.objectreference, flag, propertyname, value)\",\n \"def set_role_property(self, obj, property_name, property_value): # pylint: disable=no-self-use\\n if isinstance(obj, dict):\\n if 'properties' in obj:\\n obj = obj['properties']\\n obj[property_name] = property_value\\n else:\\n if hasattr(obj, 'properties'):\\n obj = obj.properties\\n obj.property_name = property_value\",\n \"def setProp(self, name, value):\\n ret = libxml2mod.xmlSetProp(self._o, name, value)\\n if ret is None:raise treeError('xmlSetProp() failed')\\n __tmp = xmlAttr(_obj=ret)\\n return __tmp\",\n \"def set_property_value(prop, value, path):\\n\\n if not isfile(path):\\n raise ConfigFileNotCreatedException(path)\\n\\n content = \\\"\\\"\\n updated = False\\n\\n try:\\n with open(path, \\\"r+\\\") as f:\\n for line in f:\\n m = _search_pattern.search(line)\\n\\n if m:\\n result = m.groupdict()\\n\\n # check if the found property matches with the wanted property\\n if result[\\\"key\\\"] == prop:\\n content += \\\"{}={}\\\\n\\\".format(prop, value)\\n updated = True\\n continue\\n\\n content += line\\n\\n # if the last character is a newline, remove it\\n if len(content) and content[-1] == \\\"\\\\n\\\":\\n content = content[:-1]\\n\\n # create a new entry if we property does not yet exist\\n if not updated:\\n content += \\\"\\\\n{}={}\\\".format(prop, value)\\n\\n # overwrite old config file content\\n f.seek(0)\\n f.truncate()\\n f.write(content)\\n except PermissionError:\\n raise ConfigFilePermissionErrorException(path)\",\n \"def set_user_property(self, property, value):\\n self._user_properties.update({property: value})\",\n \"def set(self, attr_name, value):\\n\\n get_logger().debug('Going to set XML attribute property: %s', attr_name)\\n\\n if self.textproperty is not None:\\n # TODO: potentially programming error\\n raise MarshallingError()\\n\\n try:\\n # pylint: disable=unnecessary-dunder-call\\n self.attributes[attr_name].__set__(self.obj, value)\\n get_logger().debug('Set XML attribute property: %s', attr_name)\\n except AttributeError as ex:\\n get_logger().error('XML property %s: %s', attr_name, str(ex))\\n except KeyError:\\n get_logger().debug('Not an XML attribute property: %s', attr_name)\",\n \"def set_property(self, key: str, value: Any):\\n if not key:\\n raise ValueError(\\\"Key is required\\\")\\n\\n if value is None:\\n raise ValueError(\\\"Value is required\\\")\\n\\n self._node[\\\"app_data\\\"][\\\"properties\\\"][key] = value\",\n \"def add_property(self, name, value=None):\\n self.properties[name] = value\",\n \"def set_property(key, value):\\n return impl.set_property(**locals())\",\n \"def set(self, database_name, property_, value):\\n return isempty(self._send_command(database_name, \\\"%s=%s\\\" % (property_, value)))\",\n \"def set_property(self, key, value):\\n self.properties[key] = value\\n return self.properties[key]\",\n \"def prop_set(prop, value, extra_args=None, cibfile=None):\\n return item_create(\\n item=\\\"property\\\",\\n item_id=\\\"{}={}\\\".format(prop, value),\\n item_type=None,\\n create=\\\"set\\\",\\n extra_args=extra_args,\\n cibfile=cibfile,\\n )\",\n \"def do_set_property(self, pspec, val):\\n # FIXME: need an asynchronous API to set these properties,\\n # particularly 'private'\\n\\n if pspec.name == 'name':\\n self._name = val\\n elif pspec.name == 'color':\\n self._color = val\\n elif pspec.name == 'tags':\\n self._tags = val\\n elif pspec.name == 'private':\\n self._private = val\\n else:\\n raise ValueError('Unknown property %r', pspec.name)\\n\\n self._publish_properties()\",\n \"def set_property(self, name, value, persist_changes=True):\\n self._properties_metadata[name] = {'readonly': not persist_changes}\\n self._properties[name] = value\",\n \"def set_property(wellorcontainer, property_name, value):\\n wells = convert_to_wellgroup(wellorcontainer)\\n \\n if not isinstance(value, str):\\n value = str(value)\\n \\n for well in wells:\\n assert isinstance(well, Well)\\n well.properties[property_name] = value\",\n \"def setDynamicProperty(self, widget, property_name, property_value):\\n\\n\\t\\twidget.setProperty(property_name, property_value)\\n\\t\\twidget.style().unpolish(widget)\\n\\t\\twidget.style().polish(widget)\",\n \"def put_prop(self, obj_type, obj_id, prop_name, value):\\n ierr = exolib.py_expp(self.exoid, obj_type, obj_id, prop_name, value)\\n if ierr:\\n raise ExodusIIWriterError(\\\"Error putting prop value\\\")\",\n \"def addPropertie(self, propname, value):\\n if isinstance(propname, types.IntType) or isinstance(propname, types.StringType):\\n self.properties[propname] = value\\n else:\\n raise Exception(\\\"la propiedad debe ser de tipo int o string\\\")\",\n \"def __setattr__(self, name, value):\\n if self.serviceimplementation == 'basic':\\n if name in ('serviceproperties', 'localProperties', 'internal_attributes', 'propertysynonyms',\\n 'forceGetProperty'):\\n pass\\n elif name[0:2] == '__' or name in self.internal_attributes or name in self.localProperties:\\n pass\\n elif name in self.serviceproperties or name in self.propertysynonyms:\\n if name in self.propertysynonyms: # Reset real name if argument provided in lower or camel case\\n name = self.propertysynonyms[name]\\n if self.internal: # internal = True forces property local setting even if property is read-only\\n pass\\n elif self.serviceproperties[name] is True: # True == Editable\\n self.SetProperty(name, value)\\n return\\n else:\\n raise AttributeError(\\n \\\"type object '\\\" + self.objecttype + \\\"' has no editable property '\\\" + name + \\\"'\\\")\\n else:\\n raise AttributeError(\\\"type object '\\\" + self.objecttype + \\\"' has no property '\\\" + name + \\\"'\\\")\\n object.__setattr__(self, name, value)\\n return\",\n \"def changeProperty(self, node, name, propertyName, value, setIfNotExist=False):\",\n \"def set_property_value(self, name, value, dry_run=False):\\n raise DAVError(\\n HTTP_FORBIDDEN, err_condition=PRECONDITION_CODE_ProtectedProperty\\n )\",\n \"def set_property(self,obj_property,value):\\n existing_properties = self.get_property(obj_property)\\n if existing_properties is None:\\n if type(value) == list:\\n if len(value) == 1:\\n self.redis_server.hset(self.frbr_key,\\n obj_property,\\n value[0])\\n else:\\n new_redis_key = \\\"%s:%s\\\" % (self.frbr_key,\\n obj_property)\\n for row in value:\\n self.redis_server.sadd(new_redis_key,\\n row)\\n self.redis_server.hset(self.frbr_key,\\n obj_property,\\n new_redis_key)\\n else:\\n self.redis_server.hset(self.frbr_key,\\n obj_property,\\n value)\",\n \"def setProperty(self, path, key, value):\\n \\n try:\\n self._client.propset(key, value, self._workingCopyPath + path)\\n self.checkin(path)\\n except ClientError, error:\\n raise SubversionError(error)\",\n \"def add_property_setting(self, key, prop):\\n\\n setting = self.settings().new_property(key, prop)\\n self._add_to_list_field(\\\"settings\\\", setting)\",\n \"def run_setprop(self, expanded, unexpanded) :\\n\\t\\toptions, args = self.getopt([\\\"name=\\\", \\\"value=\\\"], expanded)\\n\\t\\tif (options is None) and (args is None) :\\n\\t\\t\\treturn -1\\t# message was already displayed in self.getopt()\\n\\t\\tif not args :\\n\\t\\t\\treturn self.errormessage(\\\"Needs at least one object to change this property\\\")\\n\\t\\tif not (options.has_key(\\\"name\\\") and options.has_key(\\\"value\\\")) :\\n\\t\\t\\treturn self.errormessage(\\\"You must supply a property name and value\\\")\\n\\t\\tproperty = options[\\\"name\\\"]\\n\\t\\tif options.has_key(\\\"value\\\") :\\n\\t\\t\\tpropvalue = options[\\\"value\\\"]\\n\\t\\t\\ttry :\\n\\t\\t\\t\\t# maybe it's a list in a string, e.g. \\\"['e', 'f']\\\"\\n\\t\\t\\t\\t# or something like that\\n\\t\\t\\t\\tnewvalue = eval(propvalue)\\n\\t\\t\\t\\tif (type(newvalue) != type(0)) and (type(newvalue) != type(0.0)) :\\n\\t\\t\\t\\t\\t# we mustn't convert numeric to string\\n\\t\\t\\t\\t\\tpropvalue = newvalue\\n\\t\\t\\texcept NameError :\\n\\t\\t\\t\\tpass\\t# normal string\\n\\t\\telse :\\n\\t\\t\\tpropvalue = \\\"\\\"\\n\\n\\t\\tstatus = 0\\n\\t\\tfor arg in args :\\n\\t\\t\\tobject = self.toObject(self.__context, arg)\\n\\t\\t\\tif object is not None :\\n\\t\\t\\t\\tif not self.HasPerms(object, 'Manage properties') :\\n\\t\\t\\t\\t\\tstatus = status - 1\\n\\t\\t\\t\\telif hasattr(object, 'hasProperty') :\\n\\t\\t\\t\\t\\tif not object.hasProperty(property) :\\n\\t\\t\\t\\t\\t\\tstatus = status + self.errormessage(\\\"Object %s has no property %s\\\" % (self.ObjectPath(object), property))\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t# in the following lines the absence of a _updateProperty\\n\\t\\t\\t\\t\\t\\t# attribute indicates an object without properties (e.g. a method)\\n\\t\\t\\t\\t\\t\\t# which indicates an object for which setting properties is a nonsense\\n\\t\\t\\t\\t\\t\\tif hasattr(object, \\\"_updateProperty\\\") :\\n\\t\\t\\t\\t\\t\\t\\tobject._updateProperty(property, propvalue)\\n\\t\\t\\t\\t\\t\\t\\tself.htmlmessage(\\\"Object %s property %s was modified to %s\\\" % (self.ObjectPath(object), property, str(propvalue)))\\n\\t\\treturn status\",\n \"def put_prop(self, obj_type, obj_id, prop_name, value):\\n ierr = exolib.py_expp(self.exoid, obj_type, obj_id, prop_name, value)\\n if ierr:\\n raise ExodusIIWriterError(\\\"Error putting prop\\\")\",\n \"def persist_cluster_config_environment_prop(cluster_config, property_name, value, property_name_check=True):\\n\\n if property_name_check is True:\\n valid_props = [\\\"cbs_ssl_enabled\\\", \\\"xattrs_enabled\\\", \\\"sg_lb_enabled\\\", \\\"sync_gateway_version\\\", \\\"server_version\\\",\\n \\\"no_conflicts_enabled\\\", \\\"sync_gateway_ssl\\\", \\\"sg_use_views\\\", \\\"number_replicas\\\",\\n \\\"delta_sync_enabled\\\", \\\"x509_certs\\\", \\\"hide_product_version\\\", \\\"cbs_developer_preview\\\", \\\"disable_persistent_config\\\",\\n \\\"server_tls_skip_verify\\\", \\\"disable_tls_server\\\", \\\"disable_admin_auth\\\", \\\"trace_logs\\\"]\\n if property_name not in valid_props:\\n raise ProvisioningError(\\\"Make sure the property you are trying to change is one of: {}\\\".format(valid_props))\\n\\n # Write property = value in the cluster_config.json\\n cluster_config_json = \\\"{}.json\\\".format(cluster_config)\\n with open(cluster_config_json) as f:\\n cluster = json.loads(f.read())\\n\\n cluster[\\\"environment\\\"][property_name] = value\\n with open(cluster_config_json, \\\"w\\\") as f:\\n json.dump(cluster, f, indent=4)\\n\\n # Write [section] property = value in the cluster_config\\n config = CustomConfigParser()\\n config.read(cluster_config)\\n config.set('environment', property_name, str(value))\\n\\n with open(cluster_config, 'w') as f:\\n config.write(f)\",\n \"def set(settingName, value):\\n if settingName not in _loaded:\\n raise ValueError(\\\"Specified configuration setting \\\\\\\"%s\\\\\\\" does not exist\\\" % settingName)\\n \\n _loaded[settingName] = value\",\n \"def set(node_key:str, property_name:str, value):\\r\\n node_names = split_node_key(node_key)\\r\\n node = root\\r\\n for node_name in node_names:\\r\\n node = node.nodes[node_name]\\r\\n node.properties[property_name] = value\",\n \"def set(self, key: str, value) -> 'Property':\\n\\n if not hasattr(self, key):\\n if key in LIMB_KEY_LOOKUP:\\n key = LIMB_KEY_LOOKUP[key]\\n else:\\n raise KeyError('\\\"{}\\\" not a valid Property key'.format(key))\\n setattr(self, key, value)\\n\\n return self\",\n \"def set_property(self, client, key, value):\\r\\n client.setProperty(key, value)\\r\\n return True\",\n \"def properties_set(self, properties):\\n self._put('properties', properties)\",\n \"def XPSetWidgetProperty(inWidget, inProperty, inValue):\\n pass\",\n \"def SetWirelessProperty(self, networkid, prop, value):\\n if (prop.strip()).endswith(\\\"script\\\"):\\n print \\\"Setting script properties through the daemon is not\\\" \\\\\\n + \\\" permitted.\\\"\\n return False\\n self.LastScan[networkid][prop] = misc.Noneify(value)\",\n \"def _update_property(self, field, value):\\n if value is not None:\\n self.properties[field] = value\\n elif field in self.properties:\\n del self.properties[field]\",\n \"def set(self, prop, value):\\r\\n\\r\\n prop_parts = prop.split(\\\".\\\")\\r\\n if self.copy_dict:\\r\\n new_dict = copy.deepcopy(self.obj)\\r\\n else:\\r\\n new_dict = self.obj\\r\\n pointer = None\\r\\n parts_length = len(prop_parts) - 1\\r\\n for i, part in enumerate(prop_parts):\\r\\n if pointer is None and i == parts_length:\\r\\n new_dict[part] = value\\r\\n elif pointer is None:\\r\\n pointer = new_dict.get(part)\\r\\n elif i == parts_length:\\r\\n pointer[part] = value\\r\\n else:\\r\\n pointer = pointer.get(part)\\r\\n return new_dict\",\n \"def __setitem__(self, name, value):\\n datastore_types.ValidateProperty(name, value)\\n dict.__setitem__(self, name, value)\",\n \"def config_set(self, name, value):\\n self.redis_config[name] = value\",\n \"def object_property_name(self, object_property_name):\\n\\n self._object_property_name = object_property_name\",\n \"def _set_property(self, name, prop_name, prop_value, ignore_items=False):\\n prop_update = {prop_name: prop_value}\\n for n in name:\\n collection = 'masks' if self.is_array(n) else 'columns'\\n if not 'properties' in self._meta[collection][n]:\\n self._meta[collection][n]['properties'] = {}\\n self._meta[collection][n]['properties'].update(prop_update)\\n if ignore_items: continue\\n for s in self.sources(n):\\n self._set_property(s, prop_name, prop_value)\\n return None\",\n \"def property_name(self, name: str) -> None:\\n name = str(name)\\n if len(name) > 100:\\n name = name[:100]\\n self.prop_name = name\",\n \"def autoprops_generated_setter(self, **kwargs):\\n setattr(self, private_property_name, kwargs[property_name])\",\n \"def set(self, key, value):\\n if key == key.upper():\\n if key not in self.config:\\n self.__log(f'Error when setting configuration variable \\\"{key}\\\", it does not exist', 'error')\\n raise KeyError\\n self.__log(f'Setting configuration variable \\\"{key}\\\" to \\\"{value}\\\"')\\n self.config[key] = value\\n else:\\n if key not in self.options:\\n self.__log(f'Error when setting option \\\"{key}\\\", it does not exist.', 'error')\\n raise KeyError\\n self.__log(f'Setting option \\\"{key}\\\" to \\\"{value}\\\"')\\n self.options[key] = value\",\n \"def property_id(self, property_id):\\n\\n self._property_id = property_id\",\n \"def SetWiredProperty(self, prop, value):\\n if self.WiredNetwork:\\n if (prop.strip()).endswith(\\\"script\\\"):\\n print \\\"Setting script properties through the daemon\\\" \\\\\\n + \\\" is not permitted.\\\"\\n return False\\n self.WiredNetwork[prop] = misc.Noneify(value)\\n return True\\n else:\\n print 'SetWiredProperty: WiredNetwork does not exist'\\n return False\",\n \"def migrate_property ( self, name, property, property_info, class_dict ):\\n get = _property_method( class_dict, '_get_' + name )\\n set = _property_method( class_dict, '_set_' + name )\\n val = _property_method( class_dict,\\n '_validate_' + name )\\n if ((get is not None) or (set is not None) or (val is not None)):\\n old_get, old_set, old_val = property_info\\n return Property( get or old_get, set or old_set, val or old_val,\\n True, **property.__dict__ )\\n return property\",\n \"def __process_property(self, element, property_name):\\n try:\\n expected_value = element.properties[property_name]\\n except KeyError:\\n return\\n\\n value_changed = self.__check_property_changed(element, property_name)\\n if isinstance(expected_value, svgelements.svgelements.Color):\\n if value_changed or expected_value.opacity:\\n self.path_began = False\\n elif not value_changed:\\n return\\n\\n if property_name == 'fill':\\n if value_changed:\\n self.generator.fill_color(expected_value)\\n if expected_value.opacity:\\n self.generator.fill()\\n elif property_name == 'linecap':\\n self.generator.line_cap(expected_value)\\n elif property_name == 'linejoin':\\n self.generator.line_join(expected_value)\\n elif property_name == 'miterlimit':\\n self.generator.miter_limit(expected_value)\\n elif property_name == 'stroke':\\n if value_changed:\\n self.generator.stroke_color(expected_value)\\n if expected_value.opacity:\\n self.generator.stroke()\\n elif property_name == 'stroke_width':\\n self.generator.stroke_width(expected_value)\\n elif property_name == 'transform':\\n self.__save(element)\\n self.generator.transform(expected_value[0], expected_value[1],\\n expected_value[2], expected_value[3],\\n expected_value[4], expected_value[5])\\n\\n self.properties[-1][property_name] = expected_value\",\n \"def set(key: str, value: Any):\\n _check_key(key)\\n config = _read_config()\\n config[key] = value\\n _write_config(config)\",\n \"def __setattr__(self, name, value):\\n # Can't set namespace variables\\n if name.startswith('_'):\\n raise ValueError('Settings cannot start with an underscore')\\n\\n if name in self._settings:\\n # Set an existing setting's value\\n if isinstance(value, Setting):\\n raise ValueError('Settings cannot be redefined')\\n self._settings[name].set(value)\\n else:\\n # Create a new setting\\n if not isinstance(value, Setting):\\n raise ValueError(\\n 'Settings must be defined before they can be assigned',\\n )\\n self._settings[name] = value\",\n \"def _write_node_property(self, new_property, property_name):\\n self.graph.vertex_properties[property_name] = new_property\",\n \"def __setattr__(self,name,value):\\n # Assignment during initialisation\\n if not self.__dict__.has_key('_PreferencesSection__initialised'):\\n self.__dict__[name]=value\\n return self.__dict__[name]\\n # Assignment after initialisation\\n if name not in ['_PreferencesSection__section','_PreferencesSection__options',\\n '_PreferencesSection__config','_PreferencesSection__initialised','__get_option','__set_option']:\\n # Set option value\\n return self.set_option(name,value)\\n else:\\n # Call original __setattr__ method\\n raise Exception('(EVOGTK - Preferences Helper) Trying to set protected \\\"%s\\\" property' % name)\",\n \"def update(name, value, config_dir=None):\\n if name not in Config.__ALLOWED:\\n msg = f'Cannot update configuration; value \\\"{name}\\\" is not allowed.'\\n raise ConfigurationError(msg)\\n config_dir = Config.resolve_config_dir(config_dir)\\n config_dat, config_file = Config.get_config_file(\\n config_dir,\\n round_trip_load=True,\\n quiet=True,\\n )\\n config_dat.update({name: value})\\n Config.write_config_file(config_dat, config_file)\\n if Config.is_set:\\n Config.__conf[name] = value\",\n \"def _setPropertyValue(self, name, value, typeString = ''):\\n method = getattr(self.__class__, \\\"_setPropertyValue\\\" + getTypeString(value))\\n return method(self, name, value, typeString)\",\n \"def test_set_property_success(self):\\r\\n self.config.option1 = 9001\\r\\n self.assertEqual(self.config.values['option1'], 9001)\\r\\n\\r\\n self.config.option2 = 'bar'\\r\\n self.assertEqual(self.config.values['option2'], 'bar')\",\n \"def setProperty(self, newProp, objectID=0):\\n\\n # Set the new property to container\\n key = (newProp.getPropertyID(),\\n newProp.getObjectID(),\\n newProp.getTime())\\n self.properties.set_value(key, newProp)\",\n \"def set(self, name, value):\\n pass\",\n \"async def set_property(self, product_type: ProductType, serial_no: str, name: str, value: Any) -> None:\\n await self._send_message_get_response(OutgoingMessage(OutgoingMessageType.set_property, domain=product_type.name, serial_no=serial_no, name=name, value=value))\",\n \"def set_value(self, section_name: str, attr_name: str, value: str) -> None:\\n config = ConfigParser(allow_no_value=True)\\n if value is not None:\\n value = str(value)\\n if self.is_section_exist(section_name=section_name) is True:\\n if self.is_attr_exist(section_name=section_name, attr_name=attr_name) is True:\\n config.read(self.connection_string)\\n for section in config.sections():\\n if section.lower().replace(' ', '_') == section_name.lower().replace(' ', '_'):\\n for attr in config[section]:\\n if attr.lower().replace(' ', '_') == attr_name.lower().replace(' ', '_'):\\n config.set(section=section, option=attr, value=value)\\n with open(file=self.connection_string, mode='w') as file:\\n config.write(fp=file)\\n else:\\n self.add_attr(section_name=section_name, attr_name=attr_name, value=value)\",\n \"def test_set_new_property():\\n\\n value = '1'\\n contents = (\\\"[info]\\\\n\\\"\\n \\\"real = not_real\\\")\\n\\n testutils.deploy_config_raw(contents)\\n\\n prop.set_prop('info', 'sdk', value)\\n assert prop.get_prop('info', 'sdk') == value\\n\\n testutils.undeploy()\",\n \"def set_value(self, _, prop_value_pair):\\n (prop, val) = prop_value_pair\\n\\n _, _, obj = self.popup_data\\n if not isinstance(obj, value_model.Value):\\n raise TypeError(\\\"Expected %s\\\" % type(value_model.Value))\\n\\n if not prop == obj.parent:\\n raise ValueError(\\\"Property '%s' is not the parent of '%s'\\\" % (prop, obj))\\n\\n # To enable undo redo for this we need a bit of trickery\\n new_prop = prop.clone(keep_id=True)\\n create_pseudo_values([new_prop])\\n if new_prop.pseudo_values[obj.index].pseudo_values != obj.pseudo_values:\\n raise ValueError(\\\"Cannot find replacement value\\\")\\n\\n # Update the value in the new property\\n new_prop.pseudo_values[obj.index].pseudo_values = val\\n\\n # Lets replace the old property with the new and updated one\\n cmd = commands.ReplaceObject(obj=prop, repl=new_prop)\\n self.execute(cmd)\\n\\n # Reset the view to make sure the changes are properly displayed.\\n self.select_object(new_prop)\\n self.reset_value_view(None)\",\n \"def setValue(self, valueName, valueSetting):\\n\\t\\tself.settings[valueName][0] = valueSetting\",\n \"def test_set_existing_property():\\n\\n value = 'new'\\n\\n contents = (\\\"[Info]\\\\n\\\"\\n \\\"sdk = old\\\")\\n\\n testutils.deploy_config_raw(contents)\\n\\n prop.set_prop('info', 'sdk', value)\\n assert prop.get_prop('info', 'sdk') == value\\n\\n testutils.undeploy()\\n\\n return 0\",\n \"def update(self, **kwargs):\\n for key, value in kwargs.items():\\n try:\\n is_property = isinstance(getattr(self.__class__, key), property)\\n except AttributeError:\\n continue\\n\\n if is_property:\\n setattr(self, key, value)\",\n \"def write_property(self, td, name, value, timeout=None):\\n\\n raise NotImplementedError()\",\n \"def SetParserProp(self, prop, value):\\n ret = libxml2mod.xmlTextReaderSetParserProp(self._o, prop, value)\\n return ret\",\n \"def set_config(self, attr, value):\\n setattr(self.config, attr, value)\",\n \"def set_config(self, attr, value):\\n setattr(self.config, attr, value)\",\n \"def setconfig(self, key, value):\\n self.config[key] = value\",\n \"def __setitem__(self, name : str, value : object) -> None:\\n self._client.set_config(name, value)\",\n \"def SetProperties(self, prop_lst):\\n # Parses Property list, ignoring all bad values\\n for prop in prop_lst:\\n if len(prop) != 2:\\n continue\\n else:\\n if not isinstance(prop[0], basestring) or not \\\\\\n isinstance(prop[1], basestring):\\n continue\\n else:\\n self.SetProperty(prop[0], prop[1])\\n return True\",\n \"def set(self, properties):\\n raise NotImplementedError\",\n \"def set_attribute(self, name, value):\\n setattr(self, '%s__' % name, value_or_none(value))\",\n \"def declare_property(self, name): # noqa: E501 # The links in the docstring above are too long to wrap to 120 chars.\\n\\n self.forced_properties.add(name)\",\n \"def set(self, attribute_name, value_name):\\n self.__set[attribute_name] = value_name\\n return self\",\n \"def set_attribute(self, name, value):\\n\\n pass\",\n \"def __setattr__(self, name, value):\\n self.set(**{name: value})\",\n \"def set_property(self, vtk_property):\\n self.vtk_act.SetProperty(vtk_property)\",\n \"def set(self, name, val, section=section_default):\\n if section not in self.config.sections():\\n self.config.add_section(section)\\n\\n self.config.set(section, name, val)\\n self.save()\",\n \"def set_system_config_property(connection, config_key, value):\\n\\n body = {\\n 'key': config_key,\\n 'value': value,\\n }\\n response = connection.post_obj_as_json('system/config', body).json()\\n config_value = response.get('result')\\n if config_value is None:\\n raise SAPCliError(\\\"gCTS response does not contain 'result'\\\")\\n\\n return config_value\",\n \"def __setattr__(self, key, value):\\n self._config.__setitem__(key, value)\",\n \"def propset(self, name, value, *args):\\r\\n d = py.path.local.mkdtemp() \\r\\n try: \\r\\n p = d.join('value') \\r\\n p.write(value) \\r\\n self._svn('propset', name, '--file', str(p), *args)\\r\\n finally: \\r\\n d.remove()\",\n \"def set_variable(self, name, value):\\n self.send_to_backend('set', name=name, value=value)\\n self.refresh_variable(name)\",\n \"def setProperty(*args):\",\n \"def setProperty(*args):\",\n \"def setProperty(*args):\",\n \"def setProperty(*args):\",\n \"def setProperty(*args):\",\n \"def __property_config__(self, model_class, property_name):\\n super(MemcacheReferenceProperty, self).__property_config__(model_class, property_name)\\n\\n if self.reference_class is _SELF_REFERENCE:\\n self.reference_class = self.data_type = model_class\\n\\n if self.collection_name is None:\\n self.collection_name = '%s_set' % (model_class.__name__.lower())\\n existing_prop = getattr(self.reference_class, self.collection_name, None)\\n if existing_prop is not None:\\n if not (isinstance(existing_prop, db._ReverseReferenceProperty) and\\n existing_prop._prop_name == property_name and\\n existing_prop._model.__name__ == model_class.__name__ and\\n existing_prop._model.__module__ == model_class.__module__):\\n raise DuplicatePropertyError('Class %s already has property %s '\\n % (self.reference_class.__name__,\\n self.collection_name))\\n setattr(self.reference_class,\\n self.collection_name,\\n db._ReverseReferenceProperty(model_class, property_name))\",\n \"def __setattr__ (self, name, value):\\n\\t\\ttry:\\n\\t\\t\\tself.__dict__[name] # Do not delete this line (it verifies the existence of an attribute)\\n\\t\\t\\t# Positioning of the existing attribute\\n\\t\\t\\tself.__dict__[name] = value\\n\\t\\texcept KeyError:\\n\\t\\t\\t# The attribute does not exist is probably value of the structure\\n\\t\\t\\tself.__dict__[\\\"value\\\"][name] = value\",\n \"def setProperty(self,prop=None):\\n objects = self.check()\\n if objects:\\n if prop is None:\\n res = askItems([['property',0]],\\n caption = 'Set Property Number for Selection (negative value to remove)')\\n if res:\\n prop = int(res['property'])\\n if prop < 0:\\n prop = None\\n for o in objects:\\n if hasattr(o,'setProp'):\\n o.setProp(prop)\\n self.draw()\",\n \"def set(self, name, value, autosave=True, override=True):\\n if self._is_section(name) and not isinstance(value, _Section):\\n raise SectionError(\\\"Cannot override section with value.\\\")\\n if isinstance(value, _Section):\\n if override:\\n self._config_obj[name] = {}\\n for key, _value in value._config_obj.items():\\n self[name].set(key, _value, autosave, override)\\n elif name not in self._config_obj or override:\\n self._config_obj[name] = value\\n if autosave:\\n self.save()\",\n \"def setValue(self, name, value):\\n values = self.__get('values')\\n values[name] = value\\n self.__set('values', values)\",\n \"def add_property(self, property):\\n # check input data type\\n if not isinstance(property, dict):\\n raise TypeError\\n # check data types of keys in dict\\n if not all([isinstance(key, str) for key in property.keys()]):\\n raise TypeError\\n # check that values are lists of strings\\n for key, value in property.items():\\n if isinstance(value, str):\\n property[key] = [value]\\n elif not isinstance(value, list):\\n raise TypeError\\n else:\\n if not all([isinstance(val, str) for val in value]):\\n raise TypeError\\n\\n # add properties to the dict\\n for key, value in property.items():\\n if key not in self.properties:\\n self.properties[key] = value\\n else:\\n self.properties[key] += value\\n self.properties[key] = list(set(self.properties[key]))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7744824","0.7589677","0.7511228","0.71817976","0.7180543","0.71250933","0.70207524","0.6867484","0.6805842","0.66848767","0.6684025","0.6615753","0.64751947","0.6462285","0.6445133","0.6340753","0.6315831","0.6308148","0.62673914","0.6257923","0.6245488","0.622961","0.6123482","0.6040454","0.59751207","0.59010977","0.58931476","0.58642673","0.58554286","0.5852848","0.58253753","0.581846","0.5810388","0.5737535","0.57112765","0.56629163","0.55839056","0.55604166","0.554588","0.55406266","0.553353","0.5528683","0.5444581","0.5422219","0.541916","0.5406026","0.53901714","0.5364961","0.53643215","0.53580654","0.5345323","0.53442943","0.5338469","0.5336238","0.5332302","0.5330189","0.5325056","0.5272518","0.52641696","0.52329105","0.5224203","0.52205557","0.5202875","0.51943207","0.51921034","0.51887286","0.5163683","0.516288","0.5157594","0.5145322","0.51066256","0.51038504","0.5099274","0.5099274","0.5096015","0.5090443","0.5087344","0.50820506","0.50810754","0.5068598","0.5063478","0.50585455","0.50545233","0.505417","0.504435","0.5028018","0.502171","0.5013491","0.4992848","0.49889082","0.49889082","0.49889082","0.49889082","0.49889082","0.49831074","0.49786824","0.49781156","0.49749288","0.49575105","0.4956257"],"string":"[\n \"0.7744824\",\n \"0.7589677\",\n \"0.7511228\",\n \"0.71817976\",\n \"0.7180543\",\n \"0.71250933\",\n \"0.70207524\",\n \"0.6867484\",\n \"0.6805842\",\n \"0.66848767\",\n \"0.6684025\",\n \"0.6615753\",\n \"0.64751947\",\n \"0.6462285\",\n \"0.6445133\",\n \"0.6340753\",\n \"0.6315831\",\n \"0.6308148\",\n \"0.62673914\",\n \"0.6257923\",\n \"0.6245488\",\n \"0.622961\",\n \"0.6123482\",\n \"0.6040454\",\n \"0.59751207\",\n \"0.59010977\",\n \"0.58931476\",\n \"0.58642673\",\n \"0.58554286\",\n \"0.5852848\",\n \"0.58253753\",\n \"0.581846\",\n \"0.5810388\",\n \"0.5737535\",\n \"0.57112765\",\n \"0.56629163\",\n \"0.55839056\",\n \"0.55604166\",\n \"0.554588\",\n \"0.55406266\",\n \"0.553353\",\n \"0.5528683\",\n \"0.5444581\",\n \"0.5422219\",\n \"0.541916\",\n \"0.5406026\",\n \"0.53901714\",\n \"0.5364961\",\n \"0.53643215\",\n \"0.53580654\",\n \"0.5345323\",\n \"0.53442943\",\n \"0.5338469\",\n \"0.5336238\",\n \"0.5332302\",\n \"0.5330189\",\n \"0.5325056\",\n \"0.5272518\",\n \"0.52641696\",\n \"0.52329105\",\n \"0.5224203\",\n \"0.52205557\",\n \"0.5202875\",\n \"0.51943207\",\n \"0.51921034\",\n \"0.51887286\",\n \"0.5163683\",\n \"0.516288\",\n \"0.5157594\",\n \"0.5145322\",\n \"0.51066256\",\n \"0.51038504\",\n \"0.5099274\",\n \"0.5099274\",\n \"0.5096015\",\n \"0.5090443\",\n \"0.5087344\",\n \"0.50820506\",\n \"0.50810754\",\n \"0.5068598\",\n \"0.5063478\",\n \"0.50585455\",\n \"0.50545233\",\n \"0.505417\",\n \"0.504435\",\n \"0.5028018\",\n \"0.502171\",\n \"0.5013491\",\n \"0.4992848\",\n \"0.49889082\",\n \"0.49889082\",\n \"0.49889082\",\n \"0.49889082\",\n \"0.49889082\",\n \"0.49831074\",\n \"0.49786824\",\n \"0.49781156\",\n \"0.49749288\",\n \"0.49575105\",\n \"0.4956257\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7238388"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":9099,"cells":{"query":{"kind":"string","value":"set_default_config() Saves default config to desired filename"},"document":{"kind":"string","value":"def set_default_config(self, filename):\n if os.path.isfile(filename):\n os.remove(filename)\n\n config = configparser.ConfigParser()\n default_cfg = {'config': {'database_name': 'manga.db',\n 'volume_limit': 128,\n 'series_per_page': 0,\n 'compact_list': 0,\n 'show_empty_series': False,\n 'default_to_gui': True}}\n\n config.read_dict(default_cfg)\n with open(filename, 'w') as config_ini:\n config.write(config_ini)\n\n # Reset class variables for config object as well\n self.config = config\n self.filename = filename\n self.database_name = 'manga.db'\n self.volume_limit = 128\n self.series_per_page = 0\n self.compact_list = False\n self.show_empty_series = False\n self.default_to_gui = 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 writeDefaultConfig(conffile='default.conf', defaults={}):\n if not os.path.exists(conffile):\n cp = createConfigParserfromDict(defaults, ['base'])\n cp.write(open(conffile,'w'))\n return conffile","def write_default_config():\n # TODO: BROKEN!\n config_path = pathlib.Path(xdg.BaseDirectory.xdg_config_home) / \"awiesm_bc\"\n config_file = config_path / DEFAULT_CONFIG_FILENAME\n if not os.path.isdir(config_path):\n os.makedirs(config_path)\n\n if not os.path.isfile(config_file):\n # TODO: write file\n pass","def write_default_config(self):\n if self.config_file:\n config_file = self.config_file\n else:\n config_file = os.path.join(self.config_dir, self.config_file_name + '.py')\n \n if os.path.exists(config_file) and not self.answer_yes:\n answer = ''\n def ask():\n prompt = \"Overwrite %s with default config? [y/N]\" % config_file\n try:\n return raw_input(prompt).lower() or 'n'\n except KeyboardInterrupt:\n print('') # empty line\n return 'n'\n answer = ask()\n while not answer.startswith(('y', 'n')):\n print(\"Please answer 'yes' or 'no'\")\n answer = ask()\n if answer.startswith('n'):\n return\n \n config_text = self.generate_config_file()\n if isinstance(config_text, bytes):\n config_text = config_text.decode('utf8')\n print(\"Writing default config to: %s\" % config_file)\n ensure_dir_exists(os.path.abspath(os.path.dirname(config_file)), 0o700)\n with open(config_file, mode='w') as f:\n f.write(config_text)","def write_starter_configfile(\n basedir=None,\n default_configfile_name=DEFAULT_CONFIGFILE_NAME,\n default_config_yaml=DEFAULT_CONFIG_YAML,\n):\n if not basedir:\n basedir = Path.cwd()\n configfile_pathname = Path(basedir) / default_configfile_name\n if os.path.exists(configfile_pathname):\n raise ConfigError(\n f\"Found existing {str(configfile_pathname)} - delete to re-generate.\"\n )\n with open(configfile_pathname, \"w\", encoding=\"utf-8\") as outfile:\n outfile.write(default_config_yaml)\n print(f\"Wrote config defaults (for editing) to: {str(configfile_pathname)}\")","def __create_default_config(self):\n if not os.path.exists(self.__configfile):\n path=os.path.dirname(self.__configfile)\n try:\n os.makedirs(path)\n except:\n pass\n if os.path.exists(path):\n self.save(defaults=True)","def set_as_default (self):\n\t\ttry:\n\t\t\tself.config.set('Global', 'Default', self.currentAccount.data['name'])\n\t\texcept ConfigParser.NoSectionError:\n\t\t\tself.setup_config()\n\t\t\tself.config.set('Global', 'Default', self.currentAccount.data['name'])\n\t\tself.config.write(open(self.configFile, 'w'))","def createConfig():\n\twith open(configPath, 'w', encoding='utf-8') as file:\n\t\tjson.dump(default_config, file, indent=3)","def add_default_settings_config(self):\n config = {\n mconst.DEF_SETTINGNAME_default_logfilename: mconst.DEF_SETTINGVAL_default_logfilename_defaultvalue,\n }\n self.settings.merge_settings_key(mconst.DEF_SETTINGSEC_config, config)","def save_config(conf, default):\n print()\n if yes_no('Would you like to save your configuration?'):\n name = simple_response(\n 'What would you like to name your configuration?')\n path = ask_path(\n 'Please enter the path you would like your configuration saved to',\n default=default)\n file_path = os.path.join(path, name)\n if file_path.find('.json') == -1:\n file_path += '.json'\n with open(file_path, 'w+') as f:\n json.dump(conf, f, indent=4)","def create_default(cls, env: str, config_f: Path) -> None:\n # create default file\n _config = Config()\n _config.save(env)\n log.info(f\"Created config file at {config_f}\")","def run(self):\n write_config(self.filename)\n print('Wrote default config to', self.filename)","def dump_default_config():\n output = \"PythiaPlotter_config.py\"\n log.info(\"Dumping config to %s\", output)\n import pythiaplotter.default_config as dc\n shutil.copy(dc.__file__.replace(\".pyc\", \".py\"), output)","def _write_default_config(self, force=False):\n\t\t\n\t\tif self.configfilepath is not None:\n\t\t\tlogger.debug(\"You use the existing config file %s, I don't have to write one.\" % \\\n (self._get_config_filepath()))\n\t\t\treturn\n\t\t\n\t\tif force or not os.path.exists(self._get_config_filepath()):\t\n\t\t\tp = subprocess.Popen([self.sexpath, \"-dd\"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n\t\t\tout, err = p.communicate()\n\t\t\tif err != \"\":\n\t\t\t\tlogger.warning(\"Ouch, SExtractor complains :\")\n\t\t\t\tlogger.warning(err)\n\t\t\tf = open(self._get_config_filepath(), 'w')\n\t\t\tf.write(out.decode(encoding='UTF-8'))\n\t\t\tf.close()\n\t\t\tlogger.debug(\"Wrote %s\" % (self._get_config_filepath()))\n\t\telse:\n\t\t\tlogger.debug(\"Default config file already exists, I don't overwrite it.\")","def init_default_config_file_if_nonexistent(package, default_config):\n config_file = os.path.join(conf.PAULA_USER_CONFIG_DIR, package + conf.CONFIG_EXTENSION)\n debug('config_file = ' + config_file)\n if not os.path.exists(config_file):\n debug('making: \\\"' + config_file+ '\\\"')\n shutil.copyfile(default_config, config_file)","def load(filename, defaultConfig={}, writeIfNonExistent=True, quitIfNonExistent=False):\n global _loaded\n assert filename and isinstance(filename, basestring)\n\n #all keys and values in defaultConfig must be strings\n #(to make it match what would be read in by ConfigParser)\n #lets error out if we find a key or value that isn't a string\n for (key, value) in defaultConfig.iteritems():\n if not isinstance(key, basestring):\n raise KeyError(\"Invalid defaultConfig: key \\\"%s\\\" is not a string\" % str(key))\n if not isinstance(value, basestring):\n raise ValueError(\"Invalid defaultConfig: value of key \\\"%s\\\" (\\\"%s\\\") is not a string\" \n % (str(key), str(value)))\n\n _loaded = defaultConfig.copy()\n \n configFileExists = os.path.exists(filename)\n \n #If we just want to \"load\" the default configuration\n if writeIfNonExistent and not configFileExists:\n log.msg(\"Configuration file \\\"%s\\\" does not exist...\" % filename, lvl='w', ss='ss_configfile')\n try:\n write(filename)\n except:\n raise\n \n #if quitIfNonExistent is set, keep going to the next block of code\n #so we can quit out properly\n if not quitIfNonExistent:\n return\n\n if quitIfNonExistent and not configFileExists:\n #print different messages depending on if the default\n #config file was written or not\n if writeIfNonExistent:\n log.msg(\"Quitting as configuration file did not exist. Please \"\n \"edit the default configuration that has been written \"\n \"to \\\"%s\\\" to suit your environment and start the program \"\n \"again.\" % filename, lvl='c', ss='ss_configfile')\n sys.exit(0)\n else:\n log.msg(\"Quitting as configuration file \\\"%s\\\" does not exist.\"\n \" Please create this file and try again.\" % filename)\n sys.exit(1)\n\n log.msg(\"Reading configuration from \\\"%s\\\"...\" % filename, lvl='i', ss='ss_configfile')\n _loaded = simpleReadConfigFile(filename, useLogging=True,\n level=consts.LOGLVL_DEBUG3)\n \n log.msg(\"ACTIVE CONFIGURATION: \" + str(_loaded),\n lvl='d2', ss='ss_configfile')","def setup(self):\n\n default_config = self.read()\n\n self.write(default_config)","def _set_config():\n\n\tdebug_msg = \"load default config yaml file\"\n\tlogger.debug(debug_msg)\n\n\tconfig_file_parser(paths.CONFIG_FILE, override_options=True)","def default_config_file(self):\n return DEFAULT_CONFIG_FILEPATH","def antenny_config_make_default(self):\n return self.antenny_config.save_as_default_config()","def servo_make_default(self):\n self.servo_config.save_as_default_config()","def save(self,filename=None,defaults=False):\n # Check filename or use default filename\n if not filename:\n if self.__configfile:\n filename=self.__configfile\n else:\n raise Exception(_('EVOGTK: Need a filename for saving preferences'))\n # Set widget values on config parser\n for section in self.__optionstruct:\n for option in self.__optionstruct[section]:\n widgets=self.__optionstruct[section][option][1]\n # Get default value\n value=vars(self)[section].get_option(option)\n if not defaults and widgets:\n # Use widget value\n val=self.__guidata.__getattr__(widgets[0])\n if val:\n value=val\n # Create section in file if not exists\n if not self.__config.has_section(section):\n self.__config.add_section(section)\n value=vars(self)[section].set_option(option,value)\n # Write config to file\n fd=open(filename,'wb')\n self.__config.write(fd)\n fd.close()","def generateDefaultConfig(self):\n\n\t\t# Open config.ini in write mode\n\t\tf = open(self.fileName, \"w\")\n\n\t\t# Set keys to config object\n\t\tself.config.add_section(\"db\")\n\t\tself.config.set(\"db\", \"host\", \"localhost\")\n\t\tself.config.set(\"db\", \"username\", \"root\")\n\t\tself.config.set(\"db\", \"password\", \"\")\n\t\tself.config.set(\"db\", \"database\", \"ripple\")\n\t\tself.config.set(\"db\", \"pingtime\", \"600\")\n\n\t\tself.config.add_section(\"server\")\n\t\tself.config.set(\"server\", \"server\", \"tornado\")\n\t\tself.config.set(\"server\", \"host\", \"0.0.0.0\")\n\t\tself.config.set(\"server\", \"port\", \"5001\")\n\t\tself.config.set(\"server\", \"localizeusers\", \"1\")\n\t\tself.config.set(\"server\", \"outputpackets\", \"0\")\n\t\tself.config.set(\"server\", \"outputrequesttime\", \"0\")\n\t\tself.config.set(\"server\", \"timeoutlooptime\", \"100\")\n\t\tself.config.set(\"server\", \"timeouttime\", \"100\")\n\n\t\tself.config.add_section(\"flask\")\n\t\tself.config.set(\"flask\", \"threaded\", \"1\")\n\t\tself.config.set(\"flask\", \"debug\", \"0\")\n\t\tself.config.set(\"flask\", \"logger\", \"0\")\n\n\t\tself.config.add_section(\"ci\")\n\t\tself.config.set(\"ci\", \"key\", \"changeme\")\n\n\t\t# Write ini to file and close\n\t\tself.config.write(f)\n\t\tf.close()","def write_config(config_filename, config=default_config):\n comments=\"\"\n if config==default_config:\n comments+=\"# %s \\n\" % version.version_string\n comments+=\"# This is the default config file\\n\"\n comments+=\"# Generated on %s \\n\" % time.strftime('%x %X %Z')\n comments+=\"# Visit %s for more informations \\n\" % version.project_url\n c=SafeConfigParser()\n f=open(config_filename,'w')\n f.write(comments+\"\\n\")\n for section in config.items():\n name=section[0]\n values=section[1]\n c.add_section(name)\n for value in values.items():\n c.set(name, value[0], value[1])\n c.write(f)\n f.flush()\n f.close()","def save_config(self, new_config, filename=None):\n self.cfg.update(new_config)\n if filename is None:\n self.cfg.filename = self.cfg_filename\n else:\n self.cfg.filename = filename\n self.cfg.write()\n logger.info(\"Config file %s written out\" % self.cfg.filename)","def write_config(self, filename):\n self.config.filename = filename\n self.config.write()","def set_config_all_to_defaults():\n logging.debug(\"Creating default config\")\n for section in all_defaults:\n set_config_section_to_defaults(section)\n global config_changed\n config_changed = True","def save_default_connections_file():\n if os.path.exists(DEFAULT_CONNECTIONS_FILE):\n if os.path.exists(DEFAULT_CONNECTIONS_FILE_BAK):\n os.remove(DEFAULT_CONNECTIONS_FILE_BAK)\n os.rename(DEFAULT_CONNECTIONS_FILE, DEFAULT_CONNECTIONS_FILE_BAK)","def create_default_config(self, parser):\n parser.add_section('irc')\n parser.set('irc', 'channels', '')\n \n # create the full path, and the file\n try:\n os.makedirs(self.config_dir_path, mode=0700)\n except OSError:\n pass\n file_resource = open(self.config_file_path, 'w')\n parser.write(file_resource)","def create_default_config():\n import codecs\n config = ConfigParser.SafeConfigParser()\n config.readfp(StringIO(DEFAULT_CONFIG))\n\n # Load user settings\n filename = get_user_config_filename()\n if not os.path.exists(filename):\n from wizard import setup_wizard\n setup_wizard(config)\n else:\n try:\n fi = codecs.open(filename, 'r', encoding='utf-8')\n config.readfp(fi)\n finally:\n fi.close()\n return config","def overrideCurrentConfiguration(self):\n if not self._currentConfiguration:\n self.saveNewConfiguration()\n else:\n self._saveToFilePath(self._currentConfiguration)","def save_defaults(self, overwrite=False):\r\n for (section, option), value in self.defaults.iteritems():\r\n if value is None:\r\n continue\r\n if section not in self.__config:\r\n self.__config[section] = {}\r\n if overwrite or option not in self.__config[section]:\r\n self.__config[section][option] = value\r\n self.save()","def get_default_config_file() -> Path:\n return get_path_to_pyflow() / \"pyflow\" / \"conf\" / CONFIG_FILE","def write_default_config(output_config: Pathlike, feature_type: str):\n create_default_feature_extractor(feature_type).to_yaml(output_config)","def SaveConfig(self):\n config_value = getattr(self, APPDATA)\n path_value = config_value.AbsolutePaths[0]\n default_cfg_file = os.path.join(path_value, CONFIG_FILE_NAME)\n temp_file = default_cfg_file + '.TEMP'\n if os.path.exists(default_cfg_file):\n json.dump(type(self)._CURRENT_CONFIG,\n open(temp_file.lower(),\n mode='w'),\n cls=ConfigEncoder,\n sort_keys=False,\n indent=4)\n EnsureBackup(temp_file, default_cfg_file)\n else:\n if not os.path.isdir(path_value):\n os.mkdir(path_value)\n json.dump(type(self)._CURRENT_CONFIG,\n open(default_cfg_file.lower(),\n mode='w'),\n cls=ConfigEncoder,\n sort_keys=False,\n indent=4)","def build_default_cfg():\n with open(Daemon.CONFIG_FILEPATH, 'wb') as fo:\n json.dump(Daemon.DEF_CONF, fo, skipkeys=True, ensure_ascii=True, indent=4)\n return Daemon.DEF_CONF","def initConfig(defaults, filepath=None):\n result = False\n if filepath is None:\n filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), \"res/\", \"config.ini\")\n if not os.path.exists(filepath):\n config = ConfigParser.ConfigParser(defaults)\n result = Helpers.saveConfig(config, filepath)\n return result","def get_default_config(self):\n return config.read(pathlib.Path(__file__).parent / \"ext.conf\")","def create_default_sensor_config_file(self, sensor_config_file_path):\n data = dict()\n data[constants.SensorConfigurationKeys.LIDAR] = \\\n constants.DEFAULT_LIDAR_CONFIGURATION\n data[constants.SensorConfigurationKeys.LIDAR_OVERLAY] = \\\n constants.DEFAULT_LIDAR_OVERLAY_CONFIGURATION\n with open(sensor_config_file_path, \"w\") as outfile:\n json.dump(data, outfile, indent=4,)","def set_config_defaults(config):\n new_config = config.copy()\n\n new_config.setdefault(\"window_title\", \"Materials Cloud Tool\")\n new_config.setdefault(\n \"page_title\",\n \"<PLEASE SPECIFY A PAGE_TITLE AND A WINDOW_TITLE IN THE CONFIG FILE>\",\n )\n\n new_config.setdefault(\"custom_css_files\", {})\n new_config.setdefault(\"custom_js_files\", {})\n new_config.setdefault(\"templates\", {})\n\n return new_config","def set_last_config(self, config_name):\n with open(FILEPATH_MANAGER.get_last_config_file_path(), 'w') as f:\n f.write(config_name + \"\\n\")","def default(path: str = 'setings.INI'):\n Setings._delete_setings(path)\n Setings._create_default_setting(path)","def save_config(**kwargs):\n if kwargs == {}:\n kwargs = config._config\n current_config = _load_config()\n current_config.update(**kwargs)\n # write to disk\n fname = _get_config_fname()\n if fname is None:\n raise RuntimeError('config filename could not be determined')\n if not op.isdir(op.dirname(fname)):\n os.mkdir(op.dirname(fname))\n with open(fname, 'w') as fid:\n json.dump(current_config, fid, sort_keys=True, indent=0)","def set_default_profile(self):\n profile = textwrap.dedent(\n \"\"\"\n config:\n boot.autostart: \"true\"\n description: Default LXD profile\n devices:\n eth0:\n name: eth0\n nictype: bridged\n parent: conjureup1\n type: nic\n eth1:\n name: eth1\n nictype: bridged\n parent: conjureup0\n type: nic\n root:\n path: /\n pool: default\n type: disk\n name: default\n \"\"\")\n with NamedTemporaryFile(mode='w', encoding='utf-8',\n delete=False) as tempf:\n utils.spew(tempf.name, profile)\n out = utils.run_script(\n 'cat {} |conjure-up.lxc profile edit default'.format(\n tempf.name))\n if out.returncode != 0:\n raise Exception(\"Problem setting default profile: {}\".format(\n out))","def load_config_with_defaults(config_path):\n config = neat.Config(\n neat.DefaultGenome,\n neat.DefaultReproduction,\n neat.DefaultSpeciesSet,\n neat.DefaultStagnation,\n config_path\n )\n return config","def load_default_config_file(filename: str) -> str:\n try:\n raw_contents = resource_string(__name__, 'configuration/' + filename)\n except FileNotFoundError:\n raise BscanConfigError(\n 'Unable to find default configuration file `' + filename + '`')\n return raw_contents.decode('utf-8')","def config_skeleton():\n config = Config()\n config.set_to_default()\n config.save()","def saveCurrentConfig():\n cf = ConfigParser.ConfigParser()\n cf.add_section(\"dir_config\")\n cf.set(\"dir_config\", \"7zpath\", SW_CONFIG['7zpath'])\n cf.set(\"dir_config\", \"sharefolder\", SW_CONFIG['sharefolder'])\n cf.set(\"dir_config\", \"distpath\", SW_CONFIG['distpath'])\n cf.add_section(\"sw_config\")\n cf.set(\"sw_config\", \"version\", SW_CONFIG['sw_version'])\n cf.set(\"sw_config\", \"startup\", SW_CONFIG['startup'])\n cf.add_section(\"run_config\")\n cf.set(\"run_config\", \"pop\", RUN_CONFIG['pop'])\n cf.set(\"run_config\", \"backup\", RUN_CONFIG['backup'])\n cf.add_section(\"hook_config'\")\n for k, v in HOOK_CONFIG:\n cf.set(\"hook_config\", k, v)\n fp = open(CONFIG_FILE, \"w\")\n cf.write(fp)\n fp.close()","def setup_configuration_file(self):\n\n with open(self.config_path, \"w+\") as f_config:\n\n f_config.write(get_configuration_file_form())","def generate_config(args):\n default_config = resource_string('webrpg', 'scripts/templates/default_config.txt').decode('utf-8')\n if args.sqla_connection_string:\n default_config = default_config.replace('%(sqlalchemy_url)s', args.sqla_connection_string)\n else:\n default_config = default_config.replace('%(sqlalchemy_url)s', get_user_parameter('SQL Alchemy Connection String', 'sqlite:///%(here)s/pyire_test.db'))\n\n with open(args.filename, 'w') as out_f:\n out_f.write(default_config)","def save():\n\n env.config.save(env.config_file)","def default_page_config(self, default_page_config):\n\n self._default_page_config = default_page_config","def test_config_create_file_with_default_dict(get_root, get_empty_config, monkeypatch):\n path = os.path.join(get_root, 'res', 'non_existent.yml')\n test_dict = {'this': 'test', 'test': 'de'}\n monkeypatch.setattr(DeviceConfig, 'minimal_essential_conf', test_dict)\n cfg = get_empty_config(DeviceConfig, path)\n\n with open(path, 'r') as fh:\n content = yaml.load(fh, Loader=get_yaml_loader())\n\n assert cfg.config_path == path, \"config path is incorrect\"\n assert cfg.minimal_essential_conf == test_dict, \"bad minimal running\"\n assert content == test_dict, \"config not written to file\"\n assert cfg.data == test_dict, \"default config not loaded from file\"","def save_config(self):\n config.save_config(self.config, self.config_file)","def set_default_paths(args):\n filename = os.path.join(os.path.expanduser('~'), '.gfail_defaults')\n if os.path.exists(filename):\n D = ConfigObj(filename)\n else:\n D = {}\n if args.data_path is not None:\n if args.data_path == 'reset':\n D.pop('data_path')\n else:\n # check that it's a valid path\n if os.path.exists(args.data_path):\n D.update({'data_path': args.data_path})\n else:\n print('Path given for data_path does not exist: %s'\n % args.data_path)\n if args.output_filepath is not None:\n if args.output_filepath == 'reset':\n D.pop('output_filepath')\n else:\n # check that it's a valid path\n if os.path.exists(args.output_filepath):\n D.update({'output_filepath': args.output_filepath})\n else:\n print('Path given for output_filepath does not exist: %s'\n % args.output_filepath)\n if args.config_filepath is not None:\n if args.config_filepath == 'reset':\n D.pop('config_filepath')\n else:\n # check that it's a valid path\n if os.path.exists(args.config_filepath):\n D.update({'config_filepath': args.config_filepath})\n else:\n print('Path given for config_filepath does not exist: %s'\n % args.config_filepath)\n if args.popfile is not None:\n if args.popfile == 'reset':\n D.pop('popfile')\n else:\n # check that it's a valid path\n if os.path.exists(args.popfile):\n D.update({'popfile': args.popfile})\n else:\n print('Path given for population file does not exist: %s'\n % args.popfile)\n if args.trimfile is not None:\n if args.trimfile == 'reset':\n D.pop('trim')\n else:\n # check that it's a valid path and that it's a shapefile\n if os.path.exists(args.trimfile):\n filename4, fileextension = os.path.splitext(args.trimfile)\n if fileextension == '.shp':\n D.update({'trimfile': args.trimfile})\n else:\n print('Ocean trimming file is not a shapefile: %s'\n % args.trimfile)\n else:\n print('Path given for ocean trimming file does not exist: %s'\n % args.trimfile)\n if args.pdl_config is not None:\n if args.pdl_config == 'reset':\n D.pop('pdl_config')\n else:\n # check that it's a valid path\n if os.path.exists(args.pdl_config):\n D.update({'pdl_config': args.pdl_config})\n else:\n print('Path given for pdl config file does not exist: %s'\n % args.pdl_config)\n if args.log_filepath is not None:\n if args.log_filepath == 'reset':\n D.pop('log_filepath')\n else:\n # check that it's a valid path\n if os.path.exists(args.log_filepath):\n D.update({'log_filepath': args.log_filepath})\n else:\n print('Path given for log file does not exist: %s'\n % args.log_filepath)\n if args.dbfile is not None:\n if args.dbfile == 'reset':\n D.pop('dbfile')\n else:\n # check that it's a valid path (file itself doesnt have to exist)\n if os.path.exists(os.path.dirname(args.dbfile)):\n D.update({'dbfile': args.dbfile})\n else:\n print('Path given for database file does not exist: %s'\n % args.dbfile)\n\n print('New default paths set.\\n')\n\n if D:\n C = ConfigObj(D)\n C.filename = filename\n C.write()\n list_default_paths()\n else:\n print('no defaults set because no paths were input\\n')","def saveConfig(self, name=None):\n\n configDir = self.mwGlob['configDir']\n\n if self.config.get('profileName', '') == 'config':\n if 'reference' in self.config:\n del self.config['reference']\n\n # default saving for reference\n if name is None:\n name = self.config.get('reference', 'config')\n\n fileName = configDir + '/' + name + '.cfg'\n with open(fileName, 'w') as outfile:\n json.dump(self.config,\n outfile,\n sort_keys=True,\n indent=4)\n # if we save a reference first, we have to save the config as well\n if name != 'config':\n fileName = configDir + '/config.cfg'\n with open(fileName, 'w') as outfile:\n json.dump(self.config,\n outfile,\n sort_keys=True,\n indent=4)\n return True","def restore_default_connections_file():\n if os.path.exists(DEFAULT_CONNECTIONS_FILE_BAK):\n if os.path.exists(DEFAULT_CONNECTIONS_FILE):\n os.remove(DEFAULT_CONNECTIONS_FILE)\n os.rename(DEFAULT_CONNECTIONS_FILE_BAK, DEFAULT_CONNECTIONS_FILE)","def bootstrap_default():\n\treturn default_configuration","def init_config(args=None):\n if args is None:\n args = parser_args()\n\n # Set the experiment directory\n exp_dir = args.exp_dir\n if exp_dir is None:\n exp_dir = 'experiment/' + args.model_name + '/' + osp.splitext(osp.basename(args.default_config_path))[0]\n\n # copy file\n dst_config_path = osp.join(exp_dir, osp.basename(args.default_config_path))\n src_copy_to_dst(args.default_config_path, dst_config_path)\n\n # overwrite\n if args.ow_config_path != 'None':\n print('ow_config_path is: {}'.format(args.ow_config_path))\n overwrite_config_file(dst_config_path, ow_file=args.ow_config_path)\n if args.ow_str != 'None':\n print('ow_str is: {}'.format(args.ow_str))\n overwrite_config_file(dst_config_path, ow_str=args.ow_str)\n\n # import config\n cfg = import_file(dst_config_path).cfg\n\n # Set log experiment dir\n cfg.log.exp_dir = exp_dir\n return cfg","def save_defaults(self):\n\n pass","def saveNewConfiguration(self):\n selection = tk.filedialog. \\\n asksaveasfilename(title=\"Save CHUM configuration\")\n if selection:\n self._currentConfiguration = selection\n self._saveToFilePath(selection)","def saveSettignsAsDefault(self, config = None):\n if config:\n resp = self.setPineAPSettings(config)\n if (resp['error']):\n return resp\n return self.request('saveAsDefault')","def save_config(self, filename: str=None):\n if not filename:\n filename = self.config_file\n with open(filename, \"w\") as file_object:\n json.dump(self.config, file_object, indent=4, sort_keys=True)","def save_configuration(config):\n with open(cwd + '/configuration.pickle', 'wb') as handle:\n pickle.dump(config, handle, protocol=pickle.HIGHEST_PROTOCOL)","def default():\n raise NotImplementedError(\"Pvwattsv7 default file no longer exists!\")","def test_get_config(default_config, tmp_path):\n abcconfig.write_config(default_config, configpath=tmp_path)\n config = abcconfig.get_config(configpath=tmp_path)\n assert config == default_config","def default_configfile():\n dirname=None\n if os.getenv(\"HOME\"):\n dirname=os.getenv(\"HOME\")\n elif os.getenv(\"USERPROFILE\"):\n dirname=os.getenv(\"USERPROFILE\")\n\n else:\n raise FattyException(\"No HOME or USERPROFILE variable set, unable to determine default config file\")\n\n return os.path.join(dirname,\".fattybugs\")","def __init__(self, name, defaults = {} ):\n self.defaults = defaults\n self.filename = os.path.expanduser(name)+\".ini\"\n self.conf = {}\n self.reset()\n if os.path.exists(self.filename):\n self.load()","def set_default_paths(args):\n filename = os.path.join(os.path.expanduser('~'), '.gfail_defaults')\n if os.path.exists(filename):\n D = ConfigObj(filename)\n else:\n D = {}\n if args.data_path is not None:\n if args.data_path == 'reset':\n D.pop('data_path')\n else:\n # check that it's a valid path\n if os.path.exists(args.data_path):\n D.update({'data_path': args.data_path})\n else:\n print('Path given for data_path does not exist: %s' % args.data_path)\n if args.output_filepath is not None:\n if args.output_filepath == 'reset':\n D.pop('output_filepath')\n else:\n # check that it's a valid path\n if os.path.exists(args.output_filepath):\n D.update({'output_filepath': args.output_filepath})\n else:\n print('Path given for output_filepath does not exist: %s' % args.output_filepath)\n if args.config_filepath is not None:\n if args.config_filepath == 'reset':\n D.pop('config_filepath')\n else:\n # check that it's a valid path\n if os.path.exists(args.config_filepath):\n D.update({'config_filepath': args.config_filepath})\n else:\n print('Path given for config_filepath does not exist: %s' % args.config_filepath)\n if args.mapconfig is not None:\n if args.mapconfig == 'reset':\n D.pop('mapconfig')\n else:\n # check that it's a valid path\n if os.path.exists(args.mapconfig):\n D.update({'mapconfig': args.mapconfig})\n else:\n print('Path given for mapconfig does not exist: %s' % args.mapconfig)\n if args.mapdata_filepath is not None:\n if args.mapdata_filepath == 'reset':\n D.pop('mapdata_filepath')\n else:\n # check that it's a valid path\n if os.path.exists(args.mapdata_filepath):\n D.update({'mapdata_filepath': args.mapdata_filepath})\n else:\n print('Path given for mapdata_filepath does not exist: %s' % args.mapdata_filepath)\n\n if D:\n C = ConfigObj(D)\n C.filename = filename\n C.write()\n list_default_paths()\n else:\n print('no defaults set because no paths were input')","def _create_default_config(self):\n self.options.setdefault('options.admin_passwd', '')\n sys.path.append(self.openerp_dir)\n sys.path.extend([egg.location for egg in self.ws])\n from openerp.tools.config import configmanager\n configmanager(self.config_path).save()","def reload_default(self, write=True, backup=True, how='right', how_section=None, sections=None):\r\n # self._cfg = self.default_config.deepcopy()\r\n self._path = self._default_path.copy()\r\n dico = self.default_config.deepcopy()\r\n sections = {sections} if isinstance(sections, str) else sections\r\n n_dico = dico if sections is None else {k: dico[k] for k in sections & dico.keys()}\r\n self.merge(n_dico, how=how, how_section=how_section, inplace=True)\r\n if write:\r\n self.save_config(overwrite=True, backup=backup)\r\n logger.info(\"Configuration reloaded and saved to '{}'.\".format(self._path))\r\n else:\r\n logger.info(\"Configuration reloaded.\")","def saveConfig():\n with open(_CONFIG_FNM, 'w') as configfile:\n CONFIG_DICT.write(configfile,\n space_around_delimiters=True)","def save_config_file(self):\n wkdir = Path(self.config_dict[\"outputdir\"])\n config_filename = str(wkdir / f\"{self.config_dict['name']}.json\")\n save_config(self.config_dict, config_filename)","def set_default_save_location(self):\n home = os.path.expanduser(\"~\")\n self.path = home+'\\\\Desktop\\\\'\n filename = datetime.datetime.now().strftime(\"%Y-%m-%d_%H-%M\")+'.csv'\n self.full_file_path = self.path+filename\n self.settings['csv_save_path'] = self.full_file_path\n self.firstopened = True","def save(self):\r\n with open(self.filename, 'wb') as configfile:\r\n self.write(configfile)","def save_config() -> None:\n with open(_config_file, \"w\", newline=\"\") as config_file:\n json.dump(_config, config_file, indent=4)\n config_file.truncate()","def UnsetWiredDefault(self):\n config = ConfigParser.ConfigParser()\n config.read(self.wired_conf)\n profileList = config.sections()\n for profile in profileList:\n if config.has_option(profile, \"default\"):\n if misc.to_bool(config.get(profile, \"default\")):\n config.set(profile, \"default\", False)\n config.write(open(self.wired_conf, \"w\"))\n self.SaveWiredNetworkProfile(profile)","def add_defaults(cls, defaults):\n defaults.wallet = bittensor.Config()\n defaults.wallet.name = os.getenv('BT_WALLET_NAME') if os.getenv('BT_WALLET_NAME') != None else 'default'\n defaults.wallet.hotkey = os.getenv('BT_WALLET_HOTKEY') if os.getenv('BT_WALLET_HOTKEY') != None else 'default'\n defaults.wallet.path = os.getenv('BT_WALLET_PATH') if os.getenv('BT_WALLET_PATH') != None else '~/.bittensor/wallets/'","def save(self):\n file = open(self.path, 'w')\n self.config.write(file)\n file.close()","def get_default_config_filename():\n if 'PYWREN_CONFIG_FILE' in os.environ:\n config_filename = os.environ['PYWREN_CONFIG_FILE']\n # FIXME log this\n\n elif os.path.exists(\".pywren_config\"):\n config_filename = os.path.abspath('.pywren_config')\n\n else:\n config_filename = get_default_home_filename()\n\n return config_filename","def antenny_config_load_default(self):\n return self.antenny_config.load_default_config()","def default(config_data=None): \n if not config_data:\n if 'PYWREN_CONFIG' in os.environ:\n config_data = json.loads(os.environ.get('PYWREN_CONFIG'))\n else:\n config_filename = get_default_config_filename()\n if config_filename is None:\n raise ValueError(\"could not find configuration file\")\n \n config_data = load(config_filename)\n \n # Apply defualt values\n if 'storage_backend' not in config_data:\n config_data['storage_backend'] = DEFAULT_STORAGE_BACKEND \n if 'pywren' not in config_data:\n config_data['pywren'] = dict()\n config_data['pywren']['storage_bucket'] = COS_BUCKET_DEFAULT\n config_data['pywren']['storage_prefix'] = COS_PREFIX_DEFAULT\n elif 'storage_bucket' not in config_data['pywren']:\n config_data['pywren']['storage_bucket'] = COS_BUCKET_DEFAULT\n elif 'storage_prefix' not in config_data['pywren']:\n config_data['pywren']['storage_prefix'] = COS_PREFIX_DEFAULT\n if 'action_name' not in config_data['ibm_cf']:\n config_data['ibm_cf']['action_name'] = CF_ACTION_NAME_DEFAULT\n \n return config_data","def test_write_config(default_config, tmp_path):\n testpath = Path(tmp_path, \"write_config\")\n testpath.mkdir()\n abcconfig.write_config(default_config, configpath=testpath)\n assert Path(testpath, \"config.yml\").exists()","def save_default_environment(\n environment=None,\n cwd=None\n):\n env_file = get_local_default_file(cwd=cwd)\n with open(env_file, 'w') as f_out:\n f_out.write(f'{str(environment)}\\n')\n return True","def default_configfile(self):\r\n config = None\r\n for path in self.searchpaths:\r\n if os.path.exists(path):\r\n config = path\r\n break\r\n if config is None and self.require_configfile:\r\n self.usage('No config file found at default paths (%s); '\r\n 'use the -c option to specify a config file '\r\n 'at a different path' % ', '.join(self.searchpaths))\r\n return config","def save_config(cp, cfile):\n cp['DEFAULT'] = {\n 'last': datetime.datetime.utcnow().replace(tzinfo=pytz.utc).isoformat()\n\n }\n with open(cfile, 'w') as cfh:\n cp.write(cfh)","def default_config_yaml(cls):\n return DEFAULT_CONFIG","def get_config_filepath(config: configs.Config) -> str:\n return os.path.join(config.model_training.dir_out, configs.DEFAULT_FILENAME_CONFIG)","def save_config(config, filename=None):\n if filename is None:\n filename = CONFIG_FN\n with open(filename, \"w\", encoding=\"utf-8\") as fh:\n json.dump(\n config,\n fh,\n sort_keys=True,\n indent=4,\n separators=(\",\", \": \"),\n )","def save():\n print(\"Saving config file..\")\n\n res = yaml.round_trip_dump(_conf, indent=2, block_seq_indent=1)\n\n with open(__config_file, 'w', encoding='utf-8') as stream:\n stream.write(res)","def setup_logging(save_dir, log_config='logger/logger_config.json', default_level=logging.INFO):\n log_config = Path(log_config)\n if log_config.is_file():\n config = read_json(log_config)\n # modify logging paths based on run config\n for _, handler in config['handlers'].items():\n if 'filename' in handler:\n handler['filename'] = str(save_dir / handler['filename'])\n\n logging.config.dictConfig(config)\n else:\n print(\"Warning: logging configuration file is not found in {}.\".format(log_config), file=sys.stderr)\n logging.basicConfig(level=default_level)","def test_set_default_config(qibuild_action, build_worktree):\n qibuild_action(\"add-config\", \"foo\", \"--default\")\n assert build_worktree.default_config == \"foo\"","def add_config(config_name, params, config_file=None, make_default=True):\n\n if config_file is None:\n config_file = pkgrs.resource_filename('latools', 'latools.cfg')\n cf = configparser.ConfigParser()\n cf.read(config_file)\n\n # if config doesn't already exist, create it.\n if config_name not in cf.sections():\n cf.add_section(config_name)\n # iterate through parameter dict and set values\n for k, v in params.items():\n cf.set(config_name, k, v)\n # make the parameter set default, if requested\n if make_default:\n cf.set('DEFAULT', 'default_config', config_name)\n\n cf.write(open(config_file, 'w'))\n\n return","def _write_config(self, config_path: Path):\n with open(config_path, \"w\") as f:\n json.dump(self.config_overrides, f)","def save(config, filename=None):\n filename = add_directory(filename or 'configure.json')\n directory = os.path.dirname(filename)\n if not os.path.exists(directory):\n os.makedirs(directory, 0o700)\n with open(filename, \"w\") as f:\n json.dump(config, f, indent=2, sort_keys=True)","def saveConfig(self):\n newPath = self.newFolderPath.text()\n config.set(\"saveLocation\", str(newPath))\n config.save()\n self.reloadSettings()","def init_cfg(input_path, quiet):\n config_file = getConfigPath(input_path)\n\n if not os.path.exists(config_file) or quiet:\n confirm_overwrite = True\n else:\n confirm_overwrite = click.confirm(\n '\\n{} already exists. Do you want to overwrite it?'.format(config_file))\n if confirm_overwrite:\n configHandler(config_file).resetConfig()\n click.secho('{} created'.format(config_file), fg='green')","def init():\n for config_filename in _config_utils.CONFIG_FILENAMES:\n if os.path.isfile(config_filename):\n config_filepath = os.path.abspath(config_filename)\n click.echo(\"found existing config file {}\".format(config_filepath))\n return\n\n config_filepath = _config_utils.create_empty_config_file('.')\n click.echo(\"initialized empty config file {}\".format(config_filepath))","def save():\n with open(CONFIG_FILE, 'w') as f:\n json.dump(config, f, indent=4, sort_keys=True)","async def setconfigfile(self, ctx, *, config_file):\n self.settings.setConfigFile(config_file)\n await ctx.send(inline('Done'))","def update_gui_defaults(GUI_defaults):\n # failure flag\n config_import_error = False\n \n # xml source directory\n src_dir = os.getcwd() + '\\\\src'\n \n # attempt to parse the xml file and get it's root\n try:\n tree = ET.parse(src_dir + '\\\\pySCPI_config.xml')\n root = tree.getroot()\n \n except (IOError, ET.ParseError):\n # parsing failed for some reason\n config_import_error = True\n GUI_defaults.log_error('*** pySCPI_config.xml is'\n 'missing or corrupt ***')\n # end try\n \n # import the default values from the xml file\n if not config_import_error:\n \n # list of tags to look for\n config_tags = ['default_filename', 'default_delay', \n 'default_length', 'default_dp']\n \n # iterate through tags\n for tag in config_tags:\n # find each tag\n config_element = root.findall(tag)\n \n # if there is only one of a tag\n if len(config_element) == 1:\n # convert it to text\n config_text = config_element[0].text\n \n # update the appropriate field\n if tag == 'default_filename':\n GUI_defaults.update_filename(config_text)\n \n elif tag == 'default_delay':\n GUI_defaults.update_delay(config_text)\n \n elif tag == 'default_length':\n GUI_defaults.update_length(config_text)\n \n elif tag == 'default_dp':\n GUI_defaults.update_dp(config_text)\n # end if\n \n else:\n GUI_defaults.log_error('*** There is the wrong number '\n 'of ' + tag + ' declarations in '\n 'pySCPI_config.xml ***') \n # end if\n # end for\n \n # find the default addresses\n address_elements = root.findall('addresses')\n \n # if there are addresses\n if (len(address_elements) == 1) and (len(address_elements[0]) > 0):\n for element in address_elements[0]:\n # add each address to the list\n GUI_defaults.add_address(element.tag, element.get('address'))\n # end for\n \n else:\n GUI_defaults.log_error('*** No addresses were provided in '\n 'pySCPI_config.xml ***') \n # end if\n \n # find the default commands\n command_elements = root.findall('default_commands')\n \n # if there are commands\n if (len(command_elements) == 1) and (len(command_elements[0]) > 0):\n for command in command_elements[0]:\n # add each command to the list\n GUI_defaults.add_command(command.text)\n # end for\n\n else:\n GUI_defaults.log_error('*** No commands were provided in '\n 'pySCPI_config.xml ***') \n # end if \n # end if"],"string":"[\n \"def writeDefaultConfig(conffile='default.conf', defaults={}):\\n if not os.path.exists(conffile):\\n cp = createConfigParserfromDict(defaults, ['base'])\\n cp.write(open(conffile,'w'))\\n return conffile\",\n \"def write_default_config():\\n # TODO: BROKEN!\\n config_path = pathlib.Path(xdg.BaseDirectory.xdg_config_home) / \\\"awiesm_bc\\\"\\n config_file = config_path / DEFAULT_CONFIG_FILENAME\\n if not os.path.isdir(config_path):\\n os.makedirs(config_path)\\n\\n if not os.path.isfile(config_file):\\n # TODO: write file\\n pass\",\n \"def write_default_config(self):\\n if self.config_file:\\n config_file = self.config_file\\n else:\\n config_file = os.path.join(self.config_dir, self.config_file_name + '.py')\\n \\n if os.path.exists(config_file) and not self.answer_yes:\\n answer = ''\\n def ask():\\n prompt = \\\"Overwrite %s with default config? [y/N]\\\" % config_file\\n try:\\n return raw_input(prompt).lower() or 'n'\\n except KeyboardInterrupt:\\n print('') # empty line\\n return 'n'\\n answer = ask()\\n while not answer.startswith(('y', 'n')):\\n print(\\\"Please answer 'yes' or 'no'\\\")\\n answer = ask()\\n if answer.startswith('n'):\\n return\\n \\n config_text = self.generate_config_file()\\n if isinstance(config_text, bytes):\\n config_text = config_text.decode('utf8')\\n print(\\\"Writing default config to: %s\\\" % config_file)\\n ensure_dir_exists(os.path.abspath(os.path.dirname(config_file)), 0o700)\\n with open(config_file, mode='w') as f:\\n f.write(config_text)\",\n \"def write_starter_configfile(\\n basedir=None,\\n default_configfile_name=DEFAULT_CONFIGFILE_NAME,\\n default_config_yaml=DEFAULT_CONFIG_YAML,\\n):\\n if not basedir:\\n basedir = Path.cwd()\\n configfile_pathname = Path(basedir) / default_configfile_name\\n if os.path.exists(configfile_pathname):\\n raise ConfigError(\\n f\\\"Found existing {str(configfile_pathname)} - delete to re-generate.\\\"\\n )\\n with open(configfile_pathname, \\\"w\\\", encoding=\\\"utf-8\\\") as outfile:\\n outfile.write(default_config_yaml)\\n print(f\\\"Wrote config defaults (for editing) to: {str(configfile_pathname)}\\\")\",\n \"def __create_default_config(self):\\n if not os.path.exists(self.__configfile):\\n path=os.path.dirname(self.__configfile)\\n try:\\n os.makedirs(path)\\n except:\\n pass\\n if os.path.exists(path):\\n self.save(defaults=True)\",\n \"def set_as_default (self):\\n\\t\\ttry:\\n\\t\\t\\tself.config.set('Global', 'Default', self.currentAccount.data['name'])\\n\\t\\texcept ConfigParser.NoSectionError:\\n\\t\\t\\tself.setup_config()\\n\\t\\t\\tself.config.set('Global', 'Default', self.currentAccount.data['name'])\\n\\t\\tself.config.write(open(self.configFile, 'w'))\",\n \"def createConfig():\\n\\twith open(configPath, 'w', encoding='utf-8') as file:\\n\\t\\tjson.dump(default_config, file, indent=3)\",\n \"def add_default_settings_config(self):\\n config = {\\n mconst.DEF_SETTINGNAME_default_logfilename: mconst.DEF_SETTINGVAL_default_logfilename_defaultvalue,\\n }\\n self.settings.merge_settings_key(mconst.DEF_SETTINGSEC_config, config)\",\n \"def save_config(conf, default):\\n print()\\n if yes_no('Would you like to save your configuration?'):\\n name = simple_response(\\n 'What would you like to name your configuration?')\\n path = ask_path(\\n 'Please enter the path you would like your configuration saved to',\\n default=default)\\n file_path = os.path.join(path, name)\\n if file_path.find('.json') == -1:\\n file_path += '.json'\\n with open(file_path, 'w+') as f:\\n json.dump(conf, f, indent=4)\",\n \"def create_default(cls, env: str, config_f: Path) -> None:\\n # create default file\\n _config = Config()\\n _config.save(env)\\n log.info(f\\\"Created config file at {config_f}\\\")\",\n \"def run(self):\\n write_config(self.filename)\\n print('Wrote default config to', self.filename)\",\n \"def dump_default_config():\\n output = \\\"PythiaPlotter_config.py\\\"\\n log.info(\\\"Dumping config to %s\\\", output)\\n import pythiaplotter.default_config as dc\\n shutil.copy(dc.__file__.replace(\\\".pyc\\\", \\\".py\\\"), output)\",\n \"def _write_default_config(self, force=False):\\n\\t\\t\\n\\t\\tif self.configfilepath is not None:\\n\\t\\t\\tlogger.debug(\\\"You use the existing config file %s, I don't have to write one.\\\" % \\\\\\n (self._get_config_filepath()))\\n\\t\\t\\treturn\\n\\t\\t\\n\\t\\tif force or not os.path.exists(self._get_config_filepath()):\\t\\n\\t\\t\\tp = subprocess.Popen([self.sexpath, \\\"-dd\\\"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)\\n\\t\\t\\tout, err = p.communicate()\\n\\t\\t\\tif err != \\\"\\\":\\n\\t\\t\\t\\tlogger.warning(\\\"Ouch, SExtractor complains :\\\")\\n\\t\\t\\t\\tlogger.warning(err)\\n\\t\\t\\tf = open(self._get_config_filepath(), 'w')\\n\\t\\t\\tf.write(out.decode(encoding='UTF-8'))\\n\\t\\t\\tf.close()\\n\\t\\t\\tlogger.debug(\\\"Wrote %s\\\" % (self._get_config_filepath()))\\n\\t\\telse:\\n\\t\\t\\tlogger.debug(\\\"Default config file already exists, I don't overwrite it.\\\")\",\n \"def init_default_config_file_if_nonexistent(package, default_config):\\n config_file = os.path.join(conf.PAULA_USER_CONFIG_DIR, package + conf.CONFIG_EXTENSION)\\n debug('config_file = ' + config_file)\\n if not os.path.exists(config_file):\\n debug('making: \\\\\\\"' + config_file+ '\\\\\\\"')\\n shutil.copyfile(default_config, config_file)\",\n \"def load(filename, defaultConfig={}, writeIfNonExistent=True, quitIfNonExistent=False):\\n global _loaded\\n assert filename and isinstance(filename, basestring)\\n\\n #all keys and values in defaultConfig must be strings\\n #(to make it match what would be read in by ConfigParser)\\n #lets error out if we find a key or value that isn't a string\\n for (key, value) in defaultConfig.iteritems():\\n if not isinstance(key, basestring):\\n raise KeyError(\\\"Invalid defaultConfig: key \\\\\\\"%s\\\\\\\" is not a string\\\" % str(key))\\n if not isinstance(value, basestring):\\n raise ValueError(\\\"Invalid defaultConfig: value of key \\\\\\\"%s\\\\\\\" (\\\\\\\"%s\\\\\\\") is not a string\\\" \\n % (str(key), str(value)))\\n\\n _loaded = defaultConfig.copy()\\n \\n configFileExists = os.path.exists(filename)\\n \\n #If we just want to \\\"load\\\" the default configuration\\n if writeIfNonExistent and not configFileExists:\\n log.msg(\\\"Configuration file \\\\\\\"%s\\\\\\\" does not exist...\\\" % filename, lvl='w', ss='ss_configfile')\\n try:\\n write(filename)\\n except:\\n raise\\n \\n #if quitIfNonExistent is set, keep going to the next block of code\\n #so we can quit out properly\\n if not quitIfNonExistent:\\n return\\n\\n if quitIfNonExistent and not configFileExists:\\n #print different messages depending on if the default\\n #config file was written or not\\n if writeIfNonExistent:\\n log.msg(\\\"Quitting as configuration file did not exist. Please \\\"\\n \\\"edit the default configuration that has been written \\\"\\n \\\"to \\\\\\\"%s\\\\\\\" to suit your environment and start the program \\\"\\n \\\"again.\\\" % filename, lvl='c', ss='ss_configfile')\\n sys.exit(0)\\n else:\\n log.msg(\\\"Quitting as configuration file \\\\\\\"%s\\\\\\\" does not exist.\\\"\\n \\\" Please create this file and try again.\\\" % filename)\\n sys.exit(1)\\n\\n log.msg(\\\"Reading configuration from \\\\\\\"%s\\\\\\\"...\\\" % filename, lvl='i', ss='ss_configfile')\\n _loaded = simpleReadConfigFile(filename, useLogging=True,\\n level=consts.LOGLVL_DEBUG3)\\n \\n log.msg(\\\"ACTIVE CONFIGURATION: \\\" + str(_loaded),\\n lvl='d2', ss='ss_configfile')\",\n \"def setup(self):\\n\\n default_config = self.read()\\n\\n self.write(default_config)\",\n \"def _set_config():\\n\\n\\tdebug_msg = \\\"load default config yaml file\\\"\\n\\tlogger.debug(debug_msg)\\n\\n\\tconfig_file_parser(paths.CONFIG_FILE, override_options=True)\",\n \"def default_config_file(self):\\n return DEFAULT_CONFIG_FILEPATH\",\n \"def antenny_config_make_default(self):\\n return self.antenny_config.save_as_default_config()\",\n \"def servo_make_default(self):\\n self.servo_config.save_as_default_config()\",\n \"def save(self,filename=None,defaults=False):\\n # Check filename or use default filename\\n if not filename:\\n if self.__configfile:\\n filename=self.__configfile\\n else:\\n raise Exception(_('EVOGTK: Need a filename for saving preferences'))\\n # Set widget values on config parser\\n for section in self.__optionstruct:\\n for option in self.__optionstruct[section]:\\n widgets=self.__optionstruct[section][option][1]\\n # Get default value\\n value=vars(self)[section].get_option(option)\\n if not defaults and widgets:\\n # Use widget value\\n val=self.__guidata.__getattr__(widgets[0])\\n if val:\\n value=val\\n # Create section in file if not exists\\n if not self.__config.has_section(section):\\n self.__config.add_section(section)\\n value=vars(self)[section].set_option(option,value)\\n # Write config to file\\n fd=open(filename,'wb')\\n self.__config.write(fd)\\n fd.close()\",\n \"def generateDefaultConfig(self):\\n\\n\\t\\t# Open config.ini in write mode\\n\\t\\tf = open(self.fileName, \\\"w\\\")\\n\\n\\t\\t# Set keys to config object\\n\\t\\tself.config.add_section(\\\"db\\\")\\n\\t\\tself.config.set(\\\"db\\\", \\\"host\\\", \\\"localhost\\\")\\n\\t\\tself.config.set(\\\"db\\\", \\\"username\\\", \\\"root\\\")\\n\\t\\tself.config.set(\\\"db\\\", \\\"password\\\", \\\"\\\")\\n\\t\\tself.config.set(\\\"db\\\", \\\"database\\\", \\\"ripple\\\")\\n\\t\\tself.config.set(\\\"db\\\", \\\"pingtime\\\", \\\"600\\\")\\n\\n\\t\\tself.config.add_section(\\\"server\\\")\\n\\t\\tself.config.set(\\\"server\\\", \\\"server\\\", \\\"tornado\\\")\\n\\t\\tself.config.set(\\\"server\\\", \\\"host\\\", \\\"0.0.0.0\\\")\\n\\t\\tself.config.set(\\\"server\\\", \\\"port\\\", \\\"5001\\\")\\n\\t\\tself.config.set(\\\"server\\\", \\\"localizeusers\\\", \\\"1\\\")\\n\\t\\tself.config.set(\\\"server\\\", \\\"outputpackets\\\", \\\"0\\\")\\n\\t\\tself.config.set(\\\"server\\\", \\\"outputrequesttime\\\", \\\"0\\\")\\n\\t\\tself.config.set(\\\"server\\\", \\\"timeoutlooptime\\\", \\\"100\\\")\\n\\t\\tself.config.set(\\\"server\\\", \\\"timeouttime\\\", \\\"100\\\")\\n\\n\\t\\tself.config.add_section(\\\"flask\\\")\\n\\t\\tself.config.set(\\\"flask\\\", \\\"threaded\\\", \\\"1\\\")\\n\\t\\tself.config.set(\\\"flask\\\", \\\"debug\\\", \\\"0\\\")\\n\\t\\tself.config.set(\\\"flask\\\", \\\"logger\\\", \\\"0\\\")\\n\\n\\t\\tself.config.add_section(\\\"ci\\\")\\n\\t\\tself.config.set(\\\"ci\\\", \\\"key\\\", \\\"changeme\\\")\\n\\n\\t\\t# Write ini to file and close\\n\\t\\tself.config.write(f)\\n\\t\\tf.close()\",\n \"def write_config(config_filename, config=default_config):\\n comments=\\\"\\\"\\n if config==default_config:\\n comments+=\\\"# %s \\\\n\\\" % version.version_string\\n comments+=\\\"# This is the default config file\\\\n\\\"\\n comments+=\\\"# Generated on %s \\\\n\\\" % time.strftime('%x %X %Z')\\n comments+=\\\"# Visit %s for more informations \\\\n\\\" % version.project_url\\n c=SafeConfigParser()\\n f=open(config_filename,'w')\\n f.write(comments+\\\"\\\\n\\\")\\n for section in config.items():\\n name=section[0]\\n values=section[1]\\n c.add_section(name)\\n for value in values.items():\\n c.set(name, value[0], value[1])\\n c.write(f)\\n f.flush()\\n f.close()\",\n \"def save_config(self, new_config, filename=None):\\n self.cfg.update(new_config)\\n if filename is None:\\n self.cfg.filename = self.cfg_filename\\n else:\\n self.cfg.filename = filename\\n self.cfg.write()\\n logger.info(\\\"Config file %s written out\\\" % self.cfg.filename)\",\n \"def write_config(self, filename):\\n self.config.filename = filename\\n self.config.write()\",\n \"def set_config_all_to_defaults():\\n logging.debug(\\\"Creating default config\\\")\\n for section in all_defaults:\\n set_config_section_to_defaults(section)\\n global config_changed\\n config_changed = True\",\n \"def save_default_connections_file():\\n if os.path.exists(DEFAULT_CONNECTIONS_FILE):\\n if os.path.exists(DEFAULT_CONNECTIONS_FILE_BAK):\\n os.remove(DEFAULT_CONNECTIONS_FILE_BAK)\\n os.rename(DEFAULT_CONNECTIONS_FILE, DEFAULT_CONNECTIONS_FILE_BAK)\",\n \"def create_default_config(self, parser):\\n parser.add_section('irc')\\n parser.set('irc', 'channels', '')\\n \\n # create the full path, and the file\\n try:\\n os.makedirs(self.config_dir_path, mode=0700)\\n except OSError:\\n pass\\n file_resource = open(self.config_file_path, 'w')\\n parser.write(file_resource)\",\n \"def create_default_config():\\n import codecs\\n config = ConfigParser.SafeConfigParser()\\n config.readfp(StringIO(DEFAULT_CONFIG))\\n\\n # Load user settings\\n filename = get_user_config_filename()\\n if not os.path.exists(filename):\\n from wizard import setup_wizard\\n setup_wizard(config)\\n else:\\n try:\\n fi = codecs.open(filename, 'r', encoding='utf-8')\\n config.readfp(fi)\\n finally:\\n fi.close()\\n return config\",\n \"def overrideCurrentConfiguration(self):\\n if not self._currentConfiguration:\\n self.saveNewConfiguration()\\n else:\\n self._saveToFilePath(self._currentConfiguration)\",\n \"def save_defaults(self, overwrite=False):\\r\\n for (section, option), value in self.defaults.iteritems():\\r\\n if value is None:\\r\\n continue\\r\\n if section not in self.__config:\\r\\n self.__config[section] = {}\\r\\n if overwrite or option not in self.__config[section]:\\r\\n self.__config[section][option] = value\\r\\n self.save()\",\n \"def get_default_config_file() -> Path:\\n return get_path_to_pyflow() / \\\"pyflow\\\" / \\\"conf\\\" / CONFIG_FILE\",\n \"def write_default_config(output_config: Pathlike, feature_type: str):\\n create_default_feature_extractor(feature_type).to_yaml(output_config)\",\n \"def SaveConfig(self):\\n config_value = getattr(self, APPDATA)\\n path_value = config_value.AbsolutePaths[0]\\n default_cfg_file = os.path.join(path_value, CONFIG_FILE_NAME)\\n temp_file = default_cfg_file + '.TEMP'\\n if os.path.exists(default_cfg_file):\\n json.dump(type(self)._CURRENT_CONFIG,\\n open(temp_file.lower(),\\n mode='w'),\\n cls=ConfigEncoder,\\n sort_keys=False,\\n indent=4)\\n EnsureBackup(temp_file, default_cfg_file)\\n else:\\n if not os.path.isdir(path_value):\\n os.mkdir(path_value)\\n json.dump(type(self)._CURRENT_CONFIG,\\n open(default_cfg_file.lower(),\\n mode='w'),\\n cls=ConfigEncoder,\\n sort_keys=False,\\n indent=4)\",\n \"def build_default_cfg():\\n with open(Daemon.CONFIG_FILEPATH, 'wb') as fo:\\n json.dump(Daemon.DEF_CONF, fo, skipkeys=True, ensure_ascii=True, indent=4)\\n return Daemon.DEF_CONF\",\n \"def initConfig(defaults, filepath=None):\\n result = False\\n if filepath is None:\\n filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), \\\"res/\\\", \\\"config.ini\\\")\\n if not os.path.exists(filepath):\\n config = ConfigParser.ConfigParser(defaults)\\n result = Helpers.saveConfig(config, filepath)\\n return result\",\n \"def get_default_config(self):\\n return config.read(pathlib.Path(__file__).parent / \\\"ext.conf\\\")\",\n \"def create_default_sensor_config_file(self, sensor_config_file_path):\\n data = dict()\\n data[constants.SensorConfigurationKeys.LIDAR] = \\\\\\n constants.DEFAULT_LIDAR_CONFIGURATION\\n data[constants.SensorConfigurationKeys.LIDAR_OVERLAY] = \\\\\\n constants.DEFAULT_LIDAR_OVERLAY_CONFIGURATION\\n with open(sensor_config_file_path, \\\"w\\\") as outfile:\\n json.dump(data, outfile, indent=4,)\",\n \"def set_config_defaults(config):\\n new_config = config.copy()\\n\\n new_config.setdefault(\\\"window_title\\\", \\\"Materials Cloud Tool\\\")\\n new_config.setdefault(\\n \\\"page_title\\\",\\n \\\"<PLEASE SPECIFY A PAGE_TITLE AND A WINDOW_TITLE IN THE CONFIG FILE>\\\",\\n )\\n\\n new_config.setdefault(\\\"custom_css_files\\\", {})\\n new_config.setdefault(\\\"custom_js_files\\\", {})\\n new_config.setdefault(\\\"templates\\\", {})\\n\\n return new_config\",\n \"def set_last_config(self, config_name):\\n with open(FILEPATH_MANAGER.get_last_config_file_path(), 'w') as f:\\n f.write(config_name + \\\"\\\\n\\\")\",\n \"def default(path: str = 'setings.INI'):\\n Setings._delete_setings(path)\\n Setings._create_default_setting(path)\",\n \"def save_config(**kwargs):\\n if kwargs == {}:\\n kwargs = config._config\\n current_config = _load_config()\\n current_config.update(**kwargs)\\n # write to disk\\n fname = _get_config_fname()\\n if fname is None:\\n raise RuntimeError('config filename could not be determined')\\n if not op.isdir(op.dirname(fname)):\\n os.mkdir(op.dirname(fname))\\n with open(fname, 'w') as fid:\\n json.dump(current_config, fid, sort_keys=True, indent=0)\",\n \"def set_default_profile(self):\\n profile = textwrap.dedent(\\n \\\"\\\"\\\"\\n config:\\n boot.autostart: \\\"true\\\"\\n description: Default LXD profile\\n devices:\\n eth0:\\n name: eth0\\n nictype: bridged\\n parent: conjureup1\\n type: nic\\n eth1:\\n name: eth1\\n nictype: bridged\\n parent: conjureup0\\n type: nic\\n root:\\n path: /\\n pool: default\\n type: disk\\n name: default\\n \\\"\\\"\\\")\\n with NamedTemporaryFile(mode='w', encoding='utf-8',\\n delete=False) as tempf:\\n utils.spew(tempf.name, profile)\\n out = utils.run_script(\\n 'cat {} |conjure-up.lxc profile edit default'.format(\\n tempf.name))\\n if out.returncode != 0:\\n raise Exception(\\\"Problem setting default profile: {}\\\".format(\\n out))\",\n \"def load_config_with_defaults(config_path):\\n config = neat.Config(\\n neat.DefaultGenome,\\n neat.DefaultReproduction,\\n neat.DefaultSpeciesSet,\\n neat.DefaultStagnation,\\n config_path\\n )\\n return config\",\n \"def load_default_config_file(filename: str) -> str:\\n try:\\n raw_contents = resource_string(__name__, 'configuration/' + filename)\\n except FileNotFoundError:\\n raise BscanConfigError(\\n 'Unable to find default configuration file `' + filename + '`')\\n return raw_contents.decode('utf-8')\",\n \"def config_skeleton():\\n config = Config()\\n config.set_to_default()\\n config.save()\",\n \"def saveCurrentConfig():\\n cf = ConfigParser.ConfigParser()\\n cf.add_section(\\\"dir_config\\\")\\n cf.set(\\\"dir_config\\\", \\\"7zpath\\\", SW_CONFIG['7zpath'])\\n cf.set(\\\"dir_config\\\", \\\"sharefolder\\\", SW_CONFIG['sharefolder'])\\n cf.set(\\\"dir_config\\\", \\\"distpath\\\", SW_CONFIG['distpath'])\\n cf.add_section(\\\"sw_config\\\")\\n cf.set(\\\"sw_config\\\", \\\"version\\\", SW_CONFIG['sw_version'])\\n cf.set(\\\"sw_config\\\", \\\"startup\\\", SW_CONFIG['startup'])\\n cf.add_section(\\\"run_config\\\")\\n cf.set(\\\"run_config\\\", \\\"pop\\\", RUN_CONFIG['pop'])\\n cf.set(\\\"run_config\\\", \\\"backup\\\", RUN_CONFIG['backup'])\\n cf.add_section(\\\"hook_config'\\\")\\n for k, v in HOOK_CONFIG:\\n cf.set(\\\"hook_config\\\", k, v)\\n fp = open(CONFIG_FILE, \\\"w\\\")\\n cf.write(fp)\\n fp.close()\",\n \"def setup_configuration_file(self):\\n\\n with open(self.config_path, \\\"w+\\\") as f_config:\\n\\n f_config.write(get_configuration_file_form())\",\n \"def generate_config(args):\\n default_config = resource_string('webrpg', 'scripts/templates/default_config.txt').decode('utf-8')\\n if args.sqla_connection_string:\\n default_config = default_config.replace('%(sqlalchemy_url)s', args.sqla_connection_string)\\n else:\\n default_config = default_config.replace('%(sqlalchemy_url)s', get_user_parameter('SQL Alchemy Connection String', 'sqlite:///%(here)s/pyire_test.db'))\\n\\n with open(args.filename, 'w') as out_f:\\n out_f.write(default_config)\",\n \"def save():\\n\\n env.config.save(env.config_file)\",\n \"def default_page_config(self, default_page_config):\\n\\n self._default_page_config = default_page_config\",\n \"def test_config_create_file_with_default_dict(get_root, get_empty_config, monkeypatch):\\n path = os.path.join(get_root, 'res', 'non_existent.yml')\\n test_dict = {'this': 'test', 'test': 'de'}\\n monkeypatch.setattr(DeviceConfig, 'minimal_essential_conf', test_dict)\\n cfg = get_empty_config(DeviceConfig, path)\\n\\n with open(path, 'r') as fh:\\n content = yaml.load(fh, Loader=get_yaml_loader())\\n\\n assert cfg.config_path == path, \\\"config path is incorrect\\\"\\n assert cfg.minimal_essential_conf == test_dict, \\\"bad minimal running\\\"\\n assert content == test_dict, \\\"config not written to file\\\"\\n assert cfg.data == test_dict, \\\"default config not loaded from file\\\"\",\n \"def save_config(self):\\n config.save_config(self.config, self.config_file)\",\n \"def set_default_paths(args):\\n filename = os.path.join(os.path.expanduser('~'), '.gfail_defaults')\\n if os.path.exists(filename):\\n D = ConfigObj(filename)\\n else:\\n D = {}\\n if args.data_path is not None:\\n if args.data_path == 'reset':\\n D.pop('data_path')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.data_path):\\n D.update({'data_path': args.data_path})\\n else:\\n print('Path given for data_path does not exist: %s'\\n % args.data_path)\\n if args.output_filepath is not None:\\n if args.output_filepath == 'reset':\\n D.pop('output_filepath')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.output_filepath):\\n D.update({'output_filepath': args.output_filepath})\\n else:\\n print('Path given for output_filepath does not exist: %s'\\n % args.output_filepath)\\n if args.config_filepath is not None:\\n if args.config_filepath == 'reset':\\n D.pop('config_filepath')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.config_filepath):\\n D.update({'config_filepath': args.config_filepath})\\n else:\\n print('Path given for config_filepath does not exist: %s'\\n % args.config_filepath)\\n if args.popfile is not None:\\n if args.popfile == 'reset':\\n D.pop('popfile')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.popfile):\\n D.update({'popfile': args.popfile})\\n else:\\n print('Path given for population file does not exist: %s'\\n % args.popfile)\\n if args.trimfile is not None:\\n if args.trimfile == 'reset':\\n D.pop('trim')\\n else:\\n # check that it's a valid path and that it's a shapefile\\n if os.path.exists(args.trimfile):\\n filename4, fileextension = os.path.splitext(args.trimfile)\\n if fileextension == '.shp':\\n D.update({'trimfile': args.trimfile})\\n else:\\n print('Ocean trimming file is not a shapefile: %s'\\n % args.trimfile)\\n else:\\n print('Path given for ocean trimming file does not exist: %s'\\n % args.trimfile)\\n if args.pdl_config is not None:\\n if args.pdl_config == 'reset':\\n D.pop('pdl_config')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.pdl_config):\\n D.update({'pdl_config': args.pdl_config})\\n else:\\n print('Path given for pdl config file does not exist: %s'\\n % args.pdl_config)\\n if args.log_filepath is not None:\\n if args.log_filepath == 'reset':\\n D.pop('log_filepath')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.log_filepath):\\n D.update({'log_filepath': args.log_filepath})\\n else:\\n print('Path given for log file does not exist: %s'\\n % args.log_filepath)\\n if args.dbfile is not None:\\n if args.dbfile == 'reset':\\n D.pop('dbfile')\\n else:\\n # check that it's a valid path (file itself doesnt have to exist)\\n if os.path.exists(os.path.dirname(args.dbfile)):\\n D.update({'dbfile': args.dbfile})\\n else:\\n print('Path given for database file does not exist: %s'\\n % args.dbfile)\\n\\n print('New default paths set.\\\\n')\\n\\n if D:\\n C = ConfigObj(D)\\n C.filename = filename\\n C.write()\\n list_default_paths()\\n else:\\n print('no defaults set because no paths were input\\\\n')\",\n \"def saveConfig(self, name=None):\\n\\n configDir = self.mwGlob['configDir']\\n\\n if self.config.get('profileName', '') == 'config':\\n if 'reference' in self.config:\\n del self.config['reference']\\n\\n # default saving for reference\\n if name is None:\\n name = self.config.get('reference', 'config')\\n\\n fileName = configDir + '/' + name + '.cfg'\\n with open(fileName, 'w') as outfile:\\n json.dump(self.config,\\n outfile,\\n sort_keys=True,\\n indent=4)\\n # if we save a reference first, we have to save the config as well\\n if name != 'config':\\n fileName = configDir + '/config.cfg'\\n with open(fileName, 'w') as outfile:\\n json.dump(self.config,\\n outfile,\\n sort_keys=True,\\n indent=4)\\n return True\",\n \"def restore_default_connections_file():\\n if os.path.exists(DEFAULT_CONNECTIONS_FILE_BAK):\\n if os.path.exists(DEFAULT_CONNECTIONS_FILE):\\n os.remove(DEFAULT_CONNECTIONS_FILE)\\n os.rename(DEFAULT_CONNECTIONS_FILE_BAK, DEFAULT_CONNECTIONS_FILE)\",\n \"def bootstrap_default():\\n\\treturn default_configuration\",\n \"def init_config(args=None):\\n if args is None:\\n args = parser_args()\\n\\n # Set the experiment directory\\n exp_dir = args.exp_dir\\n if exp_dir is None:\\n exp_dir = 'experiment/' + args.model_name + '/' + osp.splitext(osp.basename(args.default_config_path))[0]\\n\\n # copy file\\n dst_config_path = osp.join(exp_dir, osp.basename(args.default_config_path))\\n src_copy_to_dst(args.default_config_path, dst_config_path)\\n\\n # overwrite\\n if args.ow_config_path != 'None':\\n print('ow_config_path is: {}'.format(args.ow_config_path))\\n overwrite_config_file(dst_config_path, ow_file=args.ow_config_path)\\n if args.ow_str != 'None':\\n print('ow_str is: {}'.format(args.ow_str))\\n overwrite_config_file(dst_config_path, ow_str=args.ow_str)\\n\\n # import config\\n cfg = import_file(dst_config_path).cfg\\n\\n # Set log experiment dir\\n cfg.log.exp_dir = exp_dir\\n return cfg\",\n \"def save_defaults(self):\\n\\n pass\",\n \"def saveNewConfiguration(self):\\n selection = tk.filedialog. \\\\\\n asksaveasfilename(title=\\\"Save CHUM configuration\\\")\\n if selection:\\n self._currentConfiguration = selection\\n self._saveToFilePath(selection)\",\n \"def saveSettignsAsDefault(self, config = None):\\n if config:\\n resp = self.setPineAPSettings(config)\\n if (resp['error']):\\n return resp\\n return self.request('saveAsDefault')\",\n \"def save_config(self, filename: str=None):\\n if not filename:\\n filename = self.config_file\\n with open(filename, \\\"w\\\") as file_object:\\n json.dump(self.config, file_object, indent=4, sort_keys=True)\",\n \"def save_configuration(config):\\n with open(cwd + '/configuration.pickle', 'wb') as handle:\\n pickle.dump(config, handle, protocol=pickle.HIGHEST_PROTOCOL)\",\n \"def default():\\n raise NotImplementedError(\\\"Pvwattsv7 default file no longer exists!\\\")\",\n \"def test_get_config(default_config, tmp_path):\\n abcconfig.write_config(default_config, configpath=tmp_path)\\n config = abcconfig.get_config(configpath=tmp_path)\\n assert config == default_config\",\n \"def default_configfile():\\n dirname=None\\n if os.getenv(\\\"HOME\\\"):\\n dirname=os.getenv(\\\"HOME\\\")\\n elif os.getenv(\\\"USERPROFILE\\\"):\\n dirname=os.getenv(\\\"USERPROFILE\\\")\\n\\n else:\\n raise FattyException(\\\"No HOME or USERPROFILE variable set, unable to determine default config file\\\")\\n\\n return os.path.join(dirname,\\\".fattybugs\\\")\",\n \"def __init__(self, name, defaults = {} ):\\n self.defaults = defaults\\n self.filename = os.path.expanduser(name)+\\\".ini\\\"\\n self.conf = {}\\n self.reset()\\n if os.path.exists(self.filename):\\n self.load()\",\n \"def set_default_paths(args):\\n filename = os.path.join(os.path.expanduser('~'), '.gfail_defaults')\\n if os.path.exists(filename):\\n D = ConfigObj(filename)\\n else:\\n D = {}\\n if args.data_path is not None:\\n if args.data_path == 'reset':\\n D.pop('data_path')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.data_path):\\n D.update({'data_path': args.data_path})\\n else:\\n print('Path given for data_path does not exist: %s' % args.data_path)\\n if args.output_filepath is not None:\\n if args.output_filepath == 'reset':\\n D.pop('output_filepath')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.output_filepath):\\n D.update({'output_filepath': args.output_filepath})\\n else:\\n print('Path given for output_filepath does not exist: %s' % args.output_filepath)\\n if args.config_filepath is not None:\\n if args.config_filepath == 'reset':\\n D.pop('config_filepath')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.config_filepath):\\n D.update({'config_filepath': args.config_filepath})\\n else:\\n print('Path given for config_filepath does not exist: %s' % args.config_filepath)\\n if args.mapconfig is not None:\\n if args.mapconfig == 'reset':\\n D.pop('mapconfig')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.mapconfig):\\n D.update({'mapconfig': args.mapconfig})\\n else:\\n print('Path given for mapconfig does not exist: %s' % args.mapconfig)\\n if args.mapdata_filepath is not None:\\n if args.mapdata_filepath == 'reset':\\n D.pop('mapdata_filepath')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.mapdata_filepath):\\n D.update({'mapdata_filepath': args.mapdata_filepath})\\n else:\\n print('Path given for mapdata_filepath does not exist: %s' % args.mapdata_filepath)\\n\\n if D:\\n C = ConfigObj(D)\\n C.filename = filename\\n C.write()\\n list_default_paths()\\n else:\\n print('no defaults set because no paths were input')\",\n \"def _create_default_config(self):\\n self.options.setdefault('options.admin_passwd', '')\\n sys.path.append(self.openerp_dir)\\n sys.path.extend([egg.location for egg in self.ws])\\n from openerp.tools.config import configmanager\\n configmanager(self.config_path).save()\",\n \"def reload_default(self, write=True, backup=True, how='right', how_section=None, sections=None):\\r\\n # self._cfg = self.default_config.deepcopy()\\r\\n self._path = self._default_path.copy()\\r\\n dico = self.default_config.deepcopy()\\r\\n sections = {sections} if isinstance(sections, str) else sections\\r\\n n_dico = dico if sections is None else {k: dico[k] for k in sections & dico.keys()}\\r\\n self.merge(n_dico, how=how, how_section=how_section, inplace=True)\\r\\n if write:\\r\\n self.save_config(overwrite=True, backup=backup)\\r\\n logger.info(\\\"Configuration reloaded and saved to '{}'.\\\".format(self._path))\\r\\n else:\\r\\n logger.info(\\\"Configuration reloaded.\\\")\",\n \"def saveConfig():\\n with open(_CONFIG_FNM, 'w') as configfile:\\n CONFIG_DICT.write(configfile,\\n space_around_delimiters=True)\",\n \"def save_config_file(self):\\n wkdir = Path(self.config_dict[\\\"outputdir\\\"])\\n config_filename = str(wkdir / f\\\"{self.config_dict['name']}.json\\\")\\n save_config(self.config_dict, config_filename)\",\n \"def set_default_save_location(self):\\n home = os.path.expanduser(\\\"~\\\")\\n self.path = home+'\\\\\\\\Desktop\\\\\\\\'\\n filename = datetime.datetime.now().strftime(\\\"%Y-%m-%d_%H-%M\\\")+'.csv'\\n self.full_file_path = self.path+filename\\n self.settings['csv_save_path'] = self.full_file_path\\n self.firstopened = True\",\n \"def save(self):\\r\\n with open(self.filename, 'wb') as configfile:\\r\\n self.write(configfile)\",\n \"def save_config() -> None:\\n with open(_config_file, \\\"w\\\", newline=\\\"\\\") as config_file:\\n json.dump(_config, config_file, indent=4)\\n config_file.truncate()\",\n \"def UnsetWiredDefault(self):\\n config = ConfigParser.ConfigParser()\\n config.read(self.wired_conf)\\n profileList = config.sections()\\n for profile in profileList:\\n if config.has_option(profile, \\\"default\\\"):\\n if misc.to_bool(config.get(profile, \\\"default\\\")):\\n config.set(profile, \\\"default\\\", False)\\n config.write(open(self.wired_conf, \\\"w\\\"))\\n self.SaveWiredNetworkProfile(profile)\",\n \"def add_defaults(cls, defaults):\\n defaults.wallet = bittensor.Config()\\n defaults.wallet.name = os.getenv('BT_WALLET_NAME') if os.getenv('BT_WALLET_NAME') != None else 'default'\\n defaults.wallet.hotkey = os.getenv('BT_WALLET_HOTKEY') if os.getenv('BT_WALLET_HOTKEY') != None else 'default'\\n defaults.wallet.path = os.getenv('BT_WALLET_PATH') if os.getenv('BT_WALLET_PATH') != None else '~/.bittensor/wallets/'\",\n \"def save(self):\\n file = open(self.path, 'w')\\n self.config.write(file)\\n file.close()\",\n \"def get_default_config_filename():\\n if 'PYWREN_CONFIG_FILE' in os.environ:\\n config_filename = os.environ['PYWREN_CONFIG_FILE']\\n # FIXME log this\\n\\n elif os.path.exists(\\\".pywren_config\\\"):\\n config_filename = os.path.abspath('.pywren_config')\\n\\n else:\\n config_filename = get_default_home_filename()\\n\\n return config_filename\",\n \"def antenny_config_load_default(self):\\n return self.antenny_config.load_default_config()\",\n \"def default(config_data=None): \\n if not config_data:\\n if 'PYWREN_CONFIG' in os.environ:\\n config_data = json.loads(os.environ.get('PYWREN_CONFIG'))\\n else:\\n config_filename = get_default_config_filename()\\n if config_filename is None:\\n raise ValueError(\\\"could not find configuration file\\\")\\n \\n config_data = load(config_filename)\\n \\n # Apply defualt values\\n if 'storage_backend' not in config_data:\\n config_data['storage_backend'] = DEFAULT_STORAGE_BACKEND \\n if 'pywren' not in config_data:\\n config_data['pywren'] = dict()\\n config_data['pywren']['storage_bucket'] = COS_BUCKET_DEFAULT\\n config_data['pywren']['storage_prefix'] = COS_PREFIX_DEFAULT\\n elif 'storage_bucket' not in config_data['pywren']:\\n config_data['pywren']['storage_bucket'] = COS_BUCKET_DEFAULT\\n elif 'storage_prefix' not in config_data['pywren']:\\n config_data['pywren']['storage_prefix'] = COS_PREFIX_DEFAULT\\n if 'action_name' not in config_data['ibm_cf']:\\n config_data['ibm_cf']['action_name'] = CF_ACTION_NAME_DEFAULT\\n \\n return config_data\",\n \"def test_write_config(default_config, tmp_path):\\n testpath = Path(tmp_path, \\\"write_config\\\")\\n testpath.mkdir()\\n abcconfig.write_config(default_config, configpath=testpath)\\n assert Path(testpath, \\\"config.yml\\\").exists()\",\n \"def save_default_environment(\\n environment=None,\\n cwd=None\\n):\\n env_file = get_local_default_file(cwd=cwd)\\n with open(env_file, 'w') as f_out:\\n f_out.write(f'{str(environment)}\\\\n')\\n return True\",\n \"def default_configfile(self):\\r\\n config = None\\r\\n for path in self.searchpaths:\\r\\n if os.path.exists(path):\\r\\n config = path\\r\\n break\\r\\n if config is None and self.require_configfile:\\r\\n self.usage('No config file found at default paths (%s); '\\r\\n 'use the -c option to specify a config file '\\r\\n 'at a different path' % ', '.join(self.searchpaths))\\r\\n return config\",\n \"def save_config(cp, cfile):\\n cp['DEFAULT'] = {\\n 'last': datetime.datetime.utcnow().replace(tzinfo=pytz.utc).isoformat()\\n\\n }\\n with open(cfile, 'w') as cfh:\\n cp.write(cfh)\",\n \"def default_config_yaml(cls):\\n return DEFAULT_CONFIG\",\n \"def get_config_filepath(config: configs.Config) -> str:\\n return os.path.join(config.model_training.dir_out, configs.DEFAULT_FILENAME_CONFIG)\",\n \"def save_config(config, filename=None):\\n if filename is None:\\n filename = CONFIG_FN\\n with open(filename, \\\"w\\\", encoding=\\\"utf-8\\\") as fh:\\n json.dump(\\n config,\\n fh,\\n sort_keys=True,\\n indent=4,\\n separators=(\\\",\\\", \\\": \\\"),\\n )\",\n \"def save():\\n print(\\\"Saving config file..\\\")\\n\\n res = yaml.round_trip_dump(_conf, indent=2, block_seq_indent=1)\\n\\n with open(__config_file, 'w', encoding='utf-8') as stream:\\n stream.write(res)\",\n \"def setup_logging(save_dir, log_config='logger/logger_config.json', default_level=logging.INFO):\\n log_config = Path(log_config)\\n if log_config.is_file():\\n config = read_json(log_config)\\n # modify logging paths based on run config\\n for _, handler in config['handlers'].items():\\n if 'filename' in handler:\\n handler['filename'] = str(save_dir / handler['filename'])\\n\\n logging.config.dictConfig(config)\\n else:\\n print(\\\"Warning: logging configuration file is not found in {}.\\\".format(log_config), file=sys.stderr)\\n logging.basicConfig(level=default_level)\",\n \"def test_set_default_config(qibuild_action, build_worktree):\\n qibuild_action(\\\"add-config\\\", \\\"foo\\\", \\\"--default\\\")\\n assert build_worktree.default_config == \\\"foo\\\"\",\n \"def add_config(config_name, params, config_file=None, make_default=True):\\n\\n if config_file is None:\\n config_file = pkgrs.resource_filename('latools', 'latools.cfg')\\n cf = configparser.ConfigParser()\\n cf.read(config_file)\\n\\n # if config doesn't already exist, create it.\\n if config_name not in cf.sections():\\n cf.add_section(config_name)\\n # iterate through parameter dict and set values\\n for k, v in params.items():\\n cf.set(config_name, k, v)\\n # make the parameter set default, if requested\\n if make_default:\\n cf.set('DEFAULT', 'default_config', config_name)\\n\\n cf.write(open(config_file, 'w'))\\n\\n return\",\n \"def _write_config(self, config_path: Path):\\n with open(config_path, \\\"w\\\") as f:\\n json.dump(self.config_overrides, f)\",\n \"def save(config, filename=None):\\n filename = add_directory(filename or 'configure.json')\\n directory = os.path.dirname(filename)\\n if not os.path.exists(directory):\\n os.makedirs(directory, 0o700)\\n with open(filename, \\\"w\\\") as f:\\n json.dump(config, f, indent=2, sort_keys=True)\",\n \"def saveConfig(self):\\n newPath = self.newFolderPath.text()\\n config.set(\\\"saveLocation\\\", str(newPath))\\n config.save()\\n self.reloadSettings()\",\n \"def init_cfg(input_path, quiet):\\n config_file = getConfigPath(input_path)\\n\\n if not os.path.exists(config_file) or quiet:\\n confirm_overwrite = True\\n else:\\n confirm_overwrite = click.confirm(\\n '\\\\n{} already exists. Do you want to overwrite it?'.format(config_file))\\n if confirm_overwrite:\\n configHandler(config_file).resetConfig()\\n click.secho('{} created'.format(config_file), fg='green')\",\n \"def init():\\n for config_filename in _config_utils.CONFIG_FILENAMES:\\n if os.path.isfile(config_filename):\\n config_filepath = os.path.abspath(config_filename)\\n click.echo(\\\"found existing config file {}\\\".format(config_filepath))\\n return\\n\\n config_filepath = _config_utils.create_empty_config_file('.')\\n click.echo(\\\"initialized empty config file {}\\\".format(config_filepath))\",\n \"def save():\\n with open(CONFIG_FILE, 'w') as f:\\n json.dump(config, f, indent=4, sort_keys=True)\",\n \"async def setconfigfile(self, ctx, *, config_file):\\n self.settings.setConfigFile(config_file)\\n await ctx.send(inline('Done'))\",\n \"def update_gui_defaults(GUI_defaults):\\n # failure flag\\n config_import_error = False\\n \\n # xml source directory\\n src_dir = os.getcwd() + '\\\\\\\\src'\\n \\n # attempt to parse the xml file and get it's root\\n try:\\n tree = ET.parse(src_dir + '\\\\\\\\pySCPI_config.xml')\\n root = tree.getroot()\\n \\n except (IOError, ET.ParseError):\\n # parsing failed for some reason\\n config_import_error = True\\n GUI_defaults.log_error('*** pySCPI_config.xml is'\\n 'missing or corrupt ***')\\n # end try\\n \\n # import the default values from the xml file\\n if not config_import_error:\\n \\n # list of tags to look for\\n config_tags = ['default_filename', 'default_delay', \\n 'default_length', 'default_dp']\\n \\n # iterate through tags\\n for tag in config_tags:\\n # find each tag\\n config_element = root.findall(tag)\\n \\n # if there is only one of a tag\\n if len(config_element) == 1:\\n # convert it to text\\n config_text = config_element[0].text\\n \\n # update the appropriate field\\n if tag == 'default_filename':\\n GUI_defaults.update_filename(config_text)\\n \\n elif tag == 'default_delay':\\n GUI_defaults.update_delay(config_text)\\n \\n elif tag == 'default_length':\\n GUI_defaults.update_length(config_text)\\n \\n elif tag == 'default_dp':\\n GUI_defaults.update_dp(config_text)\\n # end if\\n \\n else:\\n GUI_defaults.log_error('*** There is the wrong number '\\n 'of ' + tag + ' declarations in '\\n 'pySCPI_config.xml ***') \\n # end if\\n # end for\\n \\n # find the default addresses\\n address_elements = root.findall('addresses')\\n \\n # if there are addresses\\n if (len(address_elements) == 1) and (len(address_elements[0]) > 0):\\n for element in address_elements[0]:\\n # add each address to the list\\n GUI_defaults.add_address(element.tag, element.get('address'))\\n # end for\\n \\n else:\\n GUI_defaults.log_error('*** No addresses were provided in '\\n 'pySCPI_config.xml ***') \\n # end if\\n \\n # find the default commands\\n command_elements = root.findall('default_commands')\\n \\n # if there are commands\\n if (len(command_elements) == 1) and (len(command_elements[0]) > 0):\\n for command in command_elements[0]:\\n # add each command to the list\\n GUI_defaults.add_command(command.text)\\n # end for\\n\\n else:\\n GUI_defaults.log_error('*** No commands were provided in '\\n 'pySCPI_config.xml ***') \\n # end if \\n # end if\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7795459","0.76893884","0.7577117","0.7335307","0.7192635","0.71420926","0.71333855","0.7080361","0.70510966","0.7046068","0.70410866","0.7012563","0.70065206","0.693917","0.6721765","0.6714416","0.67111033","0.66713166","0.66688925","0.66178155","0.642376","0.6404036","0.6403735","0.6389879","0.63797796","0.6355066","0.6335641","0.62977684","0.62890416","0.6239152","0.6233682","0.62206256","0.62126535","0.6203658","0.6157822","0.613148","0.6110743","0.6109495","0.6098885","0.6098818","0.60904056","0.60874736","0.6082604","0.60788214","0.60492504","0.6029501","0.60184664","0.60085815","0.6005163","0.59972996","0.59685814","0.5964843","0.59616107","0.59338665","0.59214944","0.5920631","0.5920102","0.5912273","0.5909892","0.58940035","0.58847433","0.5882714","0.5878263","0.587364","0.58727247","0.58666164","0.58595276","0.58583367","0.585136","0.5836644","0.5836457","0.5827649","0.58229125","0.58087885","0.5805702","0.5779824","0.57765377","0.57652736","0.5762971","0.5762074","0.57607126","0.5747282","0.5730954","0.57270944","0.57243234","0.572119","0.57088244","0.5703823","0.56999815","0.56993675","0.5694747","0.5692062","0.56918406","0.5684825","0.5683432","0.56805843","0.56718624","0.56697226","0.56669277","0.56637967"],"string":"[\n \"0.7795459\",\n \"0.76893884\",\n \"0.7577117\",\n \"0.7335307\",\n \"0.7192635\",\n \"0.71420926\",\n \"0.71333855\",\n \"0.7080361\",\n \"0.70510966\",\n \"0.7046068\",\n \"0.70410866\",\n \"0.7012563\",\n \"0.70065206\",\n \"0.693917\",\n \"0.6721765\",\n \"0.6714416\",\n \"0.67111033\",\n \"0.66713166\",\n \"0.66688925\",\n \"0.66178155\",\n \"0.642376\",\n \"0.6404036\",\n \"0.6403735\",\n \"0.6389879\",\n \"0.63797796\",\n \"0.6355066\",\n \"0.6335641\",\n \"0.62977684\",\n \"0.62890416\",\n \"0.6239152\",\n \"0.6233682\",\n \"0.62206256\",\n \"0.62126535\",\n \"0.6203658\",\n \"0.6157822\",\n \"0.613148\",\n \"0.6110743\",\n \"0.6109495\",\n \"0.6098885\",\n \"0.6098818\",\n \"0.60904056\",\n \"0.60874736\",\n \"0.6082604\",\n \"0.60788214\",\n \"0.60492504\",\n \"0.6029501\",\n \"0.60184664\",\n \"0.60085815\",\n \"0.6005163\",\n \"0.59972996\",\n \"0.59685814\",\n \"0.5964843\",\n \"0.59616107\",\n \"0.59338665\",\n \"0.59214944\",\n \"0.5920631\",\n \"0.5920102\",\n \"0.5912273\",\n \"0.5909892\",\n \"0.58940035\",\n \"0.58847433\",\n \"0.5882714\",\n \"0.5878263\",\n \"0.587364\",\n \"0.58727247\",\n \"0.58666164\",\n \"0.58595276\",\n \"0.58583367\",\n \"0.585136\",\n \"0.5836644\",\n \"0.5836457\",\n \"0.5827649\",\n \"0.58229125\",\n \"0.58087885\",\n \"0.5805702\",\n \"0.5779824\",\n \"0.57765377\",\n \"0.57652736\",\n \"0.5762971\",\n \"0.5762074\",\n \"0.57607126\",\n \"0.5747282\",\n \"0.5730954\",\n \"0.57270944\",\n \"0.57243234\",\n \"0.572119\",\n \"0.57088244\",\n \"0.5703823\",\n \"0.56999815\",\n \"0.56993675\",\n \"0.5694747\",\n \"0.5692062\",\n \"0.56918406\",\n \"0.5684825\",\n \"0.5683432\",\n \"0.56805843\",\n \"0.56718624\",\n \"0.56697226\",\n \"0.56669277\",\n \"0.56637967\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67744064"},"document_rank":{"kind":"string","value":"14"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":90,"numItemsPerPage":100,"numTotalItems":95772,"offset":9000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NDMxMjY4NCwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzQzMTYyODQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.oo9OxFV2oDUBFT-UbYIDbKLkceH-tdB74hKl4mUrJB5Uuoxfubqp2RjUinh887KA2EU97zh2hBBTI32qy8G3Ag","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Returns a step dictionary which is compatible with annotator.py. | def __call__(self, name, cmd, ok_ret=None, infra_step=False, wrapper=(),
timeout=None, allow_subannotations=None,
trigger_specs=None, stdout=None, stderr=None, stdin=None,
step_test_data=None):
# Calculate our full step name. If a step already has that name, add an
# index to the end of it.
#
# Note that another step could exist with that index already added to it
# by the user. If this happens, we'll continue appending indexes until we
# have a unique step name.
with self.m.context(name_prefix=name):
base_name = self.m.context.name_prefix
name_suffix = ''
while True:
full_name = base_name + name_suffix
if full_name not in self._seen_steps:
break
step_count = self._step_names.setdefault(full_name, 1) + 1
self._step_names[full_name] = step_count
name_suffix = ' (%d)' % step_count
self._seen_steps.add(full_name)
assert isinstance(cmd, (types.NoneType, list))
if cmd is not None:
cmd = list(wrapper) + cmd
for x in cmd:
if not isinstance(x, (int, long, basestring, Path, Placeholder)):
raise AssertionError('Type %s is not permitted. '
'cmd is %r' % (type(x), cmd))
cwd = self.m.context.cwd
if cwd and cwd == self.m.path['start_dir']:
cwd = None
with self.m.context(env_prefixes={'PATH': self._prefix_path}):
env_prefixes = self.m.context.env_prefixes
if ok_ret in ('any', 'all'):
ok_ret = self.step_client.StepConfig.ALL_OK
return self.step_client.run_step(self.step_client.StepConfig(
name=full_name,
base_name=full_name or name,
cmd=cmd,
cwd=cwd,
env=self.m.context.env,
env_prefixes=self.step_client.StepConfig.EnvAffix(
mapping=env_prefixes,
pathsep=self.m.path.pathsep,
),
env_suffixes=self.step_client.StepConfig.EnvAffix(
mapping=self.m.context.env_suffixes,
pathsep=self.m.path.pathsep,
),
allow_subannotations=bool(allow_subannotations),
trigger_specs=[self._make_trigger_spec(trig)
for trig in (trigger_specs or ())],
timeout=timeout,
infra_step=self.m.context.infra_step or bool(infra_step),
stdout=stdout,
stderr=stderr,
stdin=stdin,
ok_ret=ok_ret,
step_test_data=step_test_data,
nest_level=self.m.context.nest_level,
)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSteps():",
"def generation_step_to_dict(generation_step: GenerationStep) -> Dict[str, Any]:\n return {\n \"__type\": generation_step.__class__.__name__,\n \"model\": generation_step.model,\n \"num_trials\": generation_step.num_trials,\n \"min_trials_observed\": generation_st... | [
"0.69314784",
"0.66943085",
"0.6273986",
"0.61101913",
"0.60612357",
"0.60612357",
"0.6031463",
"0.6012955",
"0.59872484",
"0.5910651",
"0.58814424",
"0.58362293",
"0.58362293",
"0.58136266",
"0.57853806",
"0.5746236",
"0.57229125",
"0.5714291",
"0.57003534",
"0.56915283",
"0... | 0.0 | -1 |
Delete or drop table | def _delete_table(self, db, table_name):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_table(self, name: str) -> None:",
"def drop_table(cls)->None:\n database.cursor.execute(\n \"DROP TABLE IF EXISTS {}\".format(cls.table_name))\n database.connection.commit()",
"def deleteTable(self):\n return self.db.table_drop(self.entity).run(self.r)",
"def sqlite... | [
"0.81365436",
"0.80147094",
"0.8011938",
"0.785006",
"0.7730077",
"0.7719094",
"0.77065164",
"0.76392746",
"0.7639245",
"0.7558649",
"0.75291914",
"0.7528163",
"0.7518751",
"0.75040466",
"0.7492301",
"0.7477169",
"0.7466884",
"0.7411313",
"0.7407684",
"0.73777705",
"0.7354117... | 0.7943311 | 3 |
Insert single row into a table | def _insert_table_row(self, db: str, table: str, row: Dict[str, Any]):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insert_row(self, table: str, row_data: dict):\r\n\r\n columns = \"\".join([f\"'{i}',\" for i in row_data]).rstrip(\",\")\r\n keys = \"\".join([f\"'{row_data[i]}',\" for i in row_data]).rstrip(\",\")\r\n sql_statement = f\"INSERT INTO {table} ({columns}) VALUES({keys});\"\r\n try:\r\... | [
"0.7340923",
"0.7256007",
"0.7239077",
"0.7177126",
"0.71218693",
"0.70833904",
"0.7065664",
"0.69191945",
"0.68331724",
"0.682139",
"0.68028295",
"0.67609316",
"0.6746725",
"0.6736111",
"0.673245",
"0.6703915",
"0.6692947",
"0.6680959",
"0.66731584",
"0.6654706",
"0.6627586"... | 0.7353583 | 0 |
select data from a table (select from db.table where column_filers ...) | def _select_data(
self, db: str, table: str, column_filters: Dict[str, str]
) -> List[List]:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data(db, columns, table, condition=\"\"):\n cur = db.cursor()\n cur.execute(SELECT.format(columns, table) + \" \" + condition)\n return cur.fetchall()",
"def select_db(table, cond):\n query = \"SELECT * FROM \" + table + \" WHERE \" + cond\n cursor.execute(query)\n records = cursor.fetc... | [
"0.7451726",
"0.7248107",
"0.69168055",
"0.69079506",
"0.68438905",
"0.6825986",
"0.6800241",
"0.6792302",
"0.6681862",
"0.6657107",
"0.66489816",
"0.6637284",
"0.66219336",
"0.66154295",
"0.654893",
"0.6454015",
"0.641332",
"0.6410601",
"0.63980806",
"0.63969445",
"0.6383279... | 0.6876609 | 4 |
Return DB API Connection | def _db_connection(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_connection(self):\n\n\t\treturn dbapi.connect(credentials.SERVER,\\\n\t\t\t\t\t\t\t credentials.PORT,\\\n\t\t\t\t\t\t\t credentials.USER,\\\n\t\t\t\t\t\t\t credentials.PASSWORD)",
"def get_dbapi20_connection ():\n return cherrypy.engine.pool.connect ()",
"def get_connection():\n con = psy... | [
"0.8348434",
"0.82954013",
"0.78892154",
"0.7847629",
"0.77854586",
"0.7766536",
"0.7627953",
"0.75845844",
"0.75740683",
"0.7564091",
"0.7547969",
"0.7504719",
"0.7473917",
"0.7430099",
"0.7425724",
"0.74137056",
"0.74033695",
"0.7394597",
"0.73863715",
"0.73794466",
"0.7379... | 0.74661154 | 13 |
Converts a tuple to its string representation. Uses different separators (;, /, |) for different depths of the representation. | def tuple_to_string(tuptup):
def join_deepest(tup, sep=';'):
""" Recursive function to create the string representation for the deepest level of the
tuptup list.
Parameters
----------
tup : object
Element to join if list or list of lists.
sep : str, optional
Separation character to join the list elements by.
Returns
-------
object
List containing joined string in max depth. Str if input depth = 1.
"""
if not isinstance(tup, list):
return tup
if not isinstance(tup[0], list):
return sep.join(tup)
for idx, val in enumerate(tup):
tup[idx] = join_deepest(val, sep)
return tup
tup = copy.deepcopy(tuptup)
tup = join_deepest(tup, ';')
tup = join_deepest(tup, '/')
tup = join_deepest(tup, '|')
return tup | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _tupstr(tuple_):\n return ', '.join(list(map(str, tuple_)))",
"def _tuple_to_str(self, the_tuple):\r\n ret = \"\"\r\n for item in the_tuple:\r\n ret += (\" \" + str(item))\r\n return ret[1:]",
"def tupleStrFormat(tupl):\n string = \"this is a tuple (\"\n for element... | [
"0.80097777",
"0.77167994",
"0.7229197",
"0.72018117",
"0.7117311",
"0.707209",
"0.70130855",
"0.70075023",
"0.6833385",
"0.6807723",
"0.67460287",
"0.6742025",
"0.6638861",
"0.66135544",
"0.6548663",
"0.64345735",
"0.6370722",
"0.63114953",
"0.6277102",
"0.627624",
"0.625884... | 0.74598444 | 2 |
Recursive function to create the string representation for the deepest level of the tuptup list. | def join_deepest(tup, sep=';'):
if not isinstance(tup, list):
return tup
if not isinstance(tup[0], list):
return sep.join(tup)
for idx, val in enumerate(tup):
tup[idx] = join_deepest(val, sep)
return tup | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_tree_str(self, depth: int = 0) -> str:\n temp = \" \" * depth + str(self.head) + \"\\n\"\n for son in self.sons:\n temp += son.get_tree_str(depth + 1)\n return temp",
"def tuple_to_string(tuptup):\n\n def join_deepest(tup, sep=';'):\n \"\"\" Recursive function to... | [
"0.6911783",
"0.6560992",
"0.64162666",
"0.64148694",
"0.63143986",
"0.6257376",
"0.6203628",
"0.6170759",
"0.6084149",
"0.60680145",
"0.60680145",
"0.6012516",
"0.60102165",
"0.60009885",
"0.59931505",
"0.59649897",
"0.59439313",
"0.59319067",
"0.5925515",
"0.5863372",
"0.58... | 0.0 | -1 |
Compares two response objects based on equality. | def compare(obj_a, obj_b):
return tuple_to_string(obj_a) == tuple_to_string(obj_b) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __eq__(self, other):\n if not isinstance(other, Response):\n return False\n\n return self.__dict__ == other.__dict__",
"def __eq__(self, other):\n if not isinstance(other, InlineResponse200):\n return False\n\n return self.to_dict() == other.to_dict()",
"de... | [
"0.7743906",
"0.7587754",
"0.7484174",
"0.7346719",
"0.73336023",
"0.73172593",
"0.7316397",
"0.7289357",
"0.72549665",
"0.724851",
"0.72303915",
"0.722987",
"0.7205563",
"0.7172449",
"0.71693856",
"0.7155242",
"0.7135397",
"0.7128382",
"0.71163017",
"0.71147203",
"0.71114576... | 0.0 | -1 |
Compares two response objects based on their NVCness. Only returns true if both responses are in agreement with either responding NVC or not NVC. | def compare(obj_a, obj_b):
return (tuple_to_string(obj_a) == 'NVC') == (tuple_to_string(obj_b) == 'NVC') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def verify_vn_in_api_server(self):\n self.api_verification_flag = True\n self.api_s_vn_obj = self.api_s_inspect.get_cs_vn(\n domain=self.domain_name, project=self.project_name,\n vn=self.vn_name, refresh=True)\n if not self.api_s_vn_obj:\n self.logger.debug(\"V... | [
"0.57760257",
"0.57723004",
"0.57442796",
"0.5704212",
"0.5581943",
"0.55500567",
"0.5549865",
"0.55349195",
"0.55025715",
"0.54922974",
"0.544647",
"0.5440523",
"0.54150635",
"0.5412424",
"0.5370746",
"0.5357937",
"0.535282",
"0.5340017",
"0.53387195",
"0.5306857",
"0.529481... | 0.6934954 | 0 |
Parse script input arguments. | def parse_arguments():
arguments_parser = argparse.ArgumentParser()
arguments_parser.add_argument('--libvirt', help='Using KVM-libvirt as VM provider', action="store_true")
arguments_parser.add_argument('--virtualbox', help='Using KVM as VM provider', action="store_true")
arguments_parser.add_argument('-i', '--img', required=True, action='store', dest='vm_image',
help='Vagrant VM image')
arguments_parser.add_argument('-m', '--memory', required=True, action='store', dest='vm_memory',
help='VM box memory size')
arguments_parser.add_argument('-c', '--cpu', required=True, action='store', dest='vm_cpu',
help='VM box CPU count')
arguments_parser.add_argument('-n', '--node', required=True, action='store', dest='vm_node',
help='VM box nodes count')
arguments_parser.add_argument('-p', '--netprefix', required=True, action='store', dest='vm_netprefix',
help='VM box network prefix ex: 10.10.0')
arguments_parser.add_argument('-e', '--exec', action='store', dest='exec_path',
help='VM box init path')
arguments = arguments_parser.parse_args()
return arguments | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parse_arguments():\n # shift away script name\n scriptname=sys.argv[0]\n shift()\n ncl_cmd=list()\n quali_cmd=list()\n id_cmd=list() \n while(len(sys.argv)>0):\n carg = sys.argv[0]\n shift()\n if(carg == \"--nucleotide\"):\n n... | [
"0.79977995",
"0.7492374",
"0.74865186",
"0.74785024",
"0.73592305",
"0.72400653",
"0.71956307",
"0.7175748",
"0.7048367",
"0.70400876",
"0.70262593",
"0.7005223",
"0.6989726",
"0.69382596",
"0.6925051",
"0.69050217",
"0.69037956",
"0.68907475",
"0.6834261",
"0.68291724",
"0.... | 0.0 | -1 |
Returns the html of url or None if status code is not 200 | def get_html(url):
req = urllib.request.Request(
url,
headers={
'User-Agent': 'Python Learning Program',
'From': 'hklee310@gmail.com'
}
)
resp = urllib.request.urlopen(req)
if resp.code == 200:
return resp.read() # returns the html document
else:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simple_get(self, url):\r\n \"\"\"\r\n The simple_get function accepts a single url argument. \r\n It then makes a GET request to that url. \r\n If nothing goes wrong, you end up with the raw HTML content for the page you requested. \r\n If there were any problems with your re... | [
"0.73372376",
"0.6996886",
"0.6942967",
"0.69052494",
"0.6894238",
"0.6819237",
"0.68131924",
"0.68110603",
"0.68110603",
"0.68110603",
"0.6805156",
"0.6804368",
"0.6774557",
"0.67645854",
"0.67645854",
"0.67632246",
"0.6751196",
"0.6743401",
"0.67430574",
"0.6718777",
"0.671... | 0.6987104 | 2 |
Decodes char byte array to string. | def decode_to_string(self, value):
#if python3 or python 2.7
ret = bytearray(value).decode(encoding='UTF-8')
#if python2.7
#ret = str(bytearray(value))
return ret | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decode_bytes(data: bytearray) -> str:\n pattern = re.compile('\\r', re.UNICODE)\n res = data.decode('utf-8', 'ignore')\n res = pattern.sub('', res)\n return res",
"def _bytes_bytearray_to_str(s):\n if isinstance(s, (bytes, bytearray)):\n return s.decode()\n return s",
"def bytes_to... | [
"0.7620947",
"0.7159157",
"0.6875555",
"0.6810529",
"0.6642219",
"0.65613323",
"0.6543301",
"0.6531421",
"0.6475144",
"0.6392671",
"0.639041",
"0.639041",
"0.6374796",
"0.6297807",
"0.62701327",
"0.6170347",
"0.616709",
"0.61501384",
"0.6131751",
"0.6120125",
"0.60999626",
... | 0.69120693 | 2 |
Runs main gobject loop. | def run_main_loop():
mainloop = GObject.MainLoop() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loop( self ):\n import gtk\n while self.count >= 1:\n log.debug( 'GTK loop restarting' )\n while gtk.events_pending():\n gtk.main_iteration()\n log.debug( 'GTK loop exiting' )\n try:\n del self.t_loop\n except AttributeError, er... | [
"0.760594",
"0.7460419",
"0.72110164",
"0.7099442",
"0.7034407",
"0.691706",
"0.6902692",
"0.68630695",
"0.6785323",
"0.67737657",
"0.6773619",
"0.6746319",
"0.6662695",
"0.66581476",
"0.66040593",
"0.6601622",
"0.65761584",
"0.6574493",
"0.65733767",
"0.6544273",
"0.65289533... | 0.8040331 | 0 |
Initialie dbus system bus acquire adapter/interface for org.bluez.GattManager1 register application for 'org.bluez.GattService1' | def __init__(self):
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
self.bus = dbus.SystemBus()
self.adapter = self._find_adapter()
if not self.adapter:
IFaceNotFoundException('%s interface not found' % GATT_MANAGER_IFACE)
self.service_manager = dbus.Interface(
self.bus.get_object(BLUEZ_SERVICE_NAME, self.adapter),
GATT_MANAGER_IFACE)
self.mainloop = GObject.MainLoop()
self.ctx = GattContext(self.bus, self.mainloop)
self.app = Application(self.ctx)
#print('Registering GATT application...')
self.service_manager.RegisterApplication(self.app.get_path(), {},
reply_handler=register_app_cb,
error_handler=register_app_error_cb) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, alias, adapter=None):\n\n dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)\n\n self.bus = dbus.SystemBus()\n\n if not adapter:\n adapter = self._find_adapter()\n if not adapter:\n logger.error(\"Could not find any adapter implementin... | [
"0.7221227",
"0.61894155",
"0.6014742",
"0.59280574",
"0.5923623",
"0.57182866",
"0.57111996",
"0.56961524",
"0.56900334",
"0.56577533",
"0.5630222",
"0.5583196",
"0.5564716",
"0.5501188",
"0.54448515",
"0.54448307",
"0.5401305",
"0.5356949",
"0.5353707",
"0.5304931",
"0.5298... | 0.77838093 | 0 |
Adds service to previously initialize app. | def add_service(self, service):
self.app.add_service(service) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addService(self, service):\n\t\tself.services.append(service)\n\t\treturn self",
"def add(self, service: AbstractService):\n self.services.append(service)",
"def initService(self):",
"def add_app(self):\n \n pass",
"def add_service(self, zeroconf, service_type, name):\n self... | [
"0.70407766",
"0.6967143",
"0.6634693",
"0.6463807",
"0.6374438",
"0.628673",
"0.62649804",
"0.6252654",
"0.62386537",
"0.62090975",
"0.61053437",
"0.6091435",
"0.605257",
"0.6042793",
"0.60172504",
"0.599833",
"0.599623",
"0.59924555",
"0.5940163",
"0.58883333",
"0.5873045",... | 0.8112667 | 0 |
Return today's date (UTC) formatted as YYYYMMDD. | def _today() -> str:
return strftime(DATE_FORMAT, gmtime()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_date_today() -> str:\n return datetime.now().strftime(\"%Y-%m-%d\")",
"def today():\n today_object = datetime.utcnow()\n today_string = today_object.strftime('%m/%d/%Y')\n return today_string",
"def utc_today_str():\n return datetime.datetime.strftime(datetime.datetime.utcnow(), \"%Y... | [
"0.8165175",
"0.77760684",
"0.77601326",
"0.77202994",
"0.76923996",
"0.7595528",
"0.7585238",
"0.7497268",
"0.7361167",
"0.7340656",
"0.73232466",
"0.7306702",
"0.72497416",
"0.7205314",
"0.71836877",
"0.71293193",
"0.7124812",
"0.70916235",
"0.7083198",
"0.7062737",
"0.7011... | 0.7295072 | 12 |
Return the date (UTC) from 10 days ago formatted as YYYYMMDD. | def _ten_days_ago() -> str:
ten_days_ago = gmtime(mktime(gmtime()) - TEN_DAYS_SECONDS)
return strftime(DATE_FORMAT, ten_days_ago) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ago(self):\n return human(self.timestamp/1000.0, precision=1, abbreviate=True)",
"def relativeTime(date):\n diff = datetime.utcnow() - date\n\n if diff.days > 7 or diff.days < 0:\n return date.ctime()\n elif diff.days == 1:\n return '1 day ago'\n elif diff.days > 1:\n return '%d days ago'... | [
"0.63436246",
"0.6039876",
"0.5983086",
"0.5962784",
"0.58728963",
"0.581312",
"0.58069855",
"0.5791033",
"0.5787348",
"0.5763219",
"0.56588507",
"0.5579537",
"0.5577654",
"0.55374175",
"0.5471164",
"0.539841",
"0.53682923",
"0.5352607",
"0.53389454",
"0.53330094",
"0.5331382... | 0.7581562 | 0 |
Return the last month (UTC) formatted as YYYYMM. | def _last_month() -> str:
time_now = gmtime()
return (
f"{time_now.tm_year}-{time_now.tm_mon - 1:02d}" if time_now.tm_mon > 1
else f"{time_now.tm_year - 1}-12"
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def last_month_day():\r\n return (datetime.now().replace(day=1) + relativedelta(months=1) + timedelta(days=-1)).strftime(\r\n '%d-%m-%Y')",
"def make_last_month_period(dt=None):\n if not dt:\n dt = datetime.utcnow()\n dt = dt.replace(day=1) - timedelta(days=1)\n return dt.strftime('%Y%m... | [
"0.7890911",
"0.77757496",
"0.7772196",
"0.74962604",
"0.7192194",
"0.6839517",
"0.6807995",
"0.6761683",
"0.6746424",
"0.6616606",
"0.66151744",
"0.6588002",
"0.6588002",
"0.6579385",
"0.6565151",
"0.65579987",
"0.65383244",
"0.64961576",
"0.6473222",
"0.64433897",
"0.639331... | 0.8435946 | 0 |
Retrieve the ECB exchange rate data based on the arguments provided. | def _get_ecb_data(frequency: str, start: str, end: str) -> bytes:
content = bytearray()
query_url = urljoin(ECB_DATA_API, ECB_EXR_GBP_EUR.format(frequency))
query_url = urljoin(query_url, ECB_QUERY_PARAMS.format(start, end))
with requests.get(query_url) as response:
response.raise_for_status()
# The data we're requesting is relatively small so we can just read it
# one chunk; to do that we'll set the chunk size to something bigger
# than the data we're reading. Based on some trial and error, it looks
# like 3 KBytes is the right number.
for chunk in response.iter_content(chunk_size=1024 * 3): # 3 KBytes
content.extend(chunk)
return bytes(content) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_exchange_rate_data(self, source_currency, exchanged_currency, valuation_date):\n raise NotImplementedError",
"def getData(self):\n\n url = 'https://www.ecb.europa.eu/stats/eurofxref/eurofxref-hist.zip'\n try:\n file, _ = urlretrieve(url)\n zip_file_object = zipf... | [
"0.6843077",
"0.67887974",
"0.6766991",
"0.67545015",
"0.6378838",
"0.6367499",
"0.62257475",
"0.619634",
"0.6012515",
"0.5951624",
"0.57854265",
"0.5767857",
"0.57583064",
"0.5754834",
"0.57475054",
"0.57261825",
"0.5651264",
"0.5597155",
"0.557165",
"0.5563183",
"0.5555224"... | 0.58530164 | 10 |
Retrieve the latest exchange rate from the given ECB data. | def _get_latest_ecb_rate(data: bytes) -> float:
root = etree.fromstring(data)
values = root.xpath('.//generic:ObsValue/@value', namespaces=root.nsmap)
last_value = len(values) - 1
return float(values[last_value]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_and_store_latest_ecb_exrates():\n response = requests.get(DAILY_ECB_URL)\n # Raise exception if status_code != 200 or ConnectionError\n response.raise_for_status()\n info = ET.fromstring(response.content)[2][0]\n datestamp = datetime.strptime(info.attrib['time'], \"%Y-%m-%d\").date()\n ... | [
"0.7017314",
"0.6967795",
"0.6684886",
"0.6548335",
"0.65449774",
"0.65055674",
"0.6461167",
"0.6431432",
"0.64266616",
"0.6394351",
"0.62385744",
"0.62312907",
"0.62306887",
"0.62064004",
"0.61375725",
"0.6130839",
"0.6130635",
"0.6115328",
"0.60870564",
"0.6060977",
"0.5914... | 0.759938 | 0 |
Retrieve and store the 15min delayed BTC market price in EUR. | def _get_btc_eur_15min(self) -> None:
with requests.get(BITCOIN_TICKER) as response:
response.raise_for_status()
json_data = response.json()
self.btc_eur_15min = json_data["EUR"]["15m"] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getprice():\n\n print(\"Get price\")\n latest_price = get_latest_price(item_code)\n return latest_price",
"def do_work(self) -> None:\n self._get_btc_eur_15min()\n print(\n f\"1 BTC = {self.btc_eur_15min} EUR\"\n f\"\\t\\t(15min delayed market price)\"\n )\... | [
"0.65415394",
"0.6299414",
"0.62688947",
"0.6254417",
"0.62187046",
"0.6205762",
"0.620122",
"0.61773175",
"0.61718124",
"0.6161998",
"0.6105141",
"0.60968745",
"0.6074585",
"0.6072953",
"0.601132",
"0.5992859",
"0.5969653",
"0.5964009",
"0.5900362",
"0.5885169",
"0.586665",
... | 0.70017016 | 0 |
Retrieve and store last month's EUR to GBP average rate. | def _get_eur_gbp_last_month(self) -> None:
last_month = _last_month()
data = _get_ecb_data(FREQUENCY_MONTHLY, last_month, last_month)
self.eur_gbp_last_month = _get_latest_ecb_rate(data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_eur_gbp_last_daily(self) -> None:\n data = _get_ecb_data(FREQUENCY_DAILY, _ten_days_ago(), _today())\n\n self.eur_gbp_last_day = _get_latest_ecb_rate(data)",
"def get_avg(self):\r\n df = pd.read_csv(\"MonthlyRate.csv\")\r\n df = df[df.CurrencyCode == self.choice]\r\n m... | [
"0.65970474",
"0.6344092",
"0.5897189",
"0.5880332",
"0.58152103",
"0.5769175",
"0.57214457",
"0.5711045",
"0.55768675",
"0.5523535",
"0.5501505",
"0.5479372",
"0.5457628",
"0.54402447",
"0.542044",
"0.5388946",
"0.5384516",
"0.5383942",
"0.53801686",
"0.53687716",
"0.5363499... | 0.7096632 | 0 |
Retrieve and store the latest daily EUR to GBP average rate. | def _get_eur_gbp_last_daily(self) -> None:
data = _get_ecb_data(FREQUENCY_DAILY, _ten_days_ago(), _today())
self.eur_gbp_last_day = _get_latest_ecb_rate(data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bitcoinaverage(site):\n url = \"https://apiv2.bitcoinaverage.com/frontend/constants/exchangerates/local\"\n try:\n session = requests.Session()\n cfscrape_requests = cfscrape.create_scraper(sess=session)\n ret = cfscrape_requests.get(url, timeout=(15, 15)).json()[\"rates\"]\n ... | [
"0.65365905",
"0.62230974",
"0.61657596",
"0.6133238",
"0.60252744",
"0.5859477",
"0.58187735",
"0.58073163",
"0.5803112",
"0.5690306",
"0.56884164",
"0.56819123",
"0.56722516",
"0.5655974",
"0.56529254",
"0.56445503",
"0.5622465",
"0.5596036",
"0.559005",
"0.5584927",
"0.558... | 0.714428 | 0 |
Calculate the 15min delayed BTC market price in GBP. | def _get_btc_gbp_15min(self) -> None:
self._get_eur_gbp_last_daily()
self.btc_gbp_15min = self.btc_eur_15min * self.eur_gbp_last_day | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_work(self) -> None:\n self._get_btc_eur_15min()\n print(\n f\"1 BTC = {self.btc_eur_15min} EUR\"\n f\"\\t\\t(15min delayed market price)\"\n )\n\n self._get_eur_gbp_last_month()\n print(\n f\"1 EUR = {self.eur_gbp_last_month} GBP\"\n ... | [
"0.6735869",
"0.6266725",
"0.61613244",
"0.6135455",
"0.6012119",
"0.5998848",
"0.5924012",
"0.5846881",
"0.58299065",
"0.58050394",
"0.5770253",
"0.5769695",
"0.576529",
"0.5724111",
"0.57105625",
"0.5661389",
"0.563068",
"0.56113887",
"0.560933",
"0.5585725",
"0.5583436",
... | 0.7985306 | 0 |
Retrieve and display the data requested in the requirements. | def do_work(self) -> None:
self._get_btc_eur_15min()
print(
f"1 BTC = {self.btc_eur_15min} EUR"
f"\t\t(15min delayed market price)"
)
self._get_eur_gbp_last_month()
print(
f"1 EUR = {self.eur_gbp_last_month} GBP"
f"\t(last month average rate)"
)
self._get_btc_gbp_15min()
print(
f"1 BTC = {self.btc_gbp_15min:.6f} GBP"
f"\t(BTC 15min delayed market price; GBP latest daily average rate)"
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_required():\n return display_required()",
"def _get_information(self):\n pass",
"def get_details(self):",
"def get_data():\n pass",
"def get_entry(name, req, form):\n entry = {'requirement': name, 'form': form}\n form.initial['credits_needed'] = 0\n ... | [
"0.6163567",
"0.60463357",
"0.6041842",
"0.59421384",
"0.59399956",
"0.58859646",
"0.58683854",
"0.5867265",
"0.5864334",
"0.5829533",
"0.57291526",
"0.57291526",
"0.57073796",
"0.5669223",
"0.5638486",
"0.5616218",
"0.560131",
"0.55974495",
"0.5584069",
"0.5578408",
"0.55744... | 0.0 | -1 |
Instantiate and run the worker. | def main() -> None:
worker = Worker()
worker.do_work() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_and_run_worker(self):\n\n # Run processing on QThread worker - prevents GUI lock up\n # Create processing object, map control data\n processing_hub = ProcessingHub(control=self.control)\n\n # Create worker thread, connect signals to methods in this class and start, which call... | [
"0.7279886",
"0.7101314",
"0.70331264",
"0.7012368",
"0.70091134",
"0.69631004",
"0.6924996",
"0.68743694",
"0.6871539",
"0.6871292",
"0.68372667",
"0.6789902",
"0.67830294",
"0.6669269",
"0.6668853",
"0.6661168",
"0.6640133",
"0.6624162",
"0.6593175",
"0.6540589",
"0.6489322... | 0.7226993 | 1 |
Return the cosmology that is being used | def get_cosmology(cosmology=conf.cosmology):
if cosmology.lower() not in available_cosmologies:
raise ValueError(
"Unrecognised cosmology {}. Available cosmologies are {}".format(
cosmology, ", ".join(available_cosmologies)
)
)
elif cosmology.lower() in _astropy_cosmologies:
ind = [
num for num, name in enumerate(_astropy_cosmologies) if
name == cosmology.lower()
][0]
return getattr(cosmo, list(parameters.available)[ind])
elif cosmology.lower() == "planck15_lal":
return Planck15_lal_cosmology()
elif "_with_riess2019_h0" in cosmology.lower():
base_cosmology = cosmology.lower().split("_with_riess2019_h0")[0]
return Riess2019_H0_cosmology(base_cosmology) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_cos_dscp(self):\n return self.__cos_dscp",
"def set_cosmology(self, cosmo):\n self.cosmo = cosmo\n self.h70 = cosmo['h'] # Hubble parameter, H0 = 100h km/s/Mpc\n self.Om = cosmo['omega_M_0'] # Omega_matter\n self.Ol = cosmo['omega_lambda_0'] # Omega_Lambda",
"def _get_co... | [
"0.6441433",
"0.64167005",
"0.6164821",
"0.6161581",
"0.6125467",
"0.60074854",
"0.59982276",
"0.5963294",
"0.5915752",
"0.58894485",
"0.5884741",
"0.57696545",
"0.5693378",
"0.5673406",
"0.5641914",
"0.56051314",
"0.56012136",
"0.55621797",
"0.55592734",
"0.55408865",
"0.547... | 0.7251539 | 0 |
Return the Planck15 cosmology coded up in lalsuite | def Planck15_lal_cosmology():
return cosmo.LambdaCDM(H0=67.90, Om0=0.3065, Ode0=0.6935) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cie_lab(self):\n K = Fraction(1, 3) * Fraction(29, 6) ** 2\n e = Fraction(6, 29) ** 3\n x, y, z = (n / m for n, m in zip(self.cie_xyz, D65))\n fx, fy, fz = (\n n ** Fraction(1, 3) if n > e else K * n + Fraction(4, 29)\n for n in (x, y, z)\n )\n ... | [
"0.55920184",
"0.549476",
"0.54696536",
"0.54056984",
"0.53960073",
"0.5380349",
"0.53594655",
"0.53576845",
"0.53418833",
"0.53027004",
"0.5290028",
"0.5287675",
"0.5284653",
"0.52330744",
"0.51322997",
"0.50801104",
"0.5078625",
"0.50296295",
"0.50066954",
"0.5004581",
"0.4... | 0.70417845 | 0 |
Return the base cosmology but with the Riess2019 H0 value. For details | def Riess2019_H0_cosmology(base_cosmology):
_base_cosmology = get_cosmology(base_cosmology)
return cosmo.LambdaCDM(
H0=74.03, Om0=_base_cosmology.Om0, Ode0=_base_cosmology.Ode0
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sound_horizon_EH(self):\n om_m = self.omega_cb\n om_b = self.omega_b\n om_n = np.sum(self.omega_nu)\n h = self.h \n if self.M_nu_tot == 0.: rs = 44.5*np.log(9.83/om_m)/np.sqrt(1+10*om_b**0.75)*h\n else: rs = 55.154*np.exp(-72.3*(om_n+0.0006)*... | [
"0.6274564",
"0.6107101",
"0.60727805",
"0.58837694",
"0.5814193",
"0.5814193",
"0.56165946",
"0.55797195",
"0.5553944",
"0.5534817",
"0.553009",
"0.55183256",
"0.5515757",
"0.5511963",
"0.5507393",
"0.54924595",
"0.5484746",
"0.5456038",
"0.5441649",
"0.54290783",
"0.5415065... | 0.70496 | 0 |
Returns the supported components e.g. set(['mmic_autodock_vina',...]). Returns Set[str] | def tactic_comps(cls) -> Set[str]:
return set(["mmic_autodock_vina"]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_supported_components(self):\n props = [cdav.SupportedCalendarComponentSet()]\n response = self.get_properties(props, parse_response_xml=False)\n response_list = response.find_objects_and_props()\n prop = response_list[unquote(self.url.path)][\n cdav.SupportedCalendarC... | [
"0.7520092",
"0.6942378",
"0.6502353",
"0.64853776",
"0.64341474",
"0.6051912",
"0.603774",
"0.58496153",
"0.58443105",
"0.58355975",
"0.5832998",
"0.5783114",
"0.5783114",
"0.577528",
"0.57419336",
"0.57056123",
"0.56868654",
"0.5655444",
"0.5626463",
"0.5625516",
"0.5606547... | 0.7170247 | 1 |
Define test variables and initialize app. | def setUp(self):
self.app = create_app()
self.client = self.app.test_client
self.database_name = os.environ.get(
"TEST_DATABASE_NAME",
"abc123abc1234"
)
self.database_path = "postgres://postgres:postgres@{}/{}".format(
"localhost:5432", self.database_name
)
setup_db(self.app, self.database_path)
# drop db, create and populate with test data
setup_db_for_test()
self.casting_assistant_auth_header = {
"Authorization": "Bearer " + CASTING_ASSISTANT_TOKEN
}
self.casting_director_auth_header = {
"Authorization": "Bearer " + CASTING_DIRECTOR_TOKEN
}
self.executive_producer_auth_header = {
"Authorization": "Bearer " + EXECUTIVE_PRODUCER_TOKEN
}
self.create_actor_success = {
"name": "Chris Hemsworth",
"age": 37,
"gender": "Male",
}
self.create_actor_fail = {
"name": "Chris Evans",
"age": 39,
}
self.create_movie_success = {
"title": "Captain America: Civil War",
"release_date": "12/04/2016",
"actors_ids": [1, 2, 3],
}
self.create_movie_fail_1 = {
"title": "Avenger: Infinity War",
}
self.create_movie_fail_2 = {
"title": "Avenger: Infinity War",
"release_date": "27/04/2018",
"actors_ids": [],
}
self.create_movie_fail_3 = {
"title": "Avenger: Infinity War",
"release_date": "27/04/2018",
"actors_ids": [100],
}
# binds the app to the current context
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
# create all tables
self.db.create_all() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n self.app = init_api()",
"def setUp(self):\r\n self.app = app.test_client()\r\n self.app.testing = True",
"def setUp(self):\n self.app = app.test_client()\n self.app.testing = True",
"def setUp(self) -> None:\n self.app = app.app.test_client()\n ... | [
"0.8074992",
"0.799192",
"0.79715896",
"0.7904655",
"0.7897552",
"0.7884764",
"0.77985597",
"0.7775213",
"0.77417946",
"0.77252287",
"0.77252287",
"0.7690111",
"0.7678627",
"0.7651094",
"0.7564304",
"0.7556179",
"0.74967074",
"0.74653935",
"0.7387983",
"0.73835796",
"0.737744... | 0.0 | -1 |
Load the specified mojofile, and return its model id. | def load_model(self, mojofile: str) -> str:
return self._request("GET /loadmojo", params={"file": mojofile}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_model(self, filename):\r\n pass",
"def load_model(self, file=None):\n return None",
"def load_model(self, file_name=None):\n try:\n if file_name:\n self.agent.load_model(file_name)\n else:\n self.agent.load_model()\n print... | [
"0.6718768",
"0.654268",
"0.61337996",
"0.6125505",
"0.6113581",
"0.6078083",
"0.60401374",
"0.60291064",
"0.5945967",
"0.5840561",
"0.5827812",
"0.5739245",
"0.5689958",
"0.5678766",
"0.5677562",
"0.5670736",
"0.56696165",
"0.5610047",
"0.5605511",
"0.55876744",
"0.5587407",... | 0.78735054 | 0 |
Shutdown / kill the server. Sometimes the ``POST /shutdown`` request may fail. In any case we attempt to terminate the process with the SIGKILL signal if it still seems to be running. | def shutdown(self):
try:
self._request("POST /shutdown")
time.sleep(0.300)
except requests.exceptions.ConnectionError:
pass
if self._process and self._process.poll() is None:
self._process.kill()
if self._session:
self._session.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shutdown():\n os.kill(os.getpid(), signal.SIGTERM)",
"def shutdown():\n self_pid = os.getpid()\n logging.info('Forcibly terminating program (PID=%s)', self_pid)\n os.kill(self_pid, signal.SIGKILL)",
"def stop(self):\n self.shutdown_ = True\n if self.running():\n os.kill... | [
"0.8043204",
"0.7408491",
"0.74051774",
"0.73047185",
"0.7299",
"0.7294056",
"0.72432417",
"0.7183416",
"0.7163862",
"0.7163367",
"0.7136405",
"0.71052444",
"0.70983547",
"0.70959175",
"0.70620507",
"0.70323277",
"0.70266837",
"0.7002895",
"0.6961565",
"0.696054",
"0.69446033... | 0.81470776 | 0 |
Update the kernelspecs table. | def refresh_kernelspecs() -> None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh_kernels() -> None:\n ...",
"def modify_devices(self):\n\n for i in self._nodes.items():\n node = i[1]\n devices = node[\"devices\"]\n other_devices = devices[\"other_devices\"]\n kernel_devices = devices[\"kernel_devices\"]\n dpdk_devic... | [
"0.5808753",
"0.5629541",
"0.5591042",
"0.5496405",
"0.54948765",
"0.5418482",
"0.52984756",
"0.5270303",
"0.5197712",
"0.5154047",
"0.5119544",
"0.5119544",
"0.51178193",
"0.5101636",
"0.50797075",
"0.5073883",
"0.5045194",
"0.50378954",
"0.50309587",
"0.5014471",
"0.5006939... | 0.7550118 | 0 |
Update the status table. | def refresh_status() -> None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _update_status(self):\n self._db_update({'status': self.status})",
"def updateStatus(self, status):\n pass",
"def UpdateStatus(self, status):\r\n self.status.update(status)",
"def update_status(self, id, status):\n sql = f\"UPDATE incidences SET status = \\'{status}\\'\\\n ... | [
"0.8145079",
"0.7746542",
"0.7465801",
"0.69591504",
"0.69093305",
"0.6833517",
"0.6802735",
"0.6739377",
"0.6701322",
"0.6697481",
"0.6673145",
"0.6655026",
"0.6641906",
"0.6636951",
"0.64802206",
"0.64509493",
"0.6405129",
"0.64037913",
"0.64026374",
"0.6361408",
"0.6330876... | 0.62391394 | 31 |
Creates a new terminal and returns the name. | def create_terminal() -> str:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __repr__(self):\n return \"Terminal('{}')\".format(self.name)",
"def addTerminal(self, name, **opts):\n opts.update(renamable=True, removable=True)\n name = self.nextTerminalName(name)\n term = NetTerminal(self, name, **opts)\n self.terminals[name] = term\n if term.i... | [
"0.6440198",
"0.6267893",
"0.62144405",
"0.60047346",
"0.5891908",
"0.5890155",
"0.5865237",
"0.57142264",
"0.5690836",
"0.5674329",
"0.56701756",
"0.56039375",
"0.5576599",
"0.5536455",
"0.5528613",
"0.5440345",
"0.5381108",
"0.5373771",
"0.52840245",
"0.52517766",
"0.521793... | 0.80201596 | 0 |
Update the kernels table. | def refresh_kernels() -> None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh_kernelspecs() -> None:\n ...",
"def callUpdateTable(self):\r\n self.updateTable()",
"def gpu_kernels(self, node, name):\r\n raise MethodNotDefined, 'gpu_kernels'",
"def run(self):\n\n self.sess.run(self.update_operations)",
"def update(self, x_train_single, updated_h):\n ... | [
"0.6155734",
"0.57529676",
"0.5730305",
"0.56955045",
"0.56193566",
"0.5611958",
"0.5498789",
"0.5324433",
"0.5293424",
"0.5292726",
"0.5291626",
"0.52879345",
"0.5268349",
"0.5242812",
"0.52361995",
"0.52361995",
"0.51978123",
"0.5197042",
"0.51949096",
"0.5192662",
"0.51908... | 0.7096408 | 0 |
Creates a new kernel and returns the ID | def create_kernel(name: str) -> str:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_kernel(self, kernel_id):",
"def testCreateKernel(self):\n try:\n contextID, retErr = PyOpenCLInterface.CreateContext(self.testResources.listDevicesIDs, self.testResources.dictProperties)\n self.assertEqual(retErr, 0)\n # create program\n programID, retEr... | [
"0.6998178",
"0.6430162",
"0.59596896",
"0.59022087",
"0.58619636",
"0.58563536",
"0.5824651",
"0.5798457",
"0.5699474",
"0.56958765",
"0.5624578",
"0.5619856",
"0.560809",
"0.5569131",
"0.5542638",
"0.5518145",
"0.5472115",
"0.5447868",
"0.5417481",
"0.54118687",
"0.5337183"... | 0.7782273 | 0 |
Creates a new session or returns existing one if path exists | def create_session(
path: str,
type: str,
name: Optional[str] = None,
kernel_name: Optional[str] = None,
kernel_id: Optional[str] = None,
) -> str:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_new_session():\n session = Session.objects.create(uuid=str(uuid4()), container_id=None)\n return session.id",
"def _insert_new_session():\n request = self._make_request()\n session_existing = self._set_up_session_in_Redis_and_makeOne( # noqa: F841\n request, s... | [
"0.7212364",
"0.6900169",
"0.6895351",
"0.6759798",
"0.6726369",
"0.6653804",
"0.6640182",
"0.65958303",
"0.65842575",
"0.65202713",
"0.6479733",
"0.64455444",
"0.6434389",
"0.64199865",
"0.63682336",
"0.6362771",
"0.63557774",
"0.63264036",
"0.6294936",
"0.6289158",
"0.62681... | 0.70272946 | 1 |
Updates an existing session. | def update_session(
id: str,
path: Optional[str] = None,
name: Optional[str] = None,
type: Optional[str] = None,
kernel_name: Optional[str] = None,
kernel_id: Optional[str] = None,
) -> None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def upsert_session(session_data):\n g_db['sessions'].update(\n get_session_id(session_data),\n {\n \"$set\": session_data,\n },\n upsert=True\n )",
"def test_update_session(self):\r\n now = time.time()\r\n\r\n # Make sure the session has data so that it ... | [
"0.7159977",
"0.686218",
"0.68574136",
"0.66107583",
"0.6506551",
"0.6489274",
"0.6447803",
"0.64465",
"0.63691455",
"0.63294715",
"0.62878484",
"0.6127597",
"0.6104474",
"0.6089136",
"0.6085308",
"0.6046978",
"0.6046949",
"0.60441613",
"0.5959553",
"0.59453976",
"0.5927981",... | 0.726062 | 0 |
Updates the content and returns the ID | def refresh_content(
path: str,
content: Optional[bool] = False,
type: Optional[str] = None,
format: Optional[str] = None,
) -> str:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def updateContent(content, **kwargs):",
"def update_content(self):\n raise NotImplementedError",
"def on_update(self):\n self.contentnode.make_content_id_unique()",
"def put(self,id):\r\n data = request.json\r\n return update(id=id,data=data)",
"def update(self, data):\n ... | [
"0.7222523",
"0.6997383",
"0.62771076",
"0.6275982",
"0.62165546",
"0.6215696",
"0.61253357",
"0.6119364",
"0.6075601",
"0.603036",
"0.6030269",
"0.59868115",
"0.5979657",
"0.59795225",
"0.59764755",
"0.596385",
"0.59549665",
"0.59367526",
"0.589859",
"0.5896499",
"0.5894518"... | 0.0 | -1 |
Creates new content and returns the ID. | def create_content(
copy_from: Optional[str] = None,
ext: Optional[str] = None,
type: Optional[str] = None,
path: str = "",
) -> str:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_create(self):\n self.contentnode.make_content_id_unique()",
"def _create(self, title=''):\n return ContentObject(title)",
"def create_with_content_and_title(db, content, title):\n sequence_list = SequenceList(str(uuid.uuid1()))\n sequence_list.content = content\n seque... | [
"0.72641987",
"0.6442757",
"0.64032644",
"0.6294966",
"0.6188546",
"0.61151767",
"0.6097857",
"0.60493034",
"0.5894949",
"0.58636135",
"0.58631575",
"0.5804538",
"0.5788969",
"0.5767498",
"0.57668734",
"0.57604814",
"0.5739654",
"0.57271385",
"0.57177323",
"0.5717616",
"0.571... | 0.5430152 | 51 |
Returns policy and value estimates for given observations. | def step(self, obs):
obs = torch.from_numpy(obs)
_, pi, v = self.forward(obs)
return pi.detach().numpy(), v.detach().numpy() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_observations(\n self, obs: Dict[str, Any], *args: Any, **kwargs: Any\n ) -> Dict[str, Any]:\n\n for uuid in self.compute_order:\n if uuid not in obs:\n obs[uuid] = self.preprocessors[uuid].process(obs)\n\n return {uuid: obs[uuid] for uuid in self.observatio... | [
"0.5557971",
"0.548167",
"0.54308265",
"0.5420844",
"0.5312977",
"0.53012514",
"0.52951914",
"0.5293624",
"0.52801895",
"0.52599216",
"0.5253742",
"0.52483994",
"0.5174865",
"0.517392",
"0.51706284",
"0.5163968",
"0.5154146",
"0.51273954",
"0.5124976",
"0.5118999",
"0.5116802... | 0.0 | -1 |
Modified from DASHAgent to replace activation with SocogSys1 variable binding function. | def update_beliefs(self, result, action):
if self.traceUpdate:
print("Updating beliefs based on action", action, "with result", result)
if result == 'TryAgain':
return None
elif not result and not self.isTransient(action):
if self.traceUpdate:
print("Adding known false", action)
self.knownFalseTuple(action)
if isinstance(result, list):
for bindings in result:
concrete_result = substitute(action, bindings)
if not self.isTransient(concrete_result):
if self.traceUpdate:
print("Adding known true and performed", concrete_result)
self.knownTuple(concrete_result)
self.knownTuple(('performed', concrete_result))
self.update_variable_binding(concrete_result) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _activation(self,components,activation):\r\n \r\n if activation == \"ReLU\":\r\n components.append(nn.ReLU())\r\n elif activation == \"Sigmoid\":\r\n components.append(nn.Sigmoid())\r\n else:\r\n raise Exception(\"Invalid activation fn: \"+activation... | [
"0.58555764",
"0.57150984",
"0.54634446",
"0.5329766",
"0.5275407",
"0.5234855",
"0.5234301",
"0.5216041",
"0.51913345",
"0.5126263",
"0.5109353",
"0.5107513",
"0.50998616",
"0.5097742",
"0.5060914",
"0.5060419",
"0.5039985",
"0.5010341",
"0.50005376",
"0.4995609",
"0.4991565... | 0.0 | -1 |
Takes a two element tuple. The second element must be a Beliefs object which system1 will use to update the belief module. Once updated, the action queue will be emptied and the rules will be checked for satisfied conditions. The action queue will be refilled with new active actions from the rule list. | def process_belief(self, args):
goal, belief = args
if isinstance(belief, Beliefs):
self.belief_module.process_belief(belief)
self.initialize_action_queue()
return [{}] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_beliefs(self, result, action):\n if self.traceUpdate:\n print(\"Updating beliefs based on action\", action, \"with result\", result)\n\n if result == 'TryAgain':\n return None\n\n elif not result and not self.isTransient(action):\n if self.traceUpdat... | [
"0.62839353",
"0.5601004",
"0.54203224",
"0.523504",
"0.523504",
"0.523504",
"0.523504",
"0.52241856",
"0.51511395",
"0.5150723",
"0.5111748",
"0.50751257",
"0.5067793",
"0.50459915",
"0.5037544",
"0.50247914",
"0.4989329",
"0.4953486",
"0.49498907",
"0.49385783",
"0.49159616... | 0.60782725 | 1 |
Calls the belief module's emit_belief method to get and return a Beliefs object with the agents chosen belief for emission. | def emit_belief(self, args):
goal, belief = args
return [{belief: self.belief_module.emit_belief()}] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_belief(self, args):\n goal, belief = args\n\n if isinstance(belief, Beliefs):\n self.belief_module.process_belief(belief)\n self.initialize_action_queue()\n\n return [{}]",
"def calculateBeliefs(self):\n\n belief = {}\n\n for question in self.g... | [
"0.6572719",
"0.60047936",
"0.58963394",
"0.5791217",
"0.5663534",
"0.5584099",
"0.5567305",
"0.550817",
"0.54517233",
"0.53226274",
"0.53167677",
"0.5304004",
"0.51742756",
"0.51660204",
"0.5156423",
"0.5151522",
"0.5149159",
"0.51191115",
"0.5110184",
"0.50023305",
"0.49014... | 0.74441326 | 0 |
Checks if an incoming belief is in conflict with internal beliefs. A conflict occurs when the belief is of opposite valence to a current belief. This method does not update own or perceived beliefs. | def belief_conflict(self, args):
goal, belief = args
if isinstance(belief, Beliefs):
if self.belief_module.is_conflicting_belief(belief):
return [{}]
return [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_conflict(self):\n for diffstat in self.diffstat():\n if diffstat.has_conflict:\n return True\n return False",
"def checkConflicts(self):\n\t\treturn",
"def refine_conflict(self):\n self._raise_not_supported()",
"def check_conflicts(self):\n\t\tshutit_glo... | [
"0.60755587",
"0.5997811",
"0.5935477",
"0.5858629",
"0.57589734",
"0.56303644",
"0.5552522",
"0.55062824",
"0.54827005",
"0.54471344",
"0.5424391",
"0.54060894",
"0.53555745",
"0.53466696",
"0.53354824",
"0.5331523",
"0.5313019",
"0.530491",
"0.5267892",
"0.52595043",
"0.522... | 0.66045004 | 0 |
quad(f, a, b) > \int_a^b f(x) dx Uses some quadrature rule to evaluate the integral. | def quad(f, a, b):
S, D = (b+a)/2.0, (b-a)/2.0
def rescaled_f(x):
return f(x*D + S)*D
return sum(w * rescaled_f(p) for w, p in zip(quad_weights, quad_points)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def quad(func, a, b, args=()):\n\tx_units = a.units\n\tf_units = func(.5*(a+b)).units\n\n\tI, abserr = sciquad(\n\t\tlambda x : func(x*x_units).to(f_units).magnitude,\n\t\ta.magnitude, b.to(x_units).magnitude,\n\t\targs)\n\n\treturn I*x_units*f_units, abserr*x_units*f_units",
"def add_quad(a, b):\n s = np.sqr... | [
"0.7321034",
"0.66224813",
"0.6437059",
"0.64194804",
"0.62829626",
"0.62496614",
"0.6247555",
"0.6206842",
"0.6206842",
"0.6199654",
"0.61690414",
"0.6163885",
"0.61347663",
"0.6107581",
"0.60302866",
"0.60202134",
"0.6018099",
"0.6005248",
"0.60019904",
"0.5973936",
"0.5925... | 0.7673257 | 0 |
Run setup before each request. | def before_request():
id = request.headers.get("User-Id", None)
if id:
user = User.query.get(id)
if user is None:
raise CustomError(400, message="Invalid User-Id in Header.")
g.user = user
else:
g.user = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def before_request():\r\n\r\n\tinit_classes()",
"def setup(ctx):\n handle_no_cache(ctx)",
"def _setup(self) -> None:\n\t\treturn",
"def setup_once():\n # type: () -> None\n _install_httpx_client()\n _install_httpx_async_client()",
"def _setup(self):\n pass",
"def _setup(sel... | [
"0.727703",
"0.69686836",
"0.69070673",
"0.68600476",
"0.683981",
"0.683981",
"0.683981",
"0.683981",
"0.683981",
"0.6837512",
"0.68245745",
"0.6805248",
"0.67752415",
"0.676644",
"0.67472184",
"0.67328984",
"0.67298096",
"0.67094517",
"0.66988313",
"0.6659573",
"0.6658358",
... | 0.0 | -1 |
Return whether or not an email or password combination is valid. | def authenticate():
# Get JSON data from request
json = request.get_json()
if 'email' not in json or 'password' not in json:
raise CustomError(400, message='Must include an email and a password')
# Check email
user = User.query.filter_by(email=json['email']).first()
if user is None:
raise CustomError(401, message='Email or password were not found.')
# Check password
if not check_password_hash(user.password, json['password']):
raise CustomError(401, message='Email or password were not found.')
return jsonify({'success': True, 'user': user.to_dict()}), 201 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def valid_auth(email, password):\n if not email or not password:\n return False\n sha = sha1(email).hexdigest()\n user_info = redis.hgetall(\"sl:account:{}\".format(sha))\n\n return bool(\n type(user_info) == dict and\n user_info.get(\"password\") == pas... | [
"0.7349685",
"0.68957275",
"0.6839669",
"0.6783419",
"0.67657584",
"0.6671322",
"0.66452736",
"0.663105",
"0.6579197",
"0.6508494",
"0.6490613",
"0.647486",
"0.6462656",
"0.6462656",
"0.6454392",
"0.64511716",
"0.64275295",
"0.64244556",
"0.6408592",
"0.6401601",
"0.64013714"... | 0.0 | -1 |
Create new User from supplied infomation. | def signup():
# Get JSON from request
json = request.get_json()
if json is None:
raise CustomError(400, message="No JSON included or "
"Content-Type is not application/json")
expected_keys = ['first_name', 'last_name', 'email', 'password']
if not all(key in json for key in expected_keys):
raise CustomError(400, message="Must include a first name, last name,"
"email and password.")
# # Check if email is unique
if User.query.filter_by(email=json['email']).first() is not None:
raise CustomError(409, message='Email already in use.')
# # TODO: Add password validation
user = User(json['first_name'], json['last_name'], json['email'],
json['password'])
db.session.add(user)
db.session.commit()
return jsonify({'success': True, 'user': user.to_dict()}), 201 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create(self, validated_data:tuple):\n user = user_details.objects.create(user_name=validated_data[0], email=validated_data[1], password=validated_data[2])\n return user",
"def create(cls, **data):\n user = cls()\n for attribute in data:\n if hasattr(user, attribute):\n ... | [
"0.7371264",
"0.715452",
"0.70016223",
"0.6986368",
"0.69517016",
"0.6951686",
"0.69164294",
"0.6909793",
"0.6909042",
"0.68905514",
"0.68693435",
"0.68369526",
"0.6824223",
"0.6820779",
"0.6811556",
"0.6802563",
"0.68015856",
"0.67980665",
"0.67485744",
"0.67480195",
"0.6740... | 0.0 | -1 |
Get a user by its id. | def get_user_by_id(id):
user = User.query.get(id)
if user is None:
raise CustomError(404, 'User with id: {} was not found.'.format(id))
return jsonify({'success': True, 'user': user.to_dict()}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_user_by_id(self, id):\n\t\treturn self.users.get(id)",
"def get(self, id):\n\t\ttry:\n\t\t\tflask_app.logger.debug('We are getting the user: %d', id)\n\t\t\treturn user_service.get(id)\n\t\texcept AssertionError as e:\n\t\t\tuser_space.abort(400, e.args[0], status = \"Could not get user\", statusCode = \... | [
"0.89340585",
"0.8621323",
"0.85916656",
"0.8508148",
"0.8499932",
"0.84347427",
"0.8386604",
"0.8384479",
"0.8328696",
"0.8305895",
"0.82829595",
"0.82829595",
"0.82829595",
"0.82829595",
"0.8282169",
"0.82745594",
"0.8266114",
"0.82544875",
"0.82501876",
"0.8243749",
"0.821... | 0.8168108 | 27 |
Return all of the current user's friends. | def friends():
friends = [u.to_dict() for u in g.user.get_friends()]
return jsonify({'success': True, 'friends': friends}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def friends(self) -> List['Friend']:\n\n return self.sObj.getFriends()",
"async def get_friends(self) -> List[User]:\n me = await self.get_self()\n r = await self.request.request(url=f'https://friends.roblox.com/v1/users/{me.id}/friends', method=\"GET\")\n data = r.json()\n fri... | [
"0.80327207",
"0.80079186",
"0.79557514",
"0.77440524",
"0.74695307",
"0.737918",
"0.73686486",
"0.7360085",
"0.7259125",
"0.7249176",
"0.71591926",
"0.70998305",
"0.70950127",
"0.70513386",
"0.70225525",
"0.7008113",
"0.6999867",
"0.6982058",
"0.6899615",
"0.68960917",
"0.68... | 0.7357716 | 8 |
List or create friendrequests. Create an unconfirmed friendship between two users. Or return all friendships which are not confirmed for the current user. | def create_friend_request():
if request.method == "GET":
friend_requests = [f.to_dict() for f in g.user.get_friend_requests()]
return jsonify({'success': True, 'friend_requests': friend_requests})
if request.method == "POST":
# Get recieving user id from request
json = request.get_json()
if json is None:
raise CustomError(400, message="No JSON included or Content-Type"
"is not application/json")
if 'recieving_user_id' not in json:
raise CustomError(400, message="Must include recieving_user_id")
recieving_user_id = json['recieving_user_id']
# Get the user object
recieving_user = User.query.get(recieving_user_id)
if recieving_user is None:
raise CustomError(
404,
message='User with id: {} was not found.'.format(
recieving_user_id)
)
# Check friendship does not already exist
friendship_exists = Friendship.query.filter(
(Friendship.actioning_user_id == g.user.id) |
(Friendship.recieving_user_id == g.user.id),
(Friendship.actioning_user_id == recieving_user_id) |
(Friendship.recieving_user_id == recieving_user_id)
).first()
if friendship_exists:
raise CustomError(
409,
message="There is either a pending friend request between the"
"two users or the two users are already friends."
)
# Insert friend request
friend_request = Friendship(g.user, recieving_user)
db.session.add(friend_request)
db.session.commit()
return jsonify({'success': True}), 201 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_pending_friendships(self):\n url = 'friendships/pending/'\n return self.send_request(url)",
"def get_friend_requests(self, user):\n return self.filter(addresser_user=user, status=Friendship.STATUS_PENDING, active=True)",
"def friend_request():\n if 'username' not in session:\n ... | [
"0.66678417",
"0.65838015",
"0.64492136",
"0.6419166",
"0.6355479",
"0.6347656",
"0.63212603",
"0.6301099",
"0.6292718",
"0.62728006",
"0.6239098",
"0.62126476",
"0.61244184",
"0.60886",
"0.6074877",
"0.6053998",
"0.6042511",
"0.60373974",
"0.59732705",
"0.5967323",
"0.59309"... | 0.7035371 | 0 |
Get, update or delete friendship with the specified id. | def get_friend_request_with_id(id):
# Get friend request
friendship = Friendship.query.get(id)
if friendship is None:
raise CustomError(
404,
message="Friendship with id: {} not found.".format(id)
)
can_view = friendship.actioning_user_id == g.user.id or \
friendship.recieving_user_id == g.user.id
# Check user is has permission to view that request
if not can_view:
raise CustomError(
401,
message="You are not authorised to view this resource."
)
if request.method == "GET":
return jsonify({'success': True, 'friendship': friendship.to_dict()})
if request.method == "PATCH":
if friendship.recieving_user_id != g.user.id:
raise CustomError(
401,
message="You are not authorised to update this object."
)
json = request.get_json()
if json is None:
raise CustomError(400, message="No JSON included or Content-Type"
"is not application/json")
if 'confirmed' in json:
friendship.confirmed = json['confirmed']
db.session.commit()
return jsonify({'success': True, 'friendship': friendship.to_dict()})
if request.method == "DELETE":
db.session.delete(friendship)
db.session.commit()
return jsonify({'success': True}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_friend(request, id):\n user = request.user\n friend = get_object_or_404(User, id=id)\n user.profile.friends.remove(friend)\n friend.profile.friends.remove(user)\n messages.success(\n request,\n 'User deleted from your friends list'\n )\n return redirect('profiles:profi... | [
"0.6267513",
"0.60474205",
"0.5893467",
"0.57769",
"0.57769",
"0.57769",
"0.55159366",
"0.5514679",
"0.5414053",
"0.53229433",
"0.5308454",
"0.52603304",
"0.52275467",
"0.5149211",
"0.51255256",
"0.51151985",
"0.51151985",
"0.5048067",
"0.49942237",
"0.49900073",
"0.49625716"... | 0.74585414 | 0 |
sendEmails will send an email to all emails associated with a person | def sendEmails(
receiverName,
retainedCompany,
companyName,
emailList,
senderName,
senderEmail,
emailPassword,
senderTitle,
senderCompany,
senderCompanyHomePage,
senderPhone,
port=465,
returnHTML = True
):
for emailToTry in emailList:
# change back the next line after testing
time.sleep(np.random.uniform(5,15)) # I introduced this because I was being rate limited, and I want to see if this will help avoid that - it seems to help
print(f'trying {emailToTry}')
message = MIMEMultipart('alternative')
message['Subject'] = f'Engineering Positions at {companyName}' # change this back when ready to send actual emails
message['From'] = senderEmail
message['To'] = emailToTry # note that this only affects the headers - it does not affect to whom the message gets sent to
[text, html] = emailTextHTML(receiverName, retainedCompany, companyName, senderName, senderTitle, senderCompany, senderEmail, senderCompanyHomePage, senderPhone, returnHTML=returnHTML)
part1 = MIMEText(text, 'plain')
part2 = MIMEText(html, 'html')
message.attach(part1)
message.attach(part2)
# create a secure SSL context
context = ssl.create_default_context()
# now loop over each email message and extract what we need:
with smtplib.SMTP_SSL('smtp.gmail.com', port, context=context) as server:
# Using with smtplib.SMTP_SSL() as server: makes sure that the connection is automatically closed at the end of the indented code block. If port is zero, or not specified, .SMTP_SSL() will use the standard port for SMTP over SSL (port 465).
server.login(senderEmail, emailPassword)
server.sendmail(senderEmail, emailToTry, message.as_string())
# the above line is how we actually change whom the message is sent to | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_email_users():\n\n # Get users emails\n users_emails = User.objects.exclude(\n Q(email='') |\n Q(email=None)\n ).values_list(\n 'email',\n flat=True\n )\n\n # Send email to each user\n # for email_user in users_emails:\n\n title = 'Se han calculado nuevos H... | [
"0.76834345",
"0.7484118",
"0.71810454",
"0.7061762",
"0.70294595",
"0.69372624",
"0.68464893",
"0.6761992",
"0.6630803",
"0.6604708",
"0.6564017",
"0.65435404",
"0.64834946",
"0.64148235",
"0.6410648",
"0.6408025",
"0.63622856",
"0.63590986",
"0.6358885",
"0.6347821",
"0.628... | 0.6047232 | 42 |
outLookSender is not utilized in this module but wrote the function in case we want to send from an outlook account in the future | def outLookSender(receiverAddress, receiverName, retainedCompany, companyName, senderName, senderTitle, senderCompany, senderEmail, senderCompanyHomePage, senderPhone, returnHTML=False):
subj = f'Engineers from {retainedCompany} Search'
if returnHTML:
[text, html] = emailTextHTML(receiverName, retainedCompany, companyName, senderName, senderTitle, senderCompany, senderEmail, senderCompanyHomePage, senderPhone, returnHTML=returnHTML)
else:
[text] = emailTextHTML(receiverName, retainedCompany, companyName, senderName, senderTitle, senderCompany, senderEmail, senderCompanyHomePage, senderPhone, returnHTML=returnHTML)
outlook = app('Microsoft Outlook')
msg = outlook.make(
new=k.outgoing_message,
with_properties={
k.subject: subj,
k.plain_text_content: text
}
)
msg.make(
new=k.recipient,
with_properties={
k.email_address: {
k.name: receiverName,
k.address: receiverAddress
}
}
)
msg.send() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pcorMacVerification(window,refrenceid,objectidentifier,texttoenter):\n try:\n buttons = getAppButtons(window)\n atomacclick(buttons[9])\n childwindow = refrenceid.windowsR()\n protectMoreDevicestitle = getApplicatontitle(childwindow[0])\n entertext(protectMoreDevicestitle,... | [
"0.5824598",
"0.5588486",
"0.5576109",
"0.55656964",
"0.55588704",
"0.5537601",
"0.55139714",
"0.55043477",
"0.5502522",
"0.54980785",
"0.54489857",
"0.5415622",
"0.5409443",
"0.53969055",
"0.5394186",
"0.5353212",
"0.5353212",
"0.534986",
"0.5313206",
"0.5311404",
"0.5300741... | 0.65203226 | 0 |
emailJobs is a function that is used to email jobs/careers email addresses for companies in a dataframe | def emailJobs(
df,
retainedCompany,
senderName,
defaultSenderEmail,
emailPassword,
senderTitle,
senderCompany,
senderCompanyHomePage,
senderPhone,
noContactCompanyListPickleFileName,
port=465,
returnHTML=True
):
try:
with open(noContactCompanyListPickleFileName, 'rb') as inputFile:
noContactCompanyList = pickle.load(inputFile)
except:
noContactCompanyList = []
for i in range(len(df)):
companyName = df['Organization Name'][i]
if companyName.lower() in noContactCompanyList:
pass
try:
domainName = df['Domain'][i]
jobsEmails = [prefix + '@' + domainName for prefix in ['jobs', 'careers']]
# email all the jobs pages for that copmany
sendEmails(
'guys', # addressing general company, so use 'guys' instead of individual name
retainedCompany,
companyName,
jobsEmails,
senderName,
defaultSenderEmail,
emailPassword,
senderTitle,
senderCompany,
senderCompanyHomePage,
senderPhone,
port=port,
returnHTML = returnHTML
)
except:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_email(jobs):\n jobs = jobs\n server = smtplib.SMTP(\"smtp.gmail.com\", 587)\n server.ehlo()\n server.starttls()\n server.ehlo()\n\n server.login(EMAIL, PASS)\n\n subject = f\"Job Scraper Results\"\n\n if jobs != \"Not working\":\n body = []\n job_ids = [\n ... | [
"0.6686441",
"0.573404",
"0.5680976",
"0.5586321",
"0.5568828",
"0.5565883",
"0.5497524",
"0.54533464",
"0.537631",
"0.5351467",
"0.5310948",
"0.5301148",
"0.52795285",
"0.5278291",
"0.5266971",
"0.52349377",
"0.5156166",
"0.51303834",
"0.51244825",
"0.5099825",
"0.5099411",
... | 0.8165515 | 0 |
Return checked to HTML input (checkbox) | def check_ignore(self):
return "checked" if not self.ignore else "" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def uiCheckboxChecked(checkbox):\n\n return clibui.uiCheckboxChecked(checkbox)",
"def htmlCheckbox(labelText, parName, args, labelAttr='', attr=''):\n snippet = htmlLabel(labelText,parName,labelAttr)\n checked = 'checked=\"checked\"' if parName in args else ''\n snippet += '<input type=\"checkbox\" n... | [
"0.73874754",
"0.7013393",
"0.67862654",
"0.6326686",
"0.6137979",
"0.61240286",
"0.61000293",
"0.60839576",
"0.60712683",
"0.60165775",
"0.5976162",
"0.59326965",
"0.58932775",
"0.588823",
"0.5887761",
"0.5884953",
"0.5875955",
"0.5836536",
"0.5805211",
"0.57928985",
"0.5773... | 0.49396482 | 93 |
Function for updating packages | def update(self, package=None):
if package:
query = package
to_update = package.package.name
else:
query = PackageUpdate.objects.filter(server=self, ignore=False)
to_update = " ".join(list(query.values_list('package__name',
flat=True)))
if self.os == 0:
cmd = "apt-get install --only-upgrade {}".format(to_update,)
elif self.os == 1:
cmd = "yum update -y {}".format(to_update,)
r = self.send_command(cmd)
query.delete()
if PackageUpdate.objects.filter(server=self, ignore=False).count() == 0:
self.status = 0
self.save() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_package(self, **kwargs):\n logging.warning('Updating a package removes all existing data. '\n 'If you wish to keep the existing data, use `CachedCKAN.patch_package`.')\n results = self.api.action.package_update(**kwargs)\n self.get_ckan_metadata(True)\n ... | [
"0.7270838",
"0.72650665",
"0.7251651",
"0.7214989",
"0.7085298",
"0.7072634",
"0.66923255",
"0.668152",
"0.6604724",
"0.65995777",
"0.65975875",
"0.6594511",
"0.656834",
"0.6567808",
"0.6567808",
"0.6559777",
"0.65499485",
"0.65261453",
"0.64859855",
"0.64815766",
"0.6460241... | 0.7036477 | 6 |
Display HTML icon of OS distribution. | def show_os_icon(self):
if self.os == 0:
return "<i class='devicon-debian-plain'></i>"
elif self.os == 1:
return "<i class='devicon-redhat-plain'></i>"
else:
return "?" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def downloadicon_name(self):\n return 'platform_%s.gif' % \\\n re.sub(r'\\W', '_', self.context.getPlatform()).lower()",
"def icon(self) -> str:\n return ICON_SERVER",
"def icon(self):\n return \"mdi:hubspot\"",
"def icon(self):\n return ICON_BUS",
"def icon(s... | [
"0.6832323",
"0.68212587",
"0.6478877",
"0.6392684",
"0.63691825",
"0.63691825",
"0.63691825",
"0.63691825",
"0.63691825",
"0.63691825",
"0.63691825",
"0.63691825",
"0.63691825",
"0.63691825",
"0.63597417",
"0.63435024",
"0.63178104",
"0.6314043",
"0.6314043",
"0.6243124",
"0... | 0.83448386 | 0 |
Sets "_total_posts" as amount of posts in the VK domain. | async def _set_total_posts_in_domain(self) -> None:
logger.info('Getting total posts in "vk.com/%s"...', self.vk_domain)
params = {
"v": settings.VKAPI_VERSION,
"access_token": settings.VKAPI_TOKEN,
"count": 1, # Enough just to get total post in domain.
"domain": self.vk_domain,
}
# Data fetching.
response = await vk_asynchronous_request(
self._url_wall_get,
params,
domain=self.vk_domain,
)
self._total_posts_in_domain = response["response"]["count"]
logger.info("Total posts in VK domain: %s", self._total_posts_in_domain) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def posts_count(self):\n return Post.objects.filter(user__username = self.user.username).count()",
"def num_posts(self):\n\n return FlicketTicket.query.filter_by(started_id=self.id).count() + FlicketPost.query.filter_by(\n user_id=self.id).count()",
"def _update_count(self):\n s... | [
"0.63555706",
"0.6204205",
"0.56337523",
"0.55793494",
"0.5573961",
"0.5543833",
"0.5520672",
"0.55201143",
"0.5465146",
"0.5398032",
"0.53932655",
"0.53263414",
"0.52809906",
"0.52755684",
"0.5259448",
"0.5227877",
"0.51914954",
"0.5175302",
"0.51708394",
"0.5170826",
"0.516... | 0.84554565 | 0 |
Fetches posts from VK domain asynchronously and put it into "posts" attribute. | async def fetch_posts(self) -> None:
async def fetch_posts_for_offset(offset) -> list:
logger.info(
"(offset %i) Start fetching posts from vk.com/%s...",
offset,
self.vk_domain,
)
# VK Script code for /execute method.
vks_code = get_wall_post_template.substitute(
{
"domain": self.vk_domain,
"offset": offset,
"posts_per_portion": self._posts_per_portion,
"execution_times": self._execution_times,
}
)
params = {
"v": settings.VKAPI_VERSION,
"access_token": settings.VKAPI_TOKEN,
"code": vks_code,
}
url = self._url_execute
# Posts fetching.
resp_json = await vk_asynchronous_request(
url,
params,
domain=self.vk_domain,
offset=offset,
)
logger.info(
"(offset %i) End fetching posts from vk.com/%s...",
offset,
self.vk_domain,
)
# Gathered posts handling.
posts_from_vk = resp_json["response"]["items"]
posts = posts_as_schemas(posts_from_vk)
del posts_from_vk
return posts
# Checks and preparations.
await self._set_total_posts_in_domain()
if not self._total_posts_in_domain:
return
# Creating tasks for fetching.
tasks = []
posts_per_task = self._posts_per_portion * self._execution_times
offsets = list(range(0, self._total_posts_in_domain, posts_per_task))
for offset in offsets:
tasks.append(asyncio.create_task(fetch_posts_for_offset(offset)))
# Running tasks.
logger.info("Start fetching posts from vk.com/%s...", self.vk_domain)
results = await asyncio.gather(*tasks)
logger.info("End fetching posts from vk.com/%s...", self.vk_domain)
# Flatting results from many tasks into one list.
self._posts = [post for result in results for post in result]
# Final actions.
if self.sort_by_likes:
self._posts = list(sorted(self.posts, key=lambda p: p.likes, reverse=True))
if self.amount_to_fetch:
self._posts = self._posts[: self.amount_to_fetch] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_posts():\n get_chain_address = F\"{CONNECTED_NODE_ADDRESS}/chain\"\n response = requests.get(get_chain_address)\n if response.status_code == 200:\n content = []\n chain = json.loads(response.content)\n for block in chain[\"chain\"]:\n for tx in block[\"transaction... | [
"0.655602",
"0.65269387",
"0.6413515",
"0.6018604",
"0.5916808",
"0.59025943",
"0.5787382",
"0.57700604",
"0.5734009",
"0.57019544",
"0.5652772",
"0.56395626",
"0.5616751",
"0.5613428",
"0.56133306",
"0.56015396",
"0.5592875",
"0.5583471",
"0.5548579",
"0.551852",
"0.55078864... | 0.7330048 | 0 |
Creates posts as Pydantic schemas based on posts data given from VK API. | def posts_as_schemas(posts_from_vk: list[dict]) -> list[Post]:
posts = []
for post_from_vk in posts_from_vk:
try:
post = Post(
date=post_from_vk["date"],
likes=post_from_vk["likes"]["count"],
text=post_from_vk["text"],
path=f"wall{post_from_vk['owner_id']}_" f"{post_from_vk['id']}",
photos=[],
videos=[],
)
except KeyError as exc:
logger.error("No key %s for post: %s", exc, post_from_vk)
continue
# Collect attachments (photos, videos etc.).
if "attachments" in post_from_vk:
attachments = post_from_vk["attachments"]
for attachment in attachments:
if attachment["type"] == "photo":
try:
photo = PostPhoto(url="")
photo.url = attachment["photo"]["sizes"][-1]["url"]
post.photos.append(photo)
except KeyError as exc:
logger.error("No key %s for photo: %s", exc, post_from_vk)
elif attachment["type"] == "video":
video = PostVideo(first_frame_url="")
video_from_vk = attachment["video"]
if "first_frame" in video_from_vk:
video.first_frame_url = video_from_vk["first_frame"][-1]["url"]
elif "image" in video_from_vk:
video.first_frame_url = video_from_vk["image"][-1]["url"]
else:
logger.error("No video image found: %s", post)
continue
post.videos.append(video)
posts.append(post)
return posts | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def posts_post():\n data = request.json\n\n try:\n validate(data, post_schema)\n except ValidationError as error:\n data = {\"message\": error.message}\n return Response(json.dumps(data), 422, mimetype=\"application/json\")\n\n post = Post(title=data[\"title\"], body=data[\"body\"]... | [
"0.6354075",
"0.6284115",
"0.6081727",
"0.59250623",
"0.57985914",
"0.57881165",
"0.56837225",
"0.5657414",
"0.56563574",
"0.56495565",
"0.56208336",
"0.56018806",
"0.55971843",
"0.55958605",
"0.557369",
"0.55589396",
"0.5542766",
"0.5523133",
"0.5506989",
"0.5501767",
"0.550... | 0.7757099 | 0 |
Builds Enter Query Sequence up to Job Title | def buildEnter(self):
ttk.Label(self, text='Enter accession number(s), gi(s), or FASTA sequence(s)',
font=('Arial', '12', 'bold')).grid(row = self.ROW , column = 1, columnspan=4, sticky ='w')
self.clear_button = tk.Button(self, text='Clear', font=('Arial', '9', 'underline'),command =
(lambda view = self: self.controller.clear_query(view)))
self.clear_button.grid(row = self.ROW, column =5, sticky = 'E')
ttk.Label(self, text = 'Subrange:', font=('Arial', '12', 'bold', 'underline')
).grid(row = self.ROW, column = 6, columnspan = 2, sticky = 'E')
self.ROW += 1
self.query_box = scrolledtext.ScrolledText(self, width = 70, height = 7, wrap=tk.CHAR)
self.query_box.grid(row = self.ROW, column = 1, rowspan = 6, columnspan = 5)
self.model_vars['textbox'] = self.query_box
#Event generated only refers to scrolledtext need a reference to load_query_button
self.query_box.bind('<Key>', lambda event, view = self : self.controller.disable_upload_button(event, view))
tk.Label(self, text = 'From:').grid(row = self.ROW, column = 6, sticky = 'E')
self.query_from = ttk.Entry(self, textvariable = self.model_vars['from'], font=('Arial', 10), width = 15)
self.query_from.grid(row = self.ROW, column = 7, columnspan = 2, sticky = 'W')
self.ROW+=2
tk.Label(self, text = 'To:').grid(row = self.ROW, column = 6, sticky = 'E')
self.query_to = tk.Entry(self, textvariable = self.model_vars['to'], font=('Arial', 10), width = 15)
self.query_to.grid(row = self.ROW, column = 7, columnspan =2 , sticky = 'W')
self.ROW+=5
#There are objects that inherit from this one that will need to know this value for genetic code widget
self.upload_file_row = self.ROW
ttk.Label(self, text ='Or, Upload File:', font=('Arial', 10, 'bold')).grid(row = self.ROW, column=1, sticky = 'E')
self.load_query_button = ttk.Button(self, text='Choose File', command =
(lambda view = self: self.controller.load_handler(view)))
self.load_query_button.grid(row = self.ROW, column = 2)
self.load_status = ttk.Label(self, text='No file chosen', font=('Arial', '10'))
self.load_status.grid(row = self.ROW , column = 3, columnspan = 7, sticky = 'W') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def seq_query():\n query_type = input(\n '1.Specific fragment\\n'\n '2.Specific Organism\\n'\n '3.Specific gene\\n'\n '4.All\\n'\n '5.All cds\\n'\n )\n organize = input('Organize output?(y/n)\\n')\n if query_type not in ['1', '2', '3', '4', '5']:\n raise ValueE... | [
"0.57784486",
"0.5282127",
"0.51783377",
"0.5130702",
"0.512259",
"0.50177485",
"0.49613672",
"0.49327144",
"0.48891747",
"0.48707858",
"0.4861328",
"0.4850734",
"0.48490104",
"0.48305196",
"0.48305196",
"0.47956473",
"0.4788198",
"0.47836232",
"0.47815114",
"0.4765019",
"0.4... | 0.44272318 | 75 |
\'w\' means Way > str r will output as float betwenn rangestart and rangeend ri will output as int betwenn rangestart and rangeend | def r(w,rangestart,rangeend):
if w == 'r':
print(random.random(rangestart , rangeend))
if w == 'ri':
print(random.randint(rangestart,rangeend)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_range(self):\r\n\t\tif self.battery_size == 70:\r\n\t\t\trange = 240\r\n\t\telif self.battery_size == 85:\r\n\t\t\trange = 270\r\n\t\t\t\r\n\t\tmessage = \"This car can go approx. \" + str(range)\r\n\t\tmessage += \" miles on a full charge.\"\r\n\t\tprint(message)",
"def get_range(self):\n if self... | [
"0.59787583",
"0.59501344",
"0.5829102",
"0.5819392",
"0.5818934",
"0.57981986",
"0.5792976",
"0.5778558",
"0.5731891",
"0.57078105",
"0.56870514",
"0.56870514",
"0.56675357",
"0.5645643",
"0.56384957",
"0.5616127",
"0.55904025",
"0.5577517",
"0.5560445",
"0.5550442",
"0.5536... | 0.55370027 | 20 |
Initializes the model parameters. | def __init__(self, hparams, batch_size=None, num_classes=None,
summary_dir=None, verbose=False):
self._model = None
self._hparams = hparams
self._verbose = verbose
self._batch_size = batch_size
self._num_classes = num_classes
self._summary_dir = summary_dir | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, **kwargs):\n super(Model, self).__init__(**kwargs)\n self._params = self.find_params()",
"def _initialize_model_params(self):\n\n if 'model' not in self._raw_data_dict:\n raise Error('The \"model\" key is not found in the configuration file. Looks like the parse... | [
"0.8004957",
"0.76819557",
"0.7654317",
"0.75942737",
"0.7463661",
"0.7323001",
"0.7311815",
"0.7258441",
"0.7244055",
"0.72392327",
"0.7186368",
"0.71451765",
"0.709025",
"0.7045288",
"0.7019865",
"0.7001315",
"0.69580907",
"0.69482946",
"0.69447833",
"0.68896854",
"0.684116... | 0.0 | -1 |
Builds an HParam object with default hyperparameters. | def default_hparams():
raise NotImplementedError('Not implemented') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def default_hparams():\n\n model_hparams = hparams.ModelHparams(\n model_name='imagenet_resnet_50',\n model_init='kaiming_normal',\n batchnorm_init='uniform',\n )\n\n dataset_hparams = hparams.DatasetHparams(\n dataset_name='imagenet',\n b... | [
"0.70342475",
"0.7031786",
"0.6892825",
"0.67746496",
"0.6762069",
"0.6687497",
"0.66754377",
"0.6643588",
"0.6621793",
"0.65395397",
"0.6534683",
"0.6510586",
"0.64588934",
"0.6378265",
"0.63729376",
"0.63572174",
"0.62473166",
"0.62324756",
"0.6184058",
"0.61717397",
"0.612... | 0.74614435 | 0 |
Setup the model with specified hyperparameters and train the model. | def train(self, features, labels, seed=None):
raise NotImplementedError('Not implemented') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_model(self, *args, **kwargs):\n raise NotImplementedError",
"def _setupModel(self, parameters):\r\n ModelFitterCore.setupModel(self.roadrunnerModel, parameters,\r\n logger=self.logger)",
"def train_model(self, *args, **kwargs):\n self.model.train(self.training, *args... | [
"0.7335617",
"0.72743934",
"0.7272043",
"0.71031904",
"0.70921487",
"0.70791066",
"0.70587295",
"0.70124644",
"0.6923429",
"0.69174415",
"0.68890333",
"0.68263906",
"0.6823547",
"0.68021375",
"0.6764099",
"0.6710221",
"0.6695851",
"0.6694311",
"0.66900265",
"0.6688204",
"0.66... | 0.0 | -1 |
Evaluates the trained model using the specified features and labels. | def evaluate(self, features, labels):
raise NotImplementedError('Not implemented') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate(model, eval_data, num_labels): \n # Turn on the evaluation state to ignore dropouts\n model.eval()\n results = [predict(model, x) for x, y in eval_data]\n f1_score, accuracy = get_metrics(np.array([y for x, y in eval_data]), results, num_labels)\n return f1_score, accuracy",
"def m... | [
"0.71969485",
"0.6895252",
"0.68876994",
"0.6868299",
"0.6828266",
"0.68280625",
"0.6817962",
"0.6815478",
"0.6739548",
"0.66729695",
"0.66729695",
"0.6669808",
"0.6641863",
"0.65919566",
"0.6583201",
"0.6532106",
"0.6510232",
"0.6506622",
"0.65015924",
"0.64879614",
"0.64562... | 0.8275948 | 0 |
Simple wrapper around sklearn's learning curve module | def learning_curve(self, features, labels):
return learning_curve(self._model, features, labels) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self,features,y):\r\n \r\n if self.learn_type == \"nn\":\r\n #generate supervised dataset\r\n return(self.learner.train_on_batch(features,y))\r\n elif self.learn_type == \"linear\":\r\n grad = 0\r\n n = len(features)\r\n for i in... | [
"0.64221656",
"0.63034314",
"0.6246641",
"0.6199103",
"0.61902195",
"0.6133346",
"0.6075857",
"0.6074158",
"0.6016552",
"0.5998704",
"0.59975034",
"0.59883845",
"0.59740204",
"0.59331024",
"0.5884026",
"0.58812094",
"0.5867041",
"0.58130425",
"0.5809215",
"0.5798471",
"0.5792... | 0.70836437 | 0 |
Create an agent membership | def create_agent_membership(self, context, agent_membership):
am = agent_membership['agent_membership']
with context.session.begin(subtransactions=True):
am_db = AgentMembership(id=am['id'],
ip_address=am['ip_address'])
context.session.add(am_db)
return self._make_agent_membership_dict(am_db) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_member(self, body=None):\r\n return self.post(self.members_path, body=body)",
"def add_member():\n client = RequestManager()\n client.set_method(\"POST\")\n client.set_endpoint(\"/accounts/{0}/memberships\".format(CONFIG_DATA['account_id']))\n body = {\"person_id\": ... | [
"0.6627206",
"0.63848805",
"0.6290456",
"0.6268151",
"0.62504977",
"0.624233",
"0.6192578",
"0.59588885",
"0.5937359",
"0.59215134",
"0.589374",
"0.5893678",
"0.58593506",
"0.58082986",
"0.58055055",
"0.5803748",
"0.580091",
"0.5796165",
"0.5793468",
"0.57622015",
"0.57265323... | 0.7037421 | 0 |
Test load class works correctly and raises right exceptions. | def test_load_class():
full_classname = 'collections.namedtuple'
cls_ = load_class(full_classname)
assert cls_ is collections.namedtuple
with pytest.raises(ValueError):
full_classname = 'collections.Foobar'
load_class(full_classname)
with pytest.raises(ImportError):
full_classname = 'barfoo.Foobar'
load_class(full_classname) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_load_testcase(self):\n tests = self.loader.load(\"tests.sampletest.hellotest.HelloTest\")\n self.assertEqual(len(tests), 1)\n from tests.sampletest.hellotest import HelloTest\n\n self.assertEqual(type(tests[0]), HelloTest)",
"def test_load_testcase_in_module(self):\n t... | [
"0.7552986",
"0.7182643",
"0.70636034",
"0.686629",
"0.6754328",
"0.67336494",
"0.6622316",
"0.6577228",
"0.65132713",
"0.6475406",
"0.6446178",
"0.6431292",
"0.6425918",
"0.63992125",
"0.6388809",
"0.6313314",
"0.6301513",
"0.62873274",
"0.6244719",
"0.62361884",
"0.6233843"... | 0.72938436 | 1 |
irq_handler contains the code you want to execute when the interrupt occurs. Define your own callback function here by rewriting the code. We make an LED flash in this example. | def irq_handler():
# open an LED session
with LEDs() as LED:
# specify the LED which you want to control
led = Led.LED1
# specify the LED status
led_on_off = True
# writes values 10 times, which makes LED1 flash for 3 seconds
for x in range(0, 10):
# turn LED0 on or off
LED.write(led, led_on_off)
# add a short delay
time.sleep(0.3)
# if the LED is on, set the parameter to off
# if the LED is off, set the parameter to on
led_on_off = not led_on_off | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def irq(self, handler: Callable, trigger: int, hard: bool = False) -> Callable:",
"def enable_irq(state:int):",
"def extirq_cbf(task):\n try:\n if not execute_LM_function_Core(task.split(' ')):\n console_write(\"[IRQ] EXTIRQ execute_LM_function_Core error: {}\".format(task))\n except Ex... | [
"0.6793415",
"0.59784335",
"0.5772505",
"0.5751147",
"0.569456",
"0.56923246",
"0.55878675",
"0.5526748",
"0.53978044",
"0.50646555",
"0.4927286",
"0.4895538",
"0.47954524",
"0.4737531",
"0.4658877",
"0.4636048",
"0.46294534",
"0.46239135",
"0.45867148",
"0.45833647",
"0.4576... | 0.72954494 | 0 |
Creates a newly initialised datasource with the specified training or test data. If _load_test_data and _load_training_data are implemented, they are called as well, and saving/loading is handled there. | def __init__(self, _expected_d_input=None, shuffled=False, _training_data=None, _test_data=None):
self._training_data = _training_data
self._test_data = _test_data
self._num_training_samples = None
self._num_test_samples = None
self._available_training_lengths = []
self._available_test_lengths = []
self._training_data_path = os.path.join(type(self).__name__, "training_data.npy")
if not os.path.isdir(type(self).__name__):
os.mkdir(type(self).__name__)
self._expected_d_input = _expected_d_input
if self._training_data is None:
if os.path.isfile(self._training_data_path):
self._training_data = np.load(self._training_data_path).item()
for _, value in self._training_data.items():
print(value[0].shape)
print(_expected_d_input)
if value[0].shape[2] != _expected_d_input:
self._training_data = None
break
self._test_data_path = os.path.join(type(self).__name__, "testing_data.npy")
if self._test_data is None:
if os.path.isfile(self._test_data_path):
self._test_data = np.load(self._test_data_path).item()
for _, value in self._test_data.items():
if value[0].shape[2] != _expected_d_input:
self._test_data = None
break
if self._test_data is None:
self._load_test_data()
if self._training_data is None:
self._load_training_data()
if shuffled:
print("Shuffling not supported at this point!")
self.current_index = {}
for key, _ in self._training_data.items():
self.current_index[key] = 0
self._initialise_available_training_lengths()
self._initialise_available_test_lengths()
self._swapped_test_data = None
self._swapped_training_data = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_creator(config):\n train_dataset, val_dataset = LinearDataset(2, 5), LinearDataset(2, 5)\n train_loader = DataLoader(train_dataset, batch_size=config[\"batch_size\"])\n val_loader = DataLoader(val_dataset, batch_size=config[\"batch_size\"])\n return train_loader, val_loader",
"def _init_trai... | [
"0.66052645",
"0.6420619",
"0.63613456",
"0.63351035",
"0.6321313",
"0.6239802",
"0.62257236",
"0.6179237",
"0.61755306",
"0.6175438",
"0.6154874",
"0.60897607",
"0.6085115",
"0.60844827",
"0.60654354",
"0.60575354",
"0.6012859",
"0.60088485",
"0.59914017",
"0.5959267",
"0.59... | 0.0 | -1 |
This property returns the test data, and loads the test data if it doesn't exist. Note that this function returns the test data and labels in the form ([MPS input size, batch, other dimensions], [batch, classifications]) in accordance with how it is used in the MPS and MPSOptimizer classes. If the data is required in the form ([batch, MPS input size, other dimensions], [batch, classifications]), the variable _test_data should be used | def test_data(self):
if self._test_data is None:
self._load_test_data()
if self._swapped_test_data is None:
self._swapped_test_data = {}
for key, value in self._test_data.items():
self._swapped_test_data[key] = value
return self._swapped_test_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_data(self):\n\n return self.__valid_data, self.__valid_labels",
"def get_data():\r\n if not path_validation(MODEL_PATH, read_access=True):\r\n exit(0) \r\n if not path_validation(TEST_DATA_PATH, read_access=True):\r\n exit(0) \r\n if not path_validation(TEST_LABEL_PATH, rea... | [
"0.70449495",
"0.6995364",
"0.6777924",
"0.66745436",
"0.65272325",
"0.6480013",
"0.6461336",
"0.63587755",
"0.63330346",
"0.630707",
"0.6300786",
"0.6267064",
"0.6254497",
"0.62507844",
"0.6207419",
"0.62047035",
"0.61748314",
"0.6138185",
"0.61186504",
"0.6097096",
"0.60467... | 0.637961 | 7 |
Get test data (perhaps from remote server) and preprocess in shape [batch, expected shape of element]. Remember to call this from a subclass to save the things. | def _load_test_data(self):
self._save_test_data() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_test_batch(self):\n data = self.data\n # size of train dataset\n num_train = data['train'].shape[0]\n image_size = self.image_size\n # index of test image that is being classified in this batch\n batch_index = self.test_batch_index\n\n # create batch array... | [
"0.6583765",
"0.6574852",
"0.6408957",
"0.6383224",
"0.63410145",
"0.62234724",
"0.6203767",
"0.60811645",
"0.60587937",
"0.60369897",
"0.60160315",
"0.6011207",
"0.6007375",
"0.5988163",
"0.5982726",
"0.59650534",
"0.5962204",
"0.59511745",
"0.59286445",
"0.59174746",
"0.590... | 0.56260467 | 56 |
This property returns the training data, and loads the training data if it doesn't exist. Note that this function returns the training data and labels in the form ([MPS input size, batch, other dimensions], [batch, classifications]) in accordance with how it is used in the MPS and MPSOptimizer classes. If the data is required in the form ([batch, MPS input size, other dimensions], [batch, classifications]), the variable _training_data should be used | def training_data(self):
if self._training_data is None:
self._load_training_data()
if self._swapped_training_data is None:
self._swapped_training_data = {}
for key, value in self._training_data.items():
self._swapped_training_data[key] = value
return self._swapped_training_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_training_data(self) -> Tuple[List[np.ndarray], np.ndarray]:\n return self._load_set(config.TRAIN_DIR, True)",
"def getTrainingData(self):\n raise NotImplementedError",
"def get_training_data() -> GraphDataset:\n _load_data_if_needed()\n return training_data",
"def get_data_train(... | [
"0.7380025",
"0.71378094",
"0.6946885",
"0.69251007",
"0.6852432",
"0.6813262",
"0.6799918",
"0.6751542",
"0.6742031",
"0.6650401",
"0.6590069",
"0.65826356",
"0.64915186",
"0.6483886",
"0.6470438",
"0.6446683",
"0.6443755",
"0.62918407",
"0.6268519",
"0.6244086",
"0.6243447"... | 0.72757715 | 1 |
Get training data (perhaps from remote server) and preprocess in shape [batch, expected shape of element] Remember to call this from a subclass to save the things. | def _load_training_data(self):
self._save_training_data() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTrainingData(self):\n raise NotImplementedError",
"def preprocess_data(self):\n\n self._preprocess_train_data()\n self._preprocess_test_data()",
"def preprocess_train_data(self):\r\n print(\"* Preprocessing training data.\", flush=True)\r\n prep.create_HDF_file(self.C.... | [
"0.6737078",
"0.6703798",
"0.6572939",
"0.6394934",
"0.6370723",
"0.6355788",
"0.63249135",
"0.63132846",
"0.62849104",
"0.62823945",
"0.6275704",
"0.6259968",
"0.6241224",
"0.62354356",
"0.6223649",
"0.6207623",
"0.616901",
"0.6163054",
"0.6130993",
"0.61243504",
"0.611347",... | 0.611388 | 20 |
Gets the next n data and label points from the training dataset, where n = batch_size length is the expected length of the inputs | def next_training_data_batch(self, batch_size, expected_length):
if self._training_data is None:
self._load_training_data()
if expected_length in self._training_data:
actual_length = expected_length
else:
differences = np.abs(self._available_training_lengths - expected_length)
mininimum_loc = np.argmin(differences)
actual_length = self._available_training_lengths[mininimum_loc]
all_data, all_labels = self._training_data[actual_length]
if batch_size > len(all_data):
print("Probably shouldn't do this; your batch size is greater than the size of the dataset")
data = None
labels = None
while batch_size > 0:
if len(all_data) - self.current_index[actual_length] < batch_size:
# print("A" + str(self.current_index))
batch_size -= (len(all_data) - self.current_index[actual_length])
if self.current_index[actual_length] != len(all_data):
if data is None:
data = np.array(all_data[self.current_index[actual_length]:])
labels = np.array(all_labels[self.current_index[actual_length]:])
else:
data = np.concatenate((data, all_data[self.current_index[actual_length]:]), axis=0)
labels = np.concatenate((labels, all_labels[self.current_index[actual_length]:]), axis=0)
self.current_index[actual_length] = 0
else:
# print("B" + str(self.current_index))
if data is None:
data = all_data[self.current_index[actual_length]:self.current_index[actual_length] + batch_size]
labels = np.array(all_labels[self.current_index[actual_length]:self.current_index[actual_length] + batch_size])
else:
data = np.concatenate((data, all_data[self.current_index[actual_length]:self.current_index[actual_length] + batch_size]), axis=0)
labels = np.concatenate((labels, all_labels[self.current_index[actual_length]:self.current_index[actual_length] + batch_size]),
axis=0)
self.current_index[actual_length] += batch_size
batch_size = 0
data = np.array(data)
data = np.swapaxes(data, 0, 1)
return (actual_length, (data, labels)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def next_batch(data, labels, batch_size):\n global _index_in_epoch\n start = _index_in_epoch\n _index_in_epoch += batch_size\n _num_examples = len(data)\n\n if _index_in_epoch > _num_examples:\n # Shuffle the data\n perm = np.arange(_num_examples)\n np.random.shuffle(perm)\n ... | [
"0.74909896",
"0.72481114",
"0.7209859",
"0.7209859",
"0.7201162",
"0.71773523",
"0.7172384",
"0.7135985",
"0.7022579",
"0.7018331",
"0.700701",
"0.69525987",
"0.69326574",
"0.6926339",
"0.6913601",
"0.6876563",
"0.6874372",
"0.6864877",
"0.6839137",
"0.6839137",
"0.6784926",... | 0.7202597 | 4 |
Property giving the number of training samples for each key | def num_train_samples(self):
if self._num_training_samples is None:
for key, value in self._training_data.items():
self._num_training_samples[key] = len(value[0])
return self._num_training_samples | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_training_examples(self):",
"def get_num_train_samples(self):\n raise NotImplementedError",
"def __len__(self):\n if self.TRAIN_BOOL is True:\n count = len(self.dict_batch_1[b'data'])\n count += len(self.dict_batch_2[b'data'])\n count += len(self.dict_batch... | [
"0.76472265",
"0.72392845",
"0.7154465",
"0.71007866",
"0.6989497",
"0.6887514",
"0.68653405",
"0.6852151",
"0.6844715",
"0.680676",
"0.6782863",
"0.67534184",
"0.6745939",
"0.6720424",
"0.670524",
"0.66739583",
"0.66528374",
"0.66478294",
"0.66011435",
"0.659892",
"0.6594394... | 0.7513668 | 1 |
Property giving the number of test samples | def num_test_samples(self):
if self._num_test_samples is None:
for key, value in self._test_data.items():
self._num_test_samples[key] = len(value[0])
return self._num_test_samples | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _number_of_samples(self):\n return len(self._raw_data.samples)",
"def setTestSampleSize(self, Ntest):\n self.Ntest = Ntest",
"def getNrSamples(self): \r\n return self.numSamples",
"def num_training_examples(self):",
"def sample_count(self):",
"def get_number_of_testing(self):\... | [
"0.76248336",
"0.7584526",
"0.7412485",
"0.74109805",
"0.7401342",
"0.7390789",
"0.72752166",
"0.726213",
"0.7233075",
"0.7224675",
"0.71610683",
"0.71362716",
"0.71249604",
"0.70941573",
"0.7070653",
"0.704998",
"0.70279443",
"0.7010169",
"0.6996375",
"0.6985382",
"0.6942792... | 0.8134777 | 0 |
Parse nonchimeric alignments with walkspolicy mask with pysam backend. | def test_mock_pysam():
mock_sam_path = os.path.join(testdir, "data", "mock.sam")
mock_chroms_path = os.path.join(testdir, "data", "mock.chrom.sizes")
try:
result = subprocess.check_output(
[
"python",
"-m",
"pairtools",
"parse",
"--walks-policy",
"mask",
"-c",
mock_chroms_path,
mock_sam_path,
],
).decode("ascii")
except subprocess.CalledProcessError as e:
print(e.output)
print(sys.exc_info())
raise e
# check if the header got transferred correctly
sam_header = [l.strip() for l in open(mock_sam_path, "r") if l.startswith("@")]
pairsam_header = [l.strip() for l in result.split("\n") if l.startswith("#")]
for l in sam_header:
assert any([l in l2 for l2 in pairsam_header])
# check that the pairs got assigned properly
for l in result.split("\n"):
if l.startswith("#") or not l:
continue
print(l)
assigned_pair = l.split("\t")[1:8]
simulated_pair = l.split("CT:Z:SIMULATED:", 1)[1].split("\031", 1)[0].split(",")
print(assigned_pair)
print(simulated_pair)
print()
assert assigned_pair == simulated_pair | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def recover_para_segmentations(aligned_data, gt_paras_sents, human_translator_data):\n sents_covered = 0\n outputs = \"\"\n for p1, s1, src in zip(aligned_data[\"gt_paras\"], gt_paras_sents, aligned_data[\"source_paras\"]):\n num_sents = len(s1)\n outputs += f\"<b>Source</> = {src}\\n<b>Goog... | [
"0.54760754",
"0.53752476",
"0.50093",
"0.49865466",
"0.49599963",
"0.49551886",
"0.49462736",
"0.49260557",
"0.48655975",
"0.48339373",
"0.48032323",
"0.47868657",
"0.47548297",
"0.47518492",
"0.47361124",
"0.4728765",
"0.47222483",
"0.47153112",
"0.4694921",
"0.46828434",
"... | 0.0 | -1 |
Parse all alignment in each read with walkspolicy all and pysam backend. | def test_mock_pysam_parse_all():
mock_sam_path = os.path.join(testdir, "data", "mock.parse-all.sam")
mock_chroms_path = os.path.join(testdir, "data", "mock.chrom.sizes")
try:
result = subprocess.check_output(
[
"python",
"-m",
"pairtools",
"parse",
"--walks-policy",
"all",
"-c",
mock_chroms_path,
"--add-pair-index",
mock_sam_path,
],
).decode("ascii")
except subprocess.CalledProcessError as e:
print(e.output)
print(sys.exc_info())
raise e
# check if the header got transferred correctly
sam_header = [l.strip() for l in open(mock_sam_path, "r") if l.startswith("@")]
pairsam_header = [l.strip() for l in result.split("\n") if l.startswith("#")]
for l in sam_header:
assert any([l in l2 for l2 in pairsam_header])
# check that the pairs got assigned properly
id_counter = 0
prev_id = ""
for l in result.split("\n"):
if l.startswith("#") or not l:
continue
if prev_id == l.split("\t")[0]:
id_counter += 1
else:
id_counter = 0
prev_id = l.split("\t")[0]
assigned_pair = l.split("\t")[1:8] + l.split("\t")[-2:]
simulated_pair = (
l.split("CT:Z:SIMULATED:", 1)[1]
.split("\031", 1)[0]
.split("|")[id_counter]
.split(",")
)
print(assigned_pair)
print(simulated_pair, prev_id)
print()
assert assigned_pair == simulated_pair | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def align(aligner, reads):\n counter = 0\n for read in SeqIO.parse(reads, \"fasta\"): \n try:\n alignInfo = next(aligner.map(str(read.seq)))\n print(alignInfo) \n except StopIteration:\n print(read.format(\"fasta\"), end='')",
"def align_reads(self):\n ... | [
"0.64816856",
"0.6445793",
"0.6301667",
"0.62004644",
"0.61849123",
"0.6097089",
"0.60698086",
"0.58538115",
"0.5847832",
"0.5827765",
"0.5823239",
"0.581179",
"0.581081",
"0.57999784",
"0.57905626",
"0.57769024",
"0.5743529",
"0.5681",
"0.5614261",
"0.55853",
"0.5562853",
... | 0.4956526 | 87 |
Highlights currentSelection on stdscr. | def highlightSelection(stdscr, selection):
s = tuple(list(selection.addStrArgs)+[curses.A_REVERSE])
stdscr.addstr(*s) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def switchSelection(stdscr, lastSelection, currentSelection):\n stdscr.addstr(*lastSelection.addStrArgs)\n highlightSelection(stdscr, currentSelection)",
"def draw_selected(self):\n if self.get_selected() is not None and not self.check_if_locked(self.get_selected()):\n self.color_cell(pos... | [
"0.77326286",
"0.6310758",
"0.62849665",
"0.6241305",
"0.6179359",
"0.6145725",
"0.6066579",
"0.5976721",
"0.59747756",
"0.5841172",
"0.5825609",
"0.5814059",
"0.57745796",
"0.5750539",
"0.5745168",
"0.5714649",
"0.56804645",
"0.5667968",
"0.5662644",
"0.56395173",
"0.5605114... | 0.75370693 | 1 |
Removes highlight of lastSelection and highlights currentSelection. | def switchSelection(stdscr, lastSelection, currentSelection):
stdscr.addstr(*lastSelection.addStrArgs)
highlightSelection(stdscr, currentSelection) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unhighlight(self, current=False):\n if current:\n if self.currentEditor is not None:\n self.currentEditor.highlight()\n else:\n for editor in self.editors:\n editor.highlight()",
"def Unselect(self):\r\n\r\n if self._current:\r\n ... | [
"0.71389216",
"0.7015364",
"0.65264606",
"0.6345358",
"0.63410205",
"0.6158486",
"0.61175185",
"0.6002156",
"0.59705675",
"0.5914801",
"0.5895148",
"0.58718735",
"0.5871529",
"0.579935",
"0.5699949",
"0.56871504",
"0.5649178",
"0.5641103",
"0.5631721",
"0.5626519",
"0.5604202... | 0.66989064 | 2 |
Opens a display of the todoList for the user to select an item and choose an action to take. | def selectTodoItem(stdscr, todoList):
selectionList = displayTodoList(stdscr, todoList)
currentSelection = selectionList.current()
highlightSelection(stdscr, currentSelection)
while True:
lastSelection = currentSelection
k = stdscr.get_wch()
if k in ['k', curses.KEY_UP]:
currentSelection = selectionList.prev()
elif k in ['j', curses.KEY_DOWN]:
currentSelection = selectionList.next()
elif k in ['d']:
return Action(Action.REMOVE, currentSelection.todoItem)
elif k == 'q':
return None
switchSelection(stdscr, lastSelection, currentSelection)
stdscr.refresh() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trigger_open(self):\n self.get_selected()\n if self.selected_item:\n self.controller.display_item(self.selected_item)",
"def do_todo_open(self, arg):\n try:\n open_list = arg[\"<list_param>\"]\n choice = arg[\"--choice\"]\n if choice == \"name\... | [
"0.7201459",
"0.6838654",
"0.6731044",
"0.61206925",
"0.61021215",
"0.6093656",
"0.6077997",
"0.600439",
"0.5995444",
"0.59719115",
"0.5954215",
"0.5914398",
"0.5907249",
"0.584988",
"0.58350575",
"0.58085567",
"0.5782954",
"0.5759071",
"0.57363194",
"0.5728824",
"0.5727189",... | 0.5482432 | 50 |
Creates an initial display of todoList. | def displayTodoList(stdscr, todoList):
stdscr.clear()
i = 1
selectionList = SelectionList()
for category in todoList.categories:
stdscr.addstr(i, 1, '='*len(category))
stdscr.addstr(i+1, 1, category)
stdscr.addstr(i+2, 1, '='*len(category))
i+=4
j = 1
for item in todoList[category]:
stdscr.addstr(i, 1, str(j)+'. '+item.name)
selectionList.append(Selection((i, 1, str(j)+'. '+item.name), item))
i += 1
j += 1
i += 1
return selectionList | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_todo_list_view(request: HttpRequest, pk: int) -> HttpResponse:\n todo_list = TodoListModel.objects.get(id=pk)\n\n return render(request, 'todo/display_todo_list.html', {'todo_list': todo_list})",
"def __init__(self, todolist):\n\t\tself.todolist = todolist\n\t\tself.selection_id = None;\n\t\t\n... | [
"0.66892177",
"0.6522817",
"0.637842",
"0.62759596",
"0.6237733",
"0.6173121",
"0.61659193",
"0.602686",
"0.59981143",
"0.59325516",
"0.5924609",
"0.59100825",
"0.5881322",
"0.58435386",
"0.58121586",
"0.5809451",
"0.5808901",
"0.58015496",
"0.5759406",
"0.573308",
"0.5713373... | 0.62428325 | 4 |
This initializes the DotStars object by setting a buffer, and creating an SPI object. The start and end frames for the SPI communication are created, and the leds are cleared of values. | def __init__(self, leds):
self.ledcount = leds
# create a buffer
self.buffersize = self.ledcount * 4
self.buffer = bytearray(self.ledcount * 4)
self.emptybuffer = bytearray(self.ledcount * 4)
for i in range(0, self.buffersize, 4):
self.emptybuffer[i] = 0xff
self.emptybuffer[i + 1] = 0x0
self.emptybuffer[i + 2] = 0x0
self.emptybuffer[i + 3] = 0x0
# Start frame and endframe for the SPI communication (end frame is not
# needed)
self.startframe = bytes([0x00, 0x00, 0x00, 0x00])
self.endframe = bytes([0xff, 0xff, 0xff, 0xff])
# initialize SPI (needs to be at 45 MHz in order to maximize the speed.
# This is the limiting factor for the system's speed)
self.spi = SPI(1, SPI.MASTER, baudrate=45000000,
polarity=0, phase=0, bits=8, firstbit=SPI.MSB)
self.clearleds() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, spi, dc, rst, led):\n self._spi = spi\n self._spi.open()\n self._spi.set_mode(0)\n self._spi.set_clock_frequency(4000000)\n\n self._dc = dc\n self._rst = rst\n self._led = led\n self._enabled = False",
"def SPIsetup(self):\n self.w... | [
"0.6566145",
"0.6351516",
"0.63373953",
"0.6181888",
"0.61446565",
"0.6111663",
"0.59349567",
"0.57059205",
"0.55544007",
"0.554452",
"0.5522998",
"0.5509588",
"0.5503774",
"0.5380477",
"0.53760433",
"0.5336554",
"0.5321746",
"0.5299691",
"0.52520025",
"0.5248618",
"0.5240898... | 0.74753237 | 0 |
This method clears all the LEDs in the DotStar object | def clearleds(self):
self.buffer = self.emptybuffer[:] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset(self):\n for tlight in self.trafficLights:\n self.trafficLights[tlight].reset()",
"def clear(tft, oled):\n oled.fill(tft.BLACK)",
"def clear(self):\n self._delayvalue = _CFG[\"delay\"]\n self._colormode = _CFG[\"colormode\"]\n self._delete(\"all\")\n ... | [
"0.7280109",
"0.71445733",
"0.70629704",
"0.7045428",
"0.7045238",
"0.6974367",
"0.6902242",
"0.6812371",
"0.679938",
"0.6789614",
"0.6783468",
"0.6701193",
"0.6695715",
"0.66421294",
"0.6637276",
"0.6621712",
"0.6612257",
"0.6599522",
"0.6587036",
"0.6560823",
"0.65587413",
... | 0.7821158 | 0 |
This sets the led to the specified color | def setled(self, led, red=0, green=0, blue=0):
# Set the offset for the bytes to be sent over SPI
offset = led * 4
self.buffer[offset] = 255 # equals a 1 or 0
self.buffer[offset + 1] = blue
self.buffer[offset + 2] = green
self.buffer[offset + 3] = red | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_color(self, color):\n pass",
"def led(color: int, /) -> None:",
"def set_color(self, color):\n\t\tpass",
"def set_status_led(self, color):\n raise NotImplementedError",
"def set_led_color(color):\n requests.post('http://192.168.4.1/pixel', data=json.dumps(color))",
"def set_color... | [
"0.79685086",
"0.7963265",
"0.7882642",
"0.7830038",
"0.7777075",
"0.7772559",
"0.7689048",
"0.7609751",
"0.7561696",
"0.7547319",
"0.7526898",
"0.75140256",
"0.74926007",
"0.7445177",
"0.74438715",
"0.7430585",
"0.741375",
"0.73898387",
"0.73771507",
"0.7346666",
"0.7305123"... | 0.76878345 | 7 |
This method send the led data over SPI | def send(self):
self.spi.send(self.startframe + self.buffer) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send(self, data):\n self._serial.write('spi = SPI(2, SPI.SLAVE, baudrate=500000, polarity=0, phase=0)\\r\\n'.encode('utf-8'))\n self._serial.write('data=bytearray({})\\r\\n'.format(data).encode('utf-8'))\n self._serial.write('spi.send(data, timeout=50000)\\r\\n'.encode('utf-8'))\n s... | [
"0.79480565",
"0.75796175",
"0.74145585",
"0.71241754",
"0.70519936",
"0.7026349",
"0.69845456",
"0.69544286",
"0.68782145",
"0.68735623",
"0.6855078",
"0.6780902",
"0.67396015",
"0.6739508",
"0.6665076",
"0.66579545",
"0.6576727",
"0.6573629",
"0.6531924",
"0.6527273",
"0.64... | 0.58544874 | 44 |
Extracts function arguments for the decorated function. | def _extract_func_args(
obj: str,
arg_formats: Dict[str, int],
arg_defaults: Dict[str, Any],
input_dict: Dict[str, List[tfx_types.Artifact]],
output_dict: Dict[str, List[tfx_types.Artifact]],
exec_properties: Dict[str, Any],
beam_pipeline: Optional[_BeamPipeline] = None,
) -> Dict[str, Any]:
result = {}
for name, arg_format in arg_formats.items():
if arg_format == function_parser.ArgFormats.INPUT_ARTIFACT:
input_list = input_dict.get(name, [])
if len(input_list) == 1:
result[name] = input_list[0]
elif not input_list and name in arg_defaults:
# Do not pass the missing optional input.
pass
else:
raise ValueError(
('Expected input %r to %s to be a singleton ValueArtifact channel '
'(got %s instead).') % (name, obj, input_list))
elif arg_format == function_parser.ArgFormats.OUTPUT_ARTIFACT:
output_list = output_dict.get(name, [])
if len(output_list) == 1:
result[name] = output_list[0]
else:
raise ValueError(
('Expected output %r to %s to be a singleton ValueArtifact channel '
'(got %s instead).') % (name, obj, output_list))
elif arg_format == function_parser.ArgFormats.ARTIFACT_VALUE:
input_list = input_dict.get(name, [])
if len(input_list) == 1:
result[name] = input_list[0].value
elif not input_list and name in arg_defaults:
# Do not pass the missing optional input.
pass
else:
raise ValueError(
('Expected input %r to %s to be a singleton ValueArtifact channel '
'(got %s instead).') % (name, obj, input_list))
elif arg_format == function_parser.ArgFormats.PARAMETER:
if name in exec_properties:
result[name] = exec_properties[name]
elif name in arg_defaults:
# Do not pass the missing optional input.
pass
else:
raise ValueError(
('Expected non-optional parameter %r of %s to be provided, but no '
'value was passed.') % (name, obj))
elif arg_format == function_parser.ArgFormats.BEAM_PARAMETER:
result[name] = beam_pipeline
if name in arg_defaults and arg_defaults[name] is not None:
raise ValueError('beam Pipeline parameter does not allow default ',
'value other than None.')
else:
raise ValueError('Unknown argument format: %r' % (arg_format,))
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_captured_arguments(func):\n captured_arguments = getattr(func, ATTR_NAME)\n if type(captured_arguments) is not _CapturedArguments: # pylint: disable=unidiomatic-typecheck\n # The attribute was not set by tcm, so effectively it does not exist.\n raise AttributeError\n delattr(fun... | [
"0.73196673",
"0.72977483",
"0.70101774",
"0.69297165",
"0.67886466",
"0.6777163",
"0.66621184",
"0.66599494",
"0.6646892",
"0.6559392",
"0.6559392",
"0.6526404",
"0.6525048",
"0.6484637",
"0.6477483",
"0.63901955",
"0.6309247",
"0.6304008",
"0.6285241",
"0.6279031",
"0.62567... | 0.0 | -1 |
Validates and assigns the outputs to the output_dict. | def _assign_returned_values(
function,
outputs: Dict[str, Any],
returned_values: Dict[str, Any],
output_dict: Dict[str, List[tfx_types.Artifact]],
json_typehints: Dict[str, Type], # pylint: disable=g-bare-generic
) -> Dict[str, List[tfx_types.Artifact]]:
result = copy.deepcopy(output_dict)
if not isinstance(outputs, dict):
raise ValueError(
('Expected component executor function %s to return a dict of '
'outputs (got %r instead).') % (function, outputs))
# Assign returned ValueArtifact values.
for name, is_optional in returned_values.items():
if name not in outputs:
raise ValueError(
'Did not receive expected output %r as return value from '
'component executor function %s.' % (name, function))
if not is_optional and outputs[name] is None:
raise ValueError('Non-nullable output %r received None return value from '
'component executor function %s.' % (name, function))
try:
result[name][0].value = outputs[name]
except TypeError as e:
raise TypeError(
('Return value %r for output %r is incompatible with output type '
'%r.') %
(outputs[name], name, result[name][0].__class__)) from e
# Handle JsonValue runtime type check.
if name in json_typehints:
ret = function_parser.check_strict_json_compat(outputs[name],
json_typehints[name])
if not ret:
raise TypeError(
('Return value %r for output %r is incompatible with output type '
'%r.') % (outputs[name], name, json_typehints[name]))
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_output_dictionary(self):\n\n return_dictionary = {}\n\n for output_path in self.provided_outputs:\n return_dictionary[output_path.full_path] = self.get_value(output_path)\n\n return return_dictionary",
"def _check_output_observable_dict(\n self, output_observab... | [
"0.6837641",
"0.67924696",
"0.6737341",
"0.6717199",
"0.65907484",
"0.64653313",
"0.64050525",
"0.6332762",
"0.6276232",
"0.62465364",
"0.62231946",
"0.61539495",
"0.6134005",
"0.61062723",
"0.6100173",
"0.60465825",
"0.60387117",
"0.6037164",
"0.60108835",
"0.60005236",
"0.5... | 0.5601338 | 53 |
View all the images in the dataset, on a 3 by X grid size. | def view_images(dataset, size):
images, labels = dataset
assert images.shape[0] == labels.shape[0]
num_images = images.shape[0]
num_cols = 3
num_rows = np.ceil(num_images / num_cols).astype("int")
plt.figure(figsize=size)
for i in range(num_images):
image = images[i]
label = labels[i]
ax = plt.subplot(num_rows, num_cols, i + 1)
plt.imshow(np.array(image, dtype="float"))
plt.title("Number: " + str(label))
plt.axis("off") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_imgs(dataset, n_imgs, plot_size=(15, 15), cmap=None):\n n_cols = int(np.sqrt(n_imgs))\n n_rows = int(np.ceil(np.sqrt(n_imgs)))\n class_idx = dataset.class_to_idx\n idx_class = idx_to_class(class_idx)\n\n fig, axes = plt.subplots(n_rows, n_cols, figsize=plot_size)\n for i, ax in enumerate... | [
"0.6872789",
"0.6706518",
"0.66048354",
"0.65576744",
"0.6477456",
"0.6438162",
"0.64273864",
"0.6386546",
"0.6381494",
"0.63184965",
"0.6311449",
"0.62808603",
"0.6278003",
"0.6259482",
"0.6259482",
"0.62534124",
"0.6243781",
"0.6227257",
"0.6224085",
"0.6216505",
"0.6158989... | 0.760682 | 0 |
Normalises and reshapes the images in the dataset. | def normalise(dataset):
# Scale images to the [0, 1] range
dataset = dataset.astype("float32") / 255
# Make sure images have shape (28, 28, 1)
return np.expand_dims(dataset, -1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize_dataset(self):",
"def normalize_images(data, blend_cat, Args):\n im = data['X_train']['blend_image']\n std = np.std(im)\n mean = np.mean(im)\n data['X_train']['blend_image'] = (im - mean) / std\n data['X_val']['blend_image'] = (data['X_val']['blend_image'] - mean) / std\n data['X_... | [
"0.69572496",
"0.67912114",
"0.67600954",
"0.6746723",
"0.6741553",
"0.6741553",
"0.6712757",
"0.667788",
"0.66753983",
"0.66424495",
"0.6628572",
"0.6604109",
"0.657797",
"0.65456814",
"0.6539488",
"0.64729387",
"0.6469001",
"0.64613545",
"0.6418981",
"0.63990253",
"0.639689... | 0.7404679 | 0 |
Randomly chooses some data from the dataset. | def choice(dataset, size):
x, y = dataset
assert x.shape[0] == y.shape[0]
num_datapoints = x.shape[0]
mask = np.zeros(num_datapoints).astype("bool")
mask[:size] = True
np.random.default_rng().shuffle(mask)
return x.compress(mask, axis=0), y.compress(mask, axis=0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getRandom(self):\n return random.choice(self.data)",
"def data_source():\n dataset = [0.1, 0.2, 0.3, 0.4, 0.5]\n while True:\n time.sleep(2)\n yield random.choice(dataset)",
"def randomRow(self):\r\n l = []\r\n for row in self.data:\r\n l.append(row)\r\n ... | [
"0.73725927",
"0.7179318",
"0.70049816",
"0.6915993",
"0.68809456",
"0.6742614",
"0.66800225",
"0.6568194",
"0.65536875",
"0.65441173",
"0.6533348",
"0.652268",
"0.65050435",
"0.64911234",
"0.6435912",
"0.64282745",
"0.6402564",
"0.6368382",
"0.63608557",
"0.6303325",
"0.6302... | 0.65095335 | 12 |
__init__(self, filename) Create a configparser object and store config values in class variables for later retrieval | def __init__(self, filename="config.ini"):
if not os.path.isfile(filename):
self.set_default_config(filename)
self.config = configparser.ConfigParser()
self.config.read(filename)
self.filename = filename
self.database_name = self.config.get('config',
'database_name',
fallback='manga.db')
self.volume_limit = self.config.getint('config',
'volume_limit',
fallback=128)
self.series_per_page = self.config.getint('config',
'series_per_page',
fallback=0)
self.compact_list = self.config.getboolean('config',
'compact_list',
fallback=False)
self.show_empty_series = self.config.getboolean('config',
'show_empty_series',
fallback=False)
self.default_to_gui = self.config.getboolean('config',
'default_to_gui',
fallback=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, filename, dirname='~'):\n self.config = configparser.ConfigParser()\n\n expanded_dirname = os.path.expanduser(dirname)\n self.configuration_filename = os.path.join(expanded_dirname, filename)\n if os.path.isfile(self.configuration_filename):\n self.config.r... | [
"0.8556377",
"0.8332688",
"0.83071285",
"0.83033603",
"0.80947435",
"0.80304974",
"0.79447347",
"0.7944664",
"0.7938114",
"0.79321945",
"0.7806958",
"0.77945864",
"0.7792556",
"0.777831",
"0.7728286",
"0.7725837",
"0.77198017",
"0.7715732",
"0.7694171",
"0.768226",
"0.7636645... | 0.792374 | 10 |
set_property(self, prop_name, prop_value) Set a config property to a new value. Checks to ensure that prop_name refers to a valid property, and prop_value is a valid value for that property | def set_property(self, prop_name, prop_value):
if prop_name == "database_name":
if (prop_value and isinstance(prop_value, str)
and prop_value[-3:] == ".db"):
self.config["config"]["database_name"] = prop_value
self.database_name = prop_value
elif prop_name == "volume_limit":
if isinstance(prop_value, int) and prop_value > 0:
self.config["config"]["volume_limit"] = str(prop_value)
self.volume_limit = prop_value
elif prop_name == "series_per_page":
if isinstance(prop_value, int) and prop_value >= 0:
self.config["config"]["series_per_page"] = str(prop_value)
self.series_per_page = prop_value
elif prop_name == "compact_list":
if ((isinstance(prop_value, int) and prop_value in [0, 1])
or isinstance(prop_value, bool)):
self.config["config"]["compact_list"] = str(prop_value)
self.compact_list = prop_value
elif prop_name == "show_empty_series":
if ((isinstance(prop_value, int) and prop_value in [0, 1])
or isinstance(prop_value, bool)):
self.config["config"]["show_empty_series"] = str(prop_value)
self.show_empty_series = prop_value
elif prop_name == "default_to_gui":
if ((isinstance(prop_value, int) and prop_value in [0, 1])
or isinstance(prop_value, bool)):
self.config["config"]["default_to_gui"] = str(prop_value)
self.default_to_gui = prop_value
with open(self.filename, 'w') as config_ini:
self.config.write(config_ini) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SetProp(self, name, value):\n self._props[name] = value\n self._changed(name, value)",
"def set_prop(prop, value, config_type=\"\", config_path=\"\"):\n\n path = get_config_path(config_type, config_path)\n set_property_value(prop, value, path)",
"def set_property(self, name, value):\n ... | [
"0.7744824",
"0.7589677",
"0.7511228",
"0.71817976",
"0.7180543",
"0.71250933",
"0.70207524",
"0.6867484",
"0.6805842",
"0.66848767",
"0.6684025",
"0.6615753",
"0.64751947",
"0.6462285",
"0.6445133",
"0.6340753",
"0.6315831",
"0.6308148",
"0.62673914",
"0.6257923",
"0.6245488... | 0.7238388 | 3 |
set_default_config() Saves default config to desired filename | def set_default_config(self, filename):
if os.path.isfile(filename):
os.remove(filename)
config = configparser.ConfigParser()
default_cfg = {'config': {'database_name': 'manga.db',
'volume_limit': 128,
'series_per_page': 0,
'compact_list': 0,
'show_empty_series': False,
'default_to_gui': True}}
config.read_dict(default_cfg)
with open(filename, 'w') as config_ini:
config.write(config_ini)
# Reset class variables for config object as well
self.config = config
self.filename = filename
self.database_name = 'manga.db'
self.volume_limit = 128
self.series_per_page = 0
self.compact_list = False
self.show_empty_series = False
self.default_to_gui = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def writeDefaultConfig(conffile='default.conf', defaults={}):\n if not os.path.exists(conffile):\n cp = createConfigParserfromDict(defaults, ['base'])\n cp.write(open(conffile,'w'))\n return conffile",
"def write_default_config():\n # TODO: BROKEN!\n config_path = pathlib.Path(xdg.BaseD... | [
"0.7795459",
"0.76893884",
"0.7577117",
"0.7335307",
"0.7192635",
"0.71420926",
"0.71333855",
"0.7080361",
"0.70510966",
"0.7046068",
"0.70410866",
"0.7012563",
"0.70065206",
"0.693917",
"0.6721765",
"0.6714416",
"0.67111033",
"0.66713166",
"0.66688925",
"0.66178155",
"0.6423... | 0.67744064 | 14 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.