Get the servers VERSION information.
        Optional arguments:
        * target=None - Server to get the VERSION information of.
508922
def get_version(self, target=None):
        
        with self.lock:
            if not target:
                self.send('VERSION')
            else:
                self.send('VERSION %s' % target)

            while self.readable():
                msg = self._recv(expected_replies=('351', '005'))
                version = msg[2].replace(' :are supported by this server', '')
                version = version.split()
                for info in version:
                        try:
                            info = info.split('=')
                            name = info[0]
                            value = info[1]
                            self.version[name] = value

                            if name == 'CHARSET':
                                self.encoding = value
                        except IndexError:
                            self.version[info[0]] = True

            return self.version
262573
def get_version_text(self):
        """"""
        try:
            version_text = self.device.send('uname -sr', timeout=10)
        except CommandError:
            self.log("Non Unix jumphost type detected")
            return None
            raise ConnectionError("Non Unix jumphost type detected.")
        return version_text
598278
def get_release_info(self, name, version):  # type: (str, str) -> dict
        
        if self._disable_cache:
            return self._get_release_info(name, version)

        cached = self._cache.remember_forever(
            "{}:{}".format(name, version), lambda: self._get_release_info(name, version)
        )

        cache_version = cached.get("_cache_version", "0.0.0")
        if parse_constraint(cache_version) != self.CACHE_VERSION:
            # The cache must be updated
            self._log(
                "The cache for {} {} is outdated. Refreshing.".format(name, version),
                level="debug",
            )
            cached = self._get_release_info(name, version)

            self._cache.forever("{}:{}".format(name, version), cached)

        return cached
728031
private function getServerVersion()
    {
        $connection = $this->getWrappedConnection();

        // Automatic platform version detection.
        if ($connection instanceof ServerInfoAwareConnection && ! $connection->requiresQueryForServerVersion()) {
            return $connection->getServerVersion();
        }

        // Unable to detect platform version.
        return null;
    }
1251981
def get_version(self, state=None, date=None):
        

        version_model = self._meta._version_model
        q = version_model.objects.filter(object_id=self.pk)
        if state:
            q = version_model.normal.filter(object_id=self.pk, state=state)

        if date:
            q = q.filter(date_published__lte=date)

        q = q.order_by('-date_published')

        results = q[:1]
        if results:
            return results[0]
        return None
458172
def version(self, conn):
        

        command = b'version\r\n'
        response = yield from self._execute_simple_command(
            conn, command)
        if not response.startswith(const.VERSION):
            raise ClientException('Memcached version failed', response)
        version, number = response.split()
        return number
1173743
def version(hostname, timeout=20, username=None, password=None):
    '''
    
    '''
    return __version(__connect(hostname, timeout, username, password))
1006632
def server_info(self, session=None):
        
        return self.admin.command("buildinfo",
                                  read_preference=ReadPreference.PRIMARY,
                                  session=session)
652966
def version():
    '''
    
    '''
    ret = _client_wrapper('version')
    version_re = re.compile(VERSION_RE)
    if 'Version' in ret:
        match = version_re.match(six.text_type(ret['Version']))
        if match:
            ret['VersionInfo'] = tuple(
                [int(x) for x in match.group(1).split('.')]
            )
    if 'ApiVersion' in ret:
        match = version_re.match(six.text_type(ret['ApiVersion']))
        if match:
            ret['ApiVersionInfo'] = tuple(
                [int(x) for x in match.group(1).split('.')]
            )
    return ret
891758
def api_version(self):
        
        request_url = "{}/api/0/version".format(self.instance)
        return_value = self._call_api(request_url)
        return return_value['version']
1281906
def version(request):
    
    version_json = import_string(version_callback)(settings.BASE_DIR)
    if version_json is None:
        return HttpResponseNotFound('version.json not found')
    else:
        return JsonResponse(version_json)
1041288
def _get_ignored_version():
    
    if os.path.exists(filepath):
        with open(filepath) as data_file:
            data = json.load(data_file)
            version = data.get('version')
    else:
        version = None
    return version
889928
def get_online_version ():
    """"""
    session = requests.session()
    page = urlopen(UPDATE_URL, session)
    version, url = None, None
    for line in page.text.splitlines():
        if line.startswith(VERSION_TAG):
            version = line.split(':', 1)[1].strip()
        elif line.startswith(URL_TAG):
            url = line.split(':', 1)[1].strip()
            url = url.replace('${version}', version)
    return version, url
1256937
def _get_version_info():
    
    if os.environ.get('VERSIONCHECK_DEBUG', '') != 'true':
        for lname in ['versionfinder', 'pip', 'git']:
            l = logging.getLogger(lname)
            l.setLevel(logging.CRITICAL)
            l.propagate = True
    try:
        vinfo = find_version('awslimitchecker')
        dirty = ''
        if vinfo.git_is_dirty:
            dirty = '*'
        tag = vinfo.git_tag
        if tag is not None:
            tag += dirty
        commit = vinfo.git_commit
        if commit is not None:
            if len(commit) > 7:
                commit = commit[:8]
            commit += dirty
        return AWSLimitCheckerVersion(
            vinfo.version,
            vinfo.url,
            tag=tag,
            commit=commit
        )
    except Exception:
        logger.exception("Error checking installed version; this installation "
                         "may not be in compliance with the AGPLv3 license:")
    # fall back to returning just the hard-coded release information
    return AWSLimitCheckerVersion(_VERSION, _PROJECT_URL)
699308
def get_version(cls):
        
        cmd_pieces = [cls.tool, '--version']
        process = Popen(cmd_pieces, stdout=PIPE, stderr=PIPE)
        out, err = process.communicate()
        if err:
            return ''
        else:
            return out.splitlines()[0].strip()
714919
def get_version(version=None):
    """"""
    if version is None:
        version = VERSION
    assert len(version) == 5
    assert version[3] in ('alpha', 'beta', 'rc', 'final')

    # Now build the two parts of the version number:
    # main = X.Y[.Z]
    # sub = .devN - for pre-alpha releases
    #     | {a|b|c}N - for alpha, beta and rc releases

    parts = 2 if version[2] == 0 else 3
    main = '.'.join(str(x) for x in version[:parts])

    sub = ''
    if version[3] == 'alpha' and version[4] == 0:
        # At the toplevel, this would cause an import loop.
        from django.utils.version import get_svn_revision
        svn_revision = get_svn_revision()[4:]
        if svn_revision != 'unknown':
            sub = '.dev%s' % svn_revision

    elif version[3] != 'final':
        mapping = {'alpha': 'a', 'beta': 'b', 'rc': 'c'}
        sub = mapping[version[3]] + str(version[4])

    return main + sub
1219604
def _get_version_output(self):
        
        if not self.executable:
            return ''
        command = [self.executable, '--version']
        out, _, _ = self._check(self.conn, command)
        try:
            return out.decode('utf-8').split()[2]
        except IndexError:
            return ''