Do a cold reset in BMC
555803
def reset_bmc(self):
        
        response = self.raw_command(netfn=6, command=2)
        if 'error' in response:
            raise exc.IpmiException(response['error'])
829708
def reset(self):
        

        self.stream.write(self.normal_cursor)
        self.stream.write(self.csr(0, self.height))
        self.stream.write(self.move(self.height, 0))
716028
def reset(self):
        
        ttype = self.tableType()
        if ( not ttype ):
            return False
        
        values = self.saveValues()
        self.setRecord(ttype())
        restore_values = {}
        for column in self.savedColumnsOnReset():
            if column in restore_values:
                restore_values[column] = values[column]
        if restore_values:
            self.loadValues(restore_values)
        
        return True
604201
def reset(type = 'cold')
      if ['cold', 'warm'].include?(type)
        key = "#{type}-reset"
        command(key)
      else
        logger.error("reset type: #{type} is not a valid choice, use warm or cold") if logger
        raise "reset type: #{type} is not a valid choice, use warm or cold"
      end
    end
628854
def reset():
    
    global MAIN_DIR, TEMP_DIR, DOWNLOAD_DIR, SAVESTAT_DIR, LOGFILE_PATH, USING_CORES, LOG_LEVEL, DISABLE_TQDM, \
        SAVE_STATE_VERSION
    MAIN_DIR = Path('./')
    TEMP_DIR = MAIN_DIR.joinpath(Path('temp/'))
    DOWNLOAD_DIR = MAIN_DIR.joinpath(Path('downloads/'))
    SAVESTAT_DIR = MAIN_DIR.joinpath(Path('savestates/'))
    LOGFILE_PATH = MAIN_DIR.joinpath(Path('UniDown.log'))

    USING_CORES = 1
    LOG_LEVEL = 'INFO'
    DISABLE_TQDM = False

    SAVE_STATE_VERSION = Version('1')
378978
def reset(vm_):
    '''
    
    '''
    with _get_xapi_session() as xapi:
        vm_uuid = _get_label_uuid(xapi, 'VM', vm_)
        if vm_uuid is False:
            return False
        try:
            xapi.VM.hard_reboot(vm_uuid)
            return True
        except Exception:
            return False
549693
async def cluster_reset(self, node_id, soft=True):
        
        option = 'SOFT' if soft else 'HARD'
        return await self.execute_command('CLUSTER RESET', option, node_id=node_id)
96089
def cmd_ublox_reset(self, args):
        ''''''
        print("Sending uBlox reset")
        msg = struct.pack("<HBB", 0xFFFF, 0x0, 0)
        self.master.mav.gps_inject_data_send(
            self.target_system,
            self.target_component,
            len(msg),
            bytearray(msg.ljust(110, '\0')))
130737
def reset(self):
        """"""

        # sampling
        self.it = 1
        self.batch = 0
        self.ncall = 0
        self.bound = []
        self.eff = 1.
        self.base = False

        # results
        self.saved_id = []
        self.saved_u = []
        self.saved_v = []
        self.saved_logl = []
        self.saved_logvol = []
        self.saved_logwt = []
        self.saved_logz = []
        self.saved_logzvar = []
        self.saved_h = []
        self.saved_nc = []
        self.saved_boundidx = []
        self.saved_it = []
        self.saved_n = []
        self.saved_bounditer = []
        self.saved_scale = []
        self.saved_batch = []
        self.saved_batch_nlive = []
        self.saved_batch_bounds = []

        # results from our base run
        self.base_id = []
        self.base_u = []
        self.base_v = []
        self.base_logl = []
        self.base_logvol = []
        self.base_logwt = []
        self.base_logz = []
        self.base_logzvar = []
        self.base_h = []
        self.base_nc = []
        self.base_boundidx = []
        self.base_it = []
        self.base_n = []
        self.base_bounditer = []
        self.base_scale = []

        # results from our most recent addition
        self.new_id = []
        self.new_u = []
        self.new_v = []
        self.new_logl = []
        self.new_nc = []
        self.new_it = []
        self.new_n = []
        self.new_boundidx = []
        self.new_bounditer = []
        self.new_scale = []
        self.new_logl_min, self.new_logl_max = -np.inf, np.inf
226412
def reset(self):
        """"""
        self.v = self.c
        self.u = self.b * self.v
        self.fired = 0.0
        self.current = self.bias
430460
def OnCellFrozen(self, event):
        """"""

        with undo.group(_("Frozen")):
            self.grid.actions.change_frozen_attr()

        self.grid.ForceRefresh()

        self.grid.update_attribute_toolbar()

        event.Skip()
1281588
def reset():
    
    colors = [(0., 0., 1.), (0., .5, 0.), (1., 0., 0.), (.75, .75, 0.),
            (.75, .75, 0.), (0., .75, .75), (0., 0., 0.)]
    for code, color in zip("bgrmyck", colors):
        rgb = mpl.colors.colorConverter.to_rgb(color)
        mpl.colors.colorConverter.colors[code] = rgb
        mpl.colors.colorConverter.cache[code] = rgb
    mpl.rcParams.update(mpl.rcParamsDefault)
    mpl.rcParams['figure.facecolor'] = 'white'
    mpl.rcParams['axes.facecolor'] = 'white'
268373
def reset(self):
        
        self.remaining_cycles = self.initial_training_cycles
        self.needle_index = random.randrange(self.input_size)
191790
def reset_to_default(self):
        """"""
        reset = QMessageBox.warning(self, _("Shortcuts reset"),
                                    _("Do you want to reset "
                                      "to default values?"),
                                    QMessageBox.Yes | QMessageBox.No)
        if reset == QMessageBox.No:
            return
        reset_shortcuts()
        self.main.apply_shortcuts()
        self.table.load_shortcuts()
        self.load_from_conf()
        self.set_modified(False)
1057419
def reset(self):
        
        surface = Surface(self.width, self.height)
        surface.fill(BLACK)
        self.matrix = surface.matrix
418682
def reset(self):
        """"""
        self.minimum = None
        self.maximum = None
        self.start_time = None  # datetime, absolute start time

        self.idx_current = None
        self.idx_markers = []
        self.idx_annot = []

        if self.scene is not None:
            self.scene.clear()
        self.scene = None
76545
def reset_state(self):
        

        self.h.data.zero()
        self.c.data.zero()