Sets self.input to inputs. Load order is by default random. Use setOrderedInputs() to order inputs.
2305
def setInputs(self, inputs):
        
        if not self.verifyArguments(inputs) and not self.patterned:
            raise NetworkError('setInputs() requires [[...],[...],...] or [{"layerName": [...]}, ...].', inputs)
        self.inputs = inputs
        self.loadOrder = [0] * len(self.inputs)
        for i in range(len(self.inputs)):
            self.loadOrder[i] = i
168987
def set(self, values):
        
        if hasattr(self, "inputs"):
            for item in self.inputs:
                if hasattr(self, item):
                    setattr(self, item, values[item])
345409
def send_inputs_patch(sequence)
      if has_default_thread?
        begin
          cmd = { :name => :set_inputs_patch, :patch => sequence.inputs_patch }
          @client.send_command(cmd)
        rescue Exception => e
          fail('Failed to update inputs', Log.format("Failed to apply inputs patch after execution", e, :trace))
        end
      end
      true
    ensure
      stop
    end
648117
def set_input_type(self, type_or_parse):
        
        self._inputs = OrderedDict()
        default_inputs = self.engine.in_name
        if len(default_inputs) > 1:
            raise ValueError("Need more than one input, you sould use `add_input` for each of them")
        self.add_input(default_inputs[0], type_or_parse)
1327832
public void setInput(final String input)
		throws DecodingException
	{

		boolean zipFlag = input.charAt(0) == '_';
		if (zipFlag) {
			r = new BitReader(inflateInput(
					Base64.decodeBase64(input.substring(1)), 0));
		}
		else {
			byte[] data = Base64.decodeBase64(input);
			if (data == null) {

				for (int i = 0; i < input.length(); i++) {
					System.err.println(i + ": " + (int) input.charAt(i)
							+ " <> " + input.charAt(i));
				}

				throw new DecodingException("BASE 64 DECODING FAILED: " + input);
			}
			r = new BitReader(data);
		}
	}
733149
def _set_input(el, value):
        
        if isinstance(value, dict):
            el.value = value["val"]
        elif type(value) in [list, tuple]:
            el.value = ", ".join(item["val"] for item in value)
        else:
            el.value = value
71002
public void setInput( I input ) {
		this.inputImage = input;

		// reset the state flag so that everything need sto be computed
		if( stale != null ) {
			for( int i = 0; i < stale.length; i++) {
				boolean a[] = stale[i];
				for( int j = 0; j < a.length; j++ ) {
					a[j] = true;
				}
			}
		}
	}
1227769
protected function setSort()
    {
        $this->sort = Input::get($this->sortName, []);
        if (!is_array($this->sort)) {
            return;
        }

        if (empty($this->sort['column']) || empty($this->sort['type'])) {
            return;
        }

        if (str_contains($this->sort['column'], '.')) {
            $this->setRelationSort($this->sort['column']);
        } else {
            $this->resetOrderBy();

            $this->queries->push([
                'method' => 'orderBy',
                'arguments' => [$this->sort['column'], $this->sort['type']],
            ]);
        }
    }
801501
public function setPutFromRequest()
    {
        if ($this->_put === null) {
            if ($_SERVER['REQUEST_METHOD'] == 'PUT') {
                $this->_put = file_get_contents("php://input");
            }
        } else {
            $this->_put = '';
        }
    }
1247435
@Deprecated
	public void setFirstInputs(List<Operator<IN1>> inputs) {
		this.input1 = Operator.createUnionCascade(inputs);
	}
228477
@Deprecated
	@SuppressWarnings("unchecked")
	public void addInput(List<Operator<IN>> inputs) {
		this.input = Operator.createUnionCascade(this.input, inputs.toArray(new Operator[inputs.size()]));
	}
970547
public void setInputs(Collection<String> inputs) {
    List<String> newInputs = new ArrayList<String>();
    if (inputs != null) {
      newInputs.addAll(inputs);
    }
    this.inputs = newInputs;
  }
440871
@SuppressWarnings("unchecked")
	@Deprecated
	public void addInputs(List<? extends Operator<IN>> inputs) {
		Preconditions.checkNotNull(inputs, "The inputs may not be null.");
		this.input = createUnionCascade(this.input, (Operator<IN>[]) inputs.toArray(new Operator[inputs.size()]));
	}
934798
def set_append(input_set, item):
    # type: (set, Any) -> set
    
    if item:
        if isinstance(item, (list, tuple)):
            input_set.update(item)
        else:
            input_set.add(item)
    return input_set
1265029
function init(input) {
  // Use provided pool
  if(typeof input == 'function') db.pool = input;

  else {
    // Create the pool with any options merged with the below defaults
    db.pool = mysql.createPool(Object.assign({
      user: 'root',
      password: 'root',
      database: 'test'
    },input));
  }

  // Set the local _pool(just for convenience)
  _pool = db.pool;

  return db;
}
1237415
@Deprecated
	public void setInput(Operator<IN>... input) {
		this.input = Operator.createUnionCascade(null, input);
	}
943962
def format_result(input):
        
        items = list(iteritems(input))
        return OrderedDict(sorted(items, key=lambda x: x[0]))