Position this :any:`Pipette` for an dispense
500461
def _position_for_dispense(self, location=None, clearance=0.5):
        

        if location:
            if isinstance(location, Placeable):
                location = location.bottom(min(location.z_size(), clearance))
            self.move_to(location)
483651
def depipe(s):
    """"""
    n = 0
    for i in reversed(s.split('|')):
        n = n / 60.0 + float(i)
    return n
885613
def pipes_pipe(obj, arr)
      arr.inject(obj) {|acc,e| Boson.full_invoke(e, [acc]) }
    end
776734
def pipe(self, methodname, first_arg, *args, **kwargs):
        

        for plugin in self._plugins:
            method = getattr(plugin, methodname, None)
            if method is None:
                continue
            r = method(first_arg, *args, **kwargs)
            if r is not None:
                first_arg = r
        return r
1355108
def _pipe(self):
        """"""
        if self._evdev:
            return None

        if not self.__pipe:
            target_function = self._get_target_function()
            if not target_function:
                return None

            self.__pipe, child_conn = Pipe(duplex=False)
            self._listener = Process(target=target_function,
                                     args=(child_conn,), daemon=True)
            self._listener.start()
        return self.__pipe
608064
def header(self, item0, *items):
        
        self.txt(item0)
        at_x = None
        for item in items:
            if at_x is None:
                at_x = item
            else:
                self.txt(item, at_x=at_x)
                at_x = None
1103551
function PRVTcheckTextDirective( &$text, $i, &$f, $final = 0 )
    {
        $x = 0;
        $y = 0;
        return $this->PRVTcheckTextDirective1( $text, $i, $f, $final, $x, $y );
    }
849653
private void positionDirect(long p) throws IOException {
        long newBlockStart = p / buffer.length * buffer.length;
        input.position(newBlockStart);
        buffer();
        offset = (int)(p % buffer.length);        
    }
773109
public void attachPipe(Pipe pipe)
    {
        assert (!isTerminating());
        assert (this.pipe == null);
        assert (pipe != null);
        this.pipe = pipe;
        this.pipe.setEventSink(this);
    }
1077019
function positionRoot(wt) {
    wt.prelim = ( wt.children[0].prelim + 
                  wt.children[0].mod -
                  wt.children[0].x_size/2 +
                  wt.children[wt.num_children - 1].mod + 
                  wt.children[wt.num_children - 1].prelim +
                  wt.children[wt.num_children - 1].x_size/2) / 2;
  }
1049613
function _pipe(method, args, done) {

  let proc;
  let isProc =
    typeof method === 'object' &&
    (method.constructor && method.constructor.name === 'ChildProcess');

  done = done || function () {};

  if (typeof args === 'function') {
    done = args;
    args = undefined;
  }

  // Ensure args array.
  args = args || [];

  // Allow passing args as a string.
  // supports either ' ' or ', '.
  if (typeof args === 'string') {
    let splitChar = ~args.indexOf(',') ? ',' : ' ';
    if (splitChar === ',')
      args = args.replace(/\s/g, '');
    args = args.split(splitChar);
  }

  // If string assume command set method to spawn.
  if (typeof method === 'string') {
    args = [method, args];
    method = spawn;
  }

  if (isProc)
    proc = method;

  if (!proc)
    proc = method(...args);

  const thru = thruHandler(done);

  proc.stdin = proc.stdin || process.stdin;
  proc.stdout = proc.stdout || process.stdout;
  proc.stderr = proc.stderr || process.stderr;

  proc.stdout.pipe(thru);

  return proc;

}
630912
function Position(file, line, column) {
  this.file = file;
  this.line = line || 1;
  this.column = column || 0;
}
649765
function positionHint(xpos, ypos, ybot) {
        var hintWidth = $hintContainer.width(),
            hintHeight = $hintContainer.height(),
            top = ypos - hintHeight - POINTER_TOP_OFFSET,
            left = xpos,
            $editorHolder = $("#editor-holder"),
            editorLeft;

        if ($editorHolder.offset() === undefined) {
            // this happens in jasmine tests that run
            // without a windowed document.
            return;
        }

        editorLeft = $editorHolder.offset().left;
        left = Math.max(left, editorLeft);
        left = Math.min(left, editorLeft + $editorHolder.width() - hintWidth);

        if (top < 0) {
            $hintContainer.removeClass("preview-bubble-above");
            $hintContainer.addClass("preview-bubble-below");
            top = ybot + POSITION_BELOW_OFFSET;
            $hintContainer.offset({
                left: left,
                top: top
            });
        } else {
            $hintContainer.removeClass("preview-bubble-below");
            $hintContainer.addClass("preview-bubble-above");
            $hintContainer.offset({
                left: left,
                top: top - POINTER_TOP_OFFSET
            });
        }
    }
36073
def first(pipe, items=1):
    ''' 
    '''
    pipe = iter(pipe)
    return next(pipe) if items == 1 else islice(pipe, 0, items)
1236235
def position_before(self, instr):
        
        self._block = instr.parent
        self._anchor = self._block.instructions.index(instr)
1265264
function pipeP(...fns) {
  if(!arguments.length) {
    throw new TypeError(err)
  }

  const head =
    fns[0]

  if(!isFunction(head)) {
    throw new TypeError(err)
  }

  const tail =
    fns.slice(1).concat(x => x)

  return tail.reduce(applyPipe, head)
}
843537
function inboundPayload( storedPipe, pipe ){
	if ( storedPipe && storedPipe.hasOwnProperty( "tables" ) ){
		pipe.tables = storedPipe.tables;
	}
	
	if ( !pipe.hasOwnProperty("sf") ){
		if ( storedPipe && storedPipe.hasOwnProperty( "sf" ) ){
			pipe.sf = storedPipe.sf;
		}
	}
	return pipe;
}