Request the autopilot version from the system/component.

                target_system             : System ID (uint8_t)
                target_component          : Component ID (uint8_t)
506564
def autopilot_version_request_send(self, target_system, target_component, force_mavlink1=False):
                '''
                

                '''
                return self.send(self.autopilot_version_request_encode(target_system, target_component), force_mavlink1=force_mavlink1)
840313
def agent_version(self):
        
        version = self.safe_data['agent-status']['version']
        if version:
            return client.Number.from_json(version)
        else:
            return None
633780
def base_version(self):
        """"""
        components = [self.xyz_version]
        if self.ver_extra:
            components.append(self.ver_extra)
        return ''.join(components)
1031235
def get_firmware_version(self, cb=None):
        
        task = asyncio.ensure_future(self.core.get_firmware_version())
        version = self.loop.run_until_complete(task)
        if cb:
            cb(version)
        else:
            return version
896442
def get_version(self):
        """"""
        _, version = misc.get_version(self.confdir)
        if version is None:
            return "Can't get the version."
        else:
            return "cslbot - %s" % version
529283
def gopro_get_request_send(self, target_system, target_component, cmd_id, force_mavlink1=False):
                '''
                

                '''
                return self.send(self.gopro_get_request_encode(target_system, target_component, cmd_id), force_mavlink1=force_mavlink1)
1068866
def get_system_uid():
    
    try:
        if os.name == 'nt':
            return get_nt_system_uid()
        if sys.platform == 'darwin':
            return get_osx_system_uid()
    except Exception:
        return get_mac_uid()
    else:
        return get_mac_uid()
1373364
def get_face_version(self):
        
        command = const.CMD_OPTIONS_RRQ
        command_string = b'ZKFaceVersion\x00'
        response_size = 1024

        cmd_response = self.__send_command(command, command_string, response_size)
        if cmd_response.get('status'):
            response = self.__data.split(b'=', 1)[-1].split(b'\x00')[0]
            return safe_cast(response, int, 0)  if response else 0
        else:
            return None
523419
def _ensure_systemd(version):
    '''
    
    '''
    try:
        version = int(version)
    except ValueError:
        raise CommandExecutionError('Invalid version \'{0}\''.format(version))

    try:
        installed = _sd_version()
        log.debug('nspawn: detected systemd %s', installed)
    except (IndexError, ValueError):
        raise CommandExecutionError('nspawn: Unable to get systemd version')

    if installed < version:
        raise CommandExecutionError(
            'This function requires systemd >= {0} '
            '(Detected version: {1}).'.format(version, installed)
        )
1064398
def version(self):
        

        if self._version != 'auto':
            return self._version

        if self._version == 'auto':
            try:
                data = self.execute_get('configuration/about/')
                self._version = data['configuration'][0]['version']
            except GhostException:
                return self.DEFAULT_VERSION

        return self._version
713836
def get_engine_version(self):
        """"""
        msg = StandardSend(self._address,
                           COMMAND_GET_INSTEON_ENGINE_VERSION_0X0D_0X00)
        self._send_msg(msg)
815535
def _get_sensor(self):
        """"""
        # sometimes Himawari-8 (or 9) data is stored in SCMI format
        is_h8 = 'H8' in self.platform_name
        is_h9 = 'H9' in self.platform_name
        is_ahi = is_h8 or is_h9
        return 'ahi' if is_ahi else 'abi'
1230151
public void setTargetedOperatingSystemVersions(com.google.api.ads.admanager.axis.v201808.Technology[] targetedOperatingSystemVersions) {
        this.targetedOperatingSystemVersions = targetedOperatingSystemVersions;
    }
886382
def get_version_by_version_id(version_id):
    
    for ver in registry.version_info:
        if ver.version_id == version_id:
            return ver.id

    return None
73863
def setup(app):
    """"""
    app.add_domain(EverettDomain)
    app.add_directive('autocomponent', AutoComponentDirective)

    return {
        'version': __version__,
        'parallel_read_safe': True,
        'parallel_write_safe': True
    }
182119
def get_version():
    """"""
    import imp
    import os
    mod = imp.load_source(
        'version', os.path.join('skdata', '__init__.py')
    )
    return mod.__version__
1173743
def version(hostname, timeout=20, username=None, password=None):
    '''
    
    '''
    return __version(__connect(hostname, timeout, username, password))