Fetch a ConfigurationInstance

        :param unicode ui_version: Pinned UI version

        :returns: Fetched ConfigurationInstance
        :rtype: twilio.rest.flex_api.v1.configuration.ConfigurationInstance
977136
def fetch(self, ui_version=values.unset):
        
        return self._proxy.fetch(ui_version=ui_version, )
348911
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return IpAddressInstance(
            self._version,
            payload,
            account_sid=self._solution['account_sid'],
            ip_access_control_list_sid=self._solution['ip_access_control_list_sid'],
            sid=self._solution['sid'],
        )
927706
def get_config(cls, key, default=None):
        
        return cls._app.config.get(key, default)
521314
def get_version():
    
    reg = re.compile(r'__version__ = [\'"]([^\'"]*)[\'"]')
    with open('requests_kerberos/__init__.py') as fd:
        matches = list(filter(lambda x: x, map(reg.match, fd)))

    if not matches:
        raise RuntimeError(
            'Could not find the version information for requests_kerberos'
            )

    return matches[0].group(1)
1278157
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return ExecutionInstance(
            self._version,
            payload,
            flow_sid=self._solution['flow_sid'],
            sid=self._solution['sid'],
        )
1254994
def fetch
      VersionsFile.load(read_file(Configuration.versions_file),
                        read_file(Configuration.prerelease_versions_file, true))
    end
941884
def _parse_versioning_config(self, (response, xml_bytes)):
        """"""
        root = XML(xml_bytes)
        mfa_delete = root.findtext("MfaDelete")
        status = root.findtext("Status")

        return VersioningConfiguration(mfa_delete=mfa_delete, status=status)
1309401
def get_app(system_version_file: str = None,
            config_file_override: str = None,
            name_override: str = None,
            loop: asyncio.AbstractEventLoop = None) -> web.Application:
    
    if not system_version_file:
        system_version_file = BR_BUILTIN_VERSION_FILE

    version = get_version(system_version_file)
    name = name_override or name_management.get_name()
    config_obj = config.load(config_file_override)

    LOG.info("Setup: " + '\n\t'.join([
        f'Device name: {name}',
        f'Buildroot version:         '
        f'{version.get("buildroot_version", "unknown")}',
        f'\t(from git sha      '
        f'{version.get("buildroot_sha", "unknown")}',
        f'API version:               '
        f'{version.get("opentrons_api_version", "unknown")}',
        f'\t(from git sha      '
        f'{version.get("opentrons_api_sha", "unknown")}',
        f'Update server version:     '
        f'{version.get("update_server_version", "unknown")}',
        f'\t(from git sha      '
        f'{version.get("update_server_sha", "unknown")}',
        f'Smoothie firmware version: TODO'
    ]))

    if not loop:
        loop = asyncio.get_event_loop()

    app = web.Application(loop=loop, middlewares=[log_error_middleware])
    app[config.CONFIG_VARNAME] = config_obj
    app[constants.RESTART_LOCK_NAME] = asyncio.Lock()
    app[constants.DEVICE_NAME_VARNAME] = name
    app.router.add_routes([
        web.get('/server/update/health',
                control.build_health_endpoint(version)),
        web.post('/server/update/begin', update.begin),
        web.post('/server/update/cancel', update.cancel),
        web.get('/server/update/{session}/status', update.status),
        web.post('/server/update/{session}/file', update.file_upload),
        web.post('/server/update/{session}/commit', update.commit),
        web.post('/server/restart', control.restart),
        web.get('/server/ssh_keys', ssh_key_management.list_keys),
        web.post('/server/ssh_keys', ssh_key_management.add),
        web.delete('/server/ssh_keys/{key_md5}', ssh_key_management.remove),
        web.post('/server/name', name_management.set_name_endpoint),
        web.get('/server/name', name_management.get_name_endpoint),
    ])
    return app
952000
def _get_version(self, root):
        
        # Note: STIX and MAEC use a "version" attribute. To support CybOX, a
        # subclass will need to combine "cybox_major_version",
        # "cybox_minor_version", and "cybox_update_version".
        version = self.get_version(root)
        if version:
            return StrictVersion(version)

        raise UnknownVersionError(
            "Unable to determine the version of the input document. No "
            "version information found on the root element."
        )
538218
def _read_remote_config(self):
        
        try:
            import requests
        except ImportError:
            requests = None
        if not requests:
            raise ValueError(
                'Remote config URL specified but requests not installed')
        result = requests.get(self._file_path)
        if not result.ok:
            raise ValueError(
                'Failed to retrieve remote config: {}'.format(
                    result.status_code))
        return result.text
297850
def api_version(profile=None, **connection_args):
    '''
    
    '''
    kwargs = _get_kwargs(profile=profile, **connection_args)
    auth_url = kwargs.get('auth_url', kwargs.get('endpoint', None))
    try:
        return salt.utils.http.query(auth_url, decode=True, decode_type='json',
                                     verify_ssl=False)['dict']['version']['id']
    except KeyError:
        return None
296979
def _get_version(addon_dir, manifest, odoo_version_override=None,
                 git_post_version=True):
    
    version = manifest.get('version')
    if not version:
        warn("No version in manifest in %s" % addon_dir)
        version = '0.0.0'
    if not odoo_version_override:
        if len(version.split('.')) < 5:
            raise DistutilsSetupError("Version in manifest must have at least "
                                      "5 components and start with "
                                      "the Odoo series number in %s" %
                                      addon_dir)
        odoo_version = '.'.join(version.split('.')[:2])
    else:
        odoo_version = odoo_version_override
    if odoo_version not in ODOO_VERSION_INFO:
        raise DistutilsSetupError("Unsupported odoo version '%s' in %s" %
                                  (odoo_version, addon_dir))
    odoo_version_info = ODOO_VERSION_INFO[odoo_version]
    if git_post_version:
        version = get_git_postversion(addon_dir)
    return version, odoo_version, odoo_version_info
611879
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return ParticipantInstance(
            self._version,
            payload,
            account_sid=self._solution['account_sid'],
            conference_sid=self._solution['conference_sid'],
            call_sid=self._solution['call_sid'],
        )
102199
def config_get(option_name):
    
    try:
        raw = subprocess.check_output(['config-get', option_name, '--format=yaml'])
        return yaml.load(raw.decode('UTF-8'))
    except ValueError:
        return None
567677
def _fetch_option(cfg, ret_config, virtualname, attr_name):
    
    # c_cfg is a dictionary returned from config.option for
    # any options configured for this returner.
    if isinstance(cfg, dict):
        c_cfg = cfg
    else:
        c_cfg = cfg('{0}'.format(virtualname), {})

    default_cfg_key = '{0}.{1}'.format(virtualname, attr_name)
    if not ret_config:
        # Using the default configuration key
        if isinstance(cfg, dict):
            if default_cfg_key in cfg:
                return cfg[default_cfg_key]
            else:
                return c_cfg.get(attr_name)
        else:
            return c_cfg.get(attr_name, cfg(default_cfg_key))

    # Using ret_config to override the default configuration key
    ret_cfg = cfg('{0}.{1}'.format(ret_config, virtualname), {})

    override_default_cfg_key = '{0}.{1}.{2}'.format(
        ret_config,
        virtualname,
        attr_name,
    )
    override_cfg_default = cfg(override_default_cfg_key)

    # Look for the configuration item in the override location
    ret_override_cfg = ret_cfg.get(
        attr_name,
        override_cfg_default
    )
    if ret_override_cfg:
        return ret_override_cfg

    # if not configuration item found, fall back to the default location.
    return c_cfg.get(attr_name, cfg(default_cfg_key))
1020311
async def version(self):
        
        params = {'access_token': self.token}
        url = '/api/version.{ext}'.format(ext=self.format)
        return await self.query(url, "get", **params)
862941
def get_api_connector(cls):
        
        if cls._api is None:  # pragma: no cover
            cls.load_config()
            cls.debug('initialize connection to remote server')
            apihost = cls.get('api.host')
            if not apihost:
                raise MissingConfiguration()

            apienv = cls.get('api.env')
            if apienv and apienv in cls.apienvs:
                apihost = cls.apienvs[apienv]

            cls._api = XMLRPCClient(host=apihost, debug=cls.verbose)

        return cls._api