Copy or coerce to a Host.
180266
def to_host(self):
        """"""
        return Host(self.address,
                    alias=self.alias,
                    user=self.user,
                    keyfile=self.keyfile,
                    port=self.port,
                    extra=self.extra)
1332977
def _expand_host(self, host):
        
        if isinstance(host, basestring):
            return (host, self.default_port)
        return tuple(host)
419800
def copy(self):
        """"""
        other = Version(None)
        other.tokens = self.tokens[:]
        other.seps = self.seps[:]
        return other
80929
function copyAsUser($from, $to)
    {
        copy($from, $to);

        $this->chown($to, user());
    }
139339
def copy(self, key=None):
        
        other = self.__class__(
            redis=self.redis, key=key, writeback=self.writeback
        )
        other.extend(self)

        return other
1265146
def copy(self, name=None, prefix=None):
        """"""
        setting = self.__class__.__new__(self.__class__)
        setting.__dict__.update(self.__dict__)
        # Keep the modified flag?
        # setting.modified = False
        if prefix and not setting.is_global:
            flags = setting.flags
            # Prefix a setting
            setting.orig_name = setting.name
            setting.name = '%s_%s' % (prefix, setting.name)
            if flags and flags[-1].startswith('--'):
                setting.flags = ['--%s-%s' % (prefix, flags[-1][2:])]
        if name and not setting.is_global:
            setting.short = '%s application. %s' % (name, setting.short)
        return setting
176913
def on(hosts, options={}, &block)
      subset_copy = Marshal.dump(Configuration.env.filter(hosts))
      SSHKit::Coordinator.new(Marshal.load(subset_copy)).each(options, &block)
    end
714749
def chput(local_path=None, remote_path=None, user=None, group=None,
          mode=None, use_sudo=True, mirror_local_mode=False, check=True):
    """"""
    # pylint: disable=R0913
    result = None
    if env.get('full') or not check or diff(local_path, remote_path):
        result = put(local_path, remote_path, use_sudo,
                     mirror_local_mode, mode)
    with hide('commands'):
        chown(remote_path, user, group)
    return result
972494
def _do(name, fun, path=None):
    '''
    
    '''
    host = find_guest(name, quiet=True, path=path)
    if not host:
        return False

    client = salt.client.get_local_client(__opts__['conf_file'])
    cmd_ret = client.cmd_iter(
            host,
            'lxc.{0}'.format(fun),
            [name],
            kwarg={'path': path},
            timeout=60)
    data = next(cmd_ret)
    data = data.get(host, {}).get('ret', None)
    if data:
        data = {host: data}
    return data
959714
function clonePureArray (subject, host) {
  var i = subject.length
  var start = host.length

  while (i --) {
    host[start + i] = subject[i]
  }

  return host
}
699598
def copy(self, src_url, dst_url):
        """"""
        src_bucket, src_key = _parse_url(src_url)
        dst_bucket, dst_key = _parse_url(dst_url)

        if not dst_bucket:
            dst_bucket = src_bucket
        params = {
            'copy_source': '/'.join((src_bucket, src_key)),
            'bucket': dst_bucket,
            'key': dst_key,
        }
        return self.call("CopyObject", **params)
1188362
def dcc_get(self, mask, host, port, filepath, filesize=None):
        """"""
        return self.dcc.create(
            'get', mask, filepath=filepath, filesize=filesize,
            host=host, port=port).ready
894521
def slaveof(self, host=None, port=None):
        
        if host is None and port is None:
            return self.execute_command('SLAVEOF', Token.get_token('NO'),
                                        Token.get_token('ONE'))
        return self.execute_command('SLAVEOF', host, port)
705739
async def slaveof(self, host=None, port=None):
        
        if host is None and port is None:
            return await self.execute_command('SLAVEOF', b('NO'), b('ONE'))
        return await self.execute_command('SLAVEOF', host, port)
1278233
function clone(conf) {
  if (typeof conf !== 'object') return conf;
  var obj = {};
  for (var key in conf) {
    obj[key] = clone(conf[key]);
  }
  return obj;
}
500279
def copy(path, options = {}, &block)
      perform_request Net::HTTP::Copy, path, options, &block
    end
385472
def copy(self, key=None):
        
        other = self.__class__(
            self.__iter__(),
            self.maxlen,
            redis=self.redis,
            key=key,
            writeback=self.writeback,
        )

        return other