Updates the number of load commands in the raw data.
 @param ncmds [Integer] the new number of commands
 @return [void]
 @api private
960771
def update_ncmds(ncmds)
      fmt = Utils.specialize_format("L=", endianness)
      ncmds_raw = [ncmds].pack(fmt)
      @raw_data[16..19] = ncmds_raw
    end
315965
def update(self, command=None, **kwargs):
        
        if command is None:
            argparser = self.argparser
        else:
            argparser = self[command]

        for k,v in kwargs.items():
            setattr(argparser, k, v)
331688
def _add_numeric_methods_disabled(cls):
        
        cls.__pow__ = make_invalid_op('__pow__')
        cls.__rpow__ = make_invalid_op('__rpow__')
        cls.__mul__ = make_invalid_op('__mul__')
        cls.__rmul__ = make_invalid_op('__rmul__')
        cls.__floordiv__ = make_invalid_op('__floordiv__')
        cls.__rfloordiv__ = make_invalid_op('__rfloordiv__')
        cls.__truediv__ = make_invalid_op('__truediv__')
        cls.__rtruediv__ = make_invalid_op('__rtruediv__')
        cls.__mod__ = make_invalid_op('__mod__')
        cls.__divmod__ = make_invalid_op('__divmod__')
        cls.__neg__ = make_invalid_op('__neg__')
        cls.__pos__ = make_invalid_op('__pos__')
        cls.__abs__ = make_invalid_op('__abs__')
        cls.__inv__ = make_invalid_op('__inv__')
833337
def init
      @model = Hashie::Mash.new
      @log = ENV["NPOLAR_ENV"] == "test" ? ::Logger.new("/dev/null") : ::Logger.new(STDERR)
      @concurrency = 5
      @slice = 1000
      @param={}
    end
1289274
def set_data(new_data, mode)
      raise ArgumentError, "Data can't be set unless mode is :command or :merge" unless %i[command merge].include? mode
      raise ArgumentError, 'Data must be a hash when in merge mode' if mode == :merge && !new_data.is_a?(Hash)

      validate_rows new_data if mode == :command

      @data = new_data.dup
    end
608861
def update(self, byts):
        '''
        
        '''
        self.size += len(byts)
        [h[1].update(byts) for h in self.hashes]
124748
def update_status(unsent_reg_ids, all_results, multicast_result)
      results = multicast_result.results
      raise RuntimeError, "Internal error: sizes do not match. currentResults: #{results}; unsentRegIds: #{unsent_reg_ids}" unless results.size==unsent_reg_ids.size
      new_unsent_reg_ids = []
      unsent_reg_ids.each_with_index {|reg_id, index|
        result = results[index]
        all_results[reg_id]= result
        new_unsent_reg_ids << reg_id unless (result.error_code.nil? || result.error_code.eql?(ERROR_UNAVAILABLE))
      }
      new_unsent_reg_ids
    end
246847
def update(self):
        '''
        
        '''
        self.kSS = 1.0
        self.MSS = 1.0
        self.KtoLnow_init = self.kSS
        self.Rfunc = ConstantFunction(self.Rfree)
        self.wFunc = ConstantFunction(self.wRte)
        self.RfreeNow_init = self.Rfunc(self.kSS)
        self.wRteNow_init = self.wFunc(self.kSS)
        self.MaggNow_init = self.kSS
        self.AaggNow_init = self.kSS
        self.PermShkAggNow_init = 1.0
        self.TranShkAggNow_init = 1.0
        self.makeAggShkDstn()
        self.AFunc = ConstantFunction(1.0)
627827
async def update_flags(self, messages: Sequence[MessageT],
                           flag_set: FrozenSet[Flag], mode: FlagOp) -> None:
        
        ...
714808
def threaded_run!(files, change)
      return if files.empty?
      file_number = 0
      total_files = files.length
      mutex       = Mutex.new
      threads     = []
      5.times do |i|
        threads[i] = Thread.new {
          until files.empty?
            mutex.synchronize do
              file_number += 1
              Thread.current["file_number"] = file_number
            end
            file = files.pop rescue nil
            next unless file
            Rails.logger.info "[#{Thread.current["file_number"]}/#{total_files}] to #{change}..."
            
            case change
            when 'destroy'
            when 'create'
            when 'update'
            end
          end
        }
      end
      threads.each { |t| t.join }
    end
436038
def update(params={})
      machine.request_options = machine.request_options.merge(body: parse_params(params, :metadata).to_json)
      Zcloudjp::Client.put("/machines/#{machine.id}/metadata", machine.request_options)
    end
837973
def atomic_update(clazz, updates = {})
      @adds += updates.keys.length
      indexer.add_atomic_update(clazz, updates)
    end
676689
def method_missing method, *args, &block
        message = ::NRSER::Message.new method, *args, &block
        @current = message.send_to @current
        @updates << ::NRSER::HistoryUpdate.new \
          message: message,
          response: @current
      end
791380
def _updateNumbers(self, linenumers):
        
        b = self.blockCount()
        c = b - linenumers
        if c > 0:
            # remove lines numbers
            for _ in range(c):
                # remove last line:
                self.setFocus()
                storeCursorPos = self.textCursor()
                self.moveCursor(
                    QtGui.QTextCursor.End,
                    QtGui.QTextCursor.MoveAnchor)
                self.moveCursor(
                    QtGui.QTextCursor.StartOfLine,
                    QtGui.QTextCursor.MoveAnchor)
                self.moveCursor(
                    QtGui.QTextCursor.End,
                    QtGui.QTextCursor.KeepAnchor)
                self.textCursor().removeSelectedText()
                self.textCursor().deletePreviousChar()
                self.setTextCursor(storeCursorPos)
        elif c < 0:
            # add line numbers
            for i in range(-c):
                self.appendPlainText(str(b + i + 1))
1304103
def get_all_commands_hash
      without_categories = {}
      category_command_map.each do |category, commands|
        without_categories.merge!(commands)
      end
      command_map.merge(without_categories)
    end
863036
def reload(self):
        
        r = self.api._req_directory(self.cid)
        self.pid = r['pid']
        self.name = r['name']
        self._count = r['count']
682444
def update(self, prms):
        
        with self.sess.as_default():
            fetches = []
            feeds = {}
            for name, value in six.iteritems(prms):
                assert name in self.name_map
                var = self.name_map[name]
                fetches.append(var.initializer)
                # This is the implementation of `var.load`
                feeds[var.initializer.inputs[1]] = SessionUpdate.relaxed_value_for_var(value, var)
            self.sess.run(fetches, feed_dict=feeds)