def before_scenario(context, step): context.account_ids = {} context.player_ids = {} config = { 'also_return_response': True, 'validate_responses': True, 'validate_requests': True, 'validate_swagger_spec': True, 'use_models': True, 'formats': [] } env = context.config.userdata.get('env') context.env_urls = get_environment_variables(env) context.clients = Dict() context.clients.game_service = SwaggerClient.from_spec( load_file('specs/dukedoms_game_service_api.yaml', ), origin_url=context.env_urls.game_service, config=config) context.clients.account_service = SwaggerClient.from_spec( load_file('specs/dukedoms_account_service_api.yaml', ), origin_url=context.env_urls.account_service, config=config)
def bitmex(test=True, config=None, api_key=None, api_secret=None): # config options at http://bravado.readthedocs.io/en/latest/configuration.html if not config: config = { # Don't use models (Python classes) instead of dicts for #/definitions/{models} 'use_models': False, # bravado has some issues with nullable fields 'validate_responses': False, # Returns response in 2-tuple of (body, response); if False, will only return body 'also_return_response': True, # 'validate_swagger_spec': True, # 'validate_requests': True, # 'formats': [], } host = 'https://www.bitmex.com' if test: host = 'https://testnet.bitmex.com' spec_uri = host + '/api/explorer/swagger.json' spec_dict = get_swagger_json(spec_uri, exclude_formats=EXCLUDE_SWG_FORMATS) if api_key and api_secret: request_client = RequestsClient() request_client.authenticator = APIKeyAuthenticator(host, api_key, api_secret) return SwaggerClient.from_spec(spec_dict, origin_url=spec_uri, http_client=request_client, config=config) else: return SwaggerClient.from_spec(spec_dict, origin_url=spec_uri, http_client=None, config=config)
def get_client(token=None): if token == None: return SwaggerClient.from_spec(load_file(swagger_json_file)) # Set up client http_client = RequestsClient() return SwaggerClient.from_spec(load_file(swagger_json_file), http_client=http_client)
def test_also_return_response(mock_spec): with mock.patch('bravado.client.SwaggerClient.__init__') as mock_init: mock_init.return_value = None SwaggerClient.from_spec({}, config={'also_return_response': True}) mock_init.assert_called_once_with( mock_spec.from_dict.return_value, also_return_response=True, )
def test_dereferenced_swagger_schema_bravado_client( schema_format, test_app_deref, ): from bravado.client import SwaggerClient response = test_app_deref.get('/swagger.{0}'.format(schema_format)) deserializer = DESERIALIZERS[schema_format] specs = deserializer(response) SwaggerClient.from_spec(specs)
def get_paasta_api_client( cluster: str = None, system_paasta_config: SystemPaastaConfig = None, http_res: bool = False, ) -> Any: if not system_paasta_config: system_paasta_config = load_system_paasta_config() if not cluster: cluster = system_paasta_config.get_cluster() api_endpoints = system_paasta_config.get_api_endpoints() if cluster not in api_endpoints: log.error("Cluster %s not in paasta-api endpoints config", cluster) return None url = str(api_endpoints[cluster]) parsed = urlparse(url) if not parsed: log.error("Unsupported paasta-api url %s", url) return None api_server = parsed.netloc # Get swagger spec from file system instead of the api server paasta_api_path = os.path.dirname(paasta_tools.api.__file__) swagger_file = os.path.join(paasta_api_path, "api_docs/swagger.json") if not os.path.isfile(swagger_file): log.error("paasta-api swagger spec %s does not exist", swagger_file) return None with open(swagger_file) as f: spec_dict = json.load(f) # replace localhost in swagger.json with actual api server spec_dict["host"] = api_server spec_dict["schemes"] = [parsed.scheme] # sometimes we want the status code requests_client = PaastaRequestsClient( scheme=parsed.scheme, cluster=cluster, system_paasta_config=system_paasta_config) if http_res: config = {"also_return_response": True} c = SwaggerClient.from_spec(spec_dict=spec_dict, config=config, http_client=requests_client) else: c = SwaggerClient.from_spec(spec_dict=spec_dict, http_client=requests_client) return paasta_tools.api.auth_decorator.AuthClientDecorator( c, cluster_name=cluster)
def test_remove_bravado_configs(mock_spec, processed_default_config): config = CONFIG_DEFAULTS.copy() config['validate_swagger_spec'] = False # bravado_core config SwaggerClient.from_spec({}, config=config) mock_spec.from_dict.assert_called_once_with( {}, # spec_dict None, # spec_url mock.ANY, # http_client { 'bravado': processed_default_config, 'validate_swagger_spec': False, }, # config )
def load_spec_from_spec_dict(spec_dict): # type: (typing.Mapping[typing.Text, typing.Any]) -> Spec return SwaggerClient.from_spec(spec_dict, origin_url='', config={ 'internally_dereference_refs': True }).swagger_spec
def load_client(apikey=None, headers=None, host=HOST): global client force = False if client is not None: http_client = client.swagger_spec.http_client force = bool(headers is not None and http_client.headers != headers) if force or client is None: # - Kong forwards consumer headers when api-key used for auth # - forward consumer headers when connecting through localhost headers = {"x-api-key": apikey} if apikey else headers http_client = FidoClientGlobalHeaders(headers=headers) loader = Loader(http_client) protocol = "https" if apikey else "http" spec_url = f"{protocol}://{host}/apispec.json" spec_dict = loader.load_spec(spec_url) spec_dict["host"] = host spec_dict["schemes"] = [protocol] client = SwaggerClient.from_spec( spec_dict, spec_url, http_client, { "validate_responses": False, "use_models": False, "include_missing_properties": False, "formats": [email_format], }, ) return client
def before_scenario(context, step): config = { 'also_return_response': True, 'validate_responses': True, 'validate_requests': True, 'validate_swagger_spec': True, 'use_models': True, 'formats': [] } context.env_urls = Dict() context.env_urls.card_service = 'http://127.0.0.1:5005' context.env_urls.card_service_db = ( 'postgresql+psycopg2://postgres:[email protected]:5432/card_service' ) context.clients = Dict() context.clients.card_service = SwaggerClient.from_spec( load_file( 'specs/dukedoms_card_service_api.yaml', ), origin_url=context.env_urls.card_service, config=config )
def load_wes_client(service_id, http_client=None, client_library=None): """ Return an API client for the selected workflow execution service. """ if http_client is None: http_client = _init_http_client(service_id=service_id) if client_library is not None: from wes_client.util import WESClient wes_client = WESClient(service=_get_wes_opts(service_id)) return WESAdapter(wes_client) spec_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'workflow_execution_service.swagger.yaml') spec_path = os.path.abspath(spec_path) opts = _get_wes_opts(service_id) api_url = '{}://{}'.format(opts['proto'], opts['host']) loader = Loader(http_client, request_headers=None) spec_dict = loader.load_spec('file:///{}'.format(spec_path), base_url=api_url) spec_client = SwaggerClient.from_spec(spec_dict, origin_url=api_url, http_client=http_client, config={'use_models': False}) return spec_client.WorkflowExecutionService
def get_swagger_client(): """Shortcut function to init swagger client. Takes file path from django setting and initialize swagger client with custom DjangoClient """ path = settings.TEST_SWAGGER_SPEC_FILE # check is path URL or path to local file if os.path.exists(path): conf_loader = load_file else: conf_loader = load_url try: swagger_data = conf_loader(path) except Exception: msg = 'Cannot load swagger file from "{}"'.format(path) raise AssertionError(msg) from None config = { 'also_return_response': True, } return SwaggerClient.from_spec( swagger_data, config=config, http_client=DjangoClient(), )
def loop_handler(request): spec_dict = { "swagger": "2.0", "info": { "version": "0.1", "title": "Hawkular APM zipkin pyramid API" }, "host": "127.0.0.1:" + str(PORT), "schemes": ["http"], "basePath": "/" + BASE_PATH, "tags": [{ "name": "hello" }], "paths": { "/hello": { "get": { "tags": ["hello"], "operationId": "get", "responses": { "200": { "description": "OK" }, } } } } } client = SwaggerClient.from_spec(spec_dict=spec_dict) zipkin_wrapped_client = ZipkinClientDecorator(client) zipkin_wrapped_client.hello.get().result() return Response('loop -> hello')
def get_paasta_api_client(cluster=None, system_paasta_config=None): if not system_paasta_config: system_paasta_config = load_system_paasta_config() if not cluster: cluster = system_paasta_config.get_cluster() api_endpoints = system_paasta_config.get_api_endpoints() if cluster not in api_endpoints: log.error('Cluster %s not in paasta-api endpoints config', cluster) return None url = str(api_endpoints[cluster]) parsed = urlparse(url) if not parsed: log.error('Unsupported paasta-api url %s', url) return None api_server = parsed.netloc # Get swagger spec from file system instead of the api server paasta_api_path = os.path.dirname(sys.modules['paasta_tools.api'].__file__) swagger_file = os.path.join(paasta_api_path, 'api_docs/swagger.json') if not os.path.isfile(swagger_file): log.error('paasta-api swagger spec %s does not exist', swagger_file) return None with open(swagger_file) as f: spec_dict = json.load(f) # replace localhost in swagger.json with actual api server spec_dict['host'] = api_server return SwaggerClient.from_spec(spec_dict=spec_dict)
def from_spec(cls, spec_dict, origin_url=None, http_client=None, privkey=None, **kwargs): """ Build a :class:`SwaggerClient` from swagger api docs :param spec_dict: a dict with a Swagger spec in json-like form :param origin_url: the url used to retrieve the spec_dict :type origin_url: str :param http_client: an HTTP client used to perform requests :type http_client: :class:`bravado.http_client.HttpClient` :param str privkey: The WIF private key to use for bitjws signing """ if privkey is None: privkey = bitjws.PrivateKey() elif isinstance(privkey, str): privkey = bitjws.PrivateKey(bitjws.wif_to_privkey(privkey)) if http_client is None: host = urlparse.urlsplit(origin_url).hostname http_client = BitJWSRequestsClient() private_key = bitjws.privkey_to_wif(privkey.private_key) http_client.set_bitjws_key(host, private_key) return SwaggerClient.from_spec(spec_dict, http_client=http_client, **kwargs)
def __init__(self, swagger_spec: Spec): """ :param swagger_spec: Complete swagger specification for the API to test. """ self.host = "localhost" self.swagger_spec = swagger_spec self.base_path = swagger_spec.client_spec_dict.get("basePath", "") self.swagger_spec.spec_dict['host'] = f'{self.host}:{TEST_PORT}' # setting validate requests to false since we only care about # responses config = { "also_return_response": True, "use_models": False, "validate_requests": False, "formats": swagger_spec.config.get("formats", []) } self.config = config # Bravado provides an async client, but it doesnt run on ioloop? from docs: # Fido is a simple, asynchronous HTTP client built on top of Crochet and Twisted with an implementation # inspired by the book "Twisted Network Programming Essentials". It is intended to be used in environments # where there is no event loop, and where you cannot afford to spin up lots of threads (otherwise you # could just use a ThreadPoolExecutor). self.swagger_client = SwaggerClient.from_spec( self.swagger_spec.spec_dict, http_client=RequestsClient(), config=config)
def __init__(self, server_url): """Create a OpenAPI client for REANA Server.""" json_spec = self._get_spec('reana_server.json') self._client = SwaggerClient.from_spec( json_spec, config={'also_return_response': True}) self._client.swagger_spec.api_url = server_url self.server_url = server_url
def setup_client( url: str, schema: Optional[Dict[str, Any]] = None, ) -> Optional[str]: """ :returns: error message, if appropriate. """ if get_abstraction().client: return None try: config = {'internally_dereference_refs': True} if not schema: client = SwaggerClient.from_url(url, config=config) else: client = SwaggerClient.from_spec(schema, origin_url=url, config=config) except requests.exceptions.ConnectionError: return 'Unable to connect to server.' except ( simplejson.errors.JSONDecodeError, # type: ignore yaml.YAMLError, HTTPError, ): return ('Invalid swagger file. Please check to make sure the ' 'swagger file can be found at: {}.'.format(url)) except SwaggerValidationError: return 'Invalid swagger format.' get_abstraction().client = client return None
def get_api_client(config, validation=False): if config.has_key('client'): return config['client'] url = "https://%s/api/v1/spec/openapi/nsx_api.json" % config['nsxManager'][ 'ip'] base64string = base64.encodestring( ('%s:%s' % (config['nsxManager']['username'], config['nsxManager']['password'])).encode("utf-8"))[:-1] headers = {"Authorization": "Basic %s" % base64string.decode("utf-8")} context = ssl.create_default_context() context.check_hostname = False context.verify_mode = ssl.CERT_NONE req = urllib2.Request(url=url, headers=headers) response = urllib2.urlopen(req, context=context) raw_spec = json.loads(response.read()) raw_spec['host'] = config['nsxManager']['ip'] http_client = RequestsClient() http_client.session.verify = False http_client.set_basic_auth(config['nsxManager']['ip'], config['nsxManager']['username'], config['nsxManager']['password']) config = { 'also_return_response': True, 'validate_swagger_spec': validation, 'validate_responses': False, 'validate_requests': False, 'use_models': False } client = SwaggerClient.from_spec(raw_spec, http_client=http_client, config=config) config['client'] = client return client
def __init__(self, service, http_client=None): """Create an OpenAPI client.""" server_url, spec_file = OPENAPI_SPECS[service] json_spec = self._get_spec(spec_file) current_instance = BaseAPIClient._bravado_client_instance # We reinstantiate the bravado client instance if # 1. The current instance doesn't exist, or # 2. We're passing an http client (likely a mock), or # 3. The current instance is a Mock, meaning that either we want to # use the `RequestClient` or we're passing a different mock. if ( current_instance is None or http_client or isinstance(current_instance.swagger_spec.http_client, Mock) ): BaseAPIClient._bravado_client_instance = SwaggerClient.from_spec( json_spec, http_client=http_client or RequestsClient(ssl_verify=False), config={"also_return_response": True}, ) self._load_config_from_env() self._client = BaseAPIClient._bravado_client_instance if server_url is None: raise MissingAPIClientConfiguration( "Configuration to connect to {} is missing.".format(service) ) self._client.swagger_spec.api_url = server_url self.server_url = server_url
def __init__(self): self.client = SwaggerClient.from_spec(fiware_nsgiv2_openapi_spec) self.options = {'headers': {}} self.id = '' self.type = '' self.temperature = '' self.pressure = ''
def setup_swagger(self): self.http_client = RequestsClient() self.http_client.session.verify = False self.client = SwaggerClient.from_spec(load_file(self.spec), config=self.config, http_client=self.http_client) self.client.swagger_spec.api_url = self.api_url
def setup_swagger(self): self.http_client = RequestsClient() self.http_client.session.verify = False spec = pytest.config.getoption(self.spec_option) self.client = SwaggerClient.from_spec(load_file(spec), config=self.config, http_client=self.http_client) self.client.swagger_spec.api_url = self.make_api_url()
def setup(self): self.http_client = RequestsClient() self.http_client.session.verify = False self.client = SwaggerClient.from_spec(load_file('management_api.yml'), config=self.config, http_client=self.http_client) self.client.swagger_spec.api_url = "http://%s/api/%s/" % ( pytest.config.getoption("host"), pytest.config.getoption("api"))
def test_headers(self): self.uut = SwaggerClient.from_spec(self.resource_listing) httpretty.register_uri( httpretty.GET, "http://swagger.py/swagger-test/pet", body='[]') self.uut.pet.listPets( _request_options={'headers': {'foo': 'bar'}}).result() self.assertEqual('bar', httpretty.last_request().headers['foo'])
def get_client(url): with open( os.getenv("SWAGGER_SCHEMA", os.path.join(os.path.dirname(__file__), "swagger.yml"))) as f: spec = yaml.load(f) client = SwaggerClient.from_spec(spec) client.swagger_spec.api_url = url return client
def __init__(self, url=None, config=DEFAULT_CONFIG, http_client=None, request_headers=None, local=False): """ Instantiates :class:`~bravado.client.SwaggerClient`. For further documentation, refer to the documentation for :meth:`bravado.client.SwaggerClient.from_url` and :meth:`bravado.client.SwaggerClient.from_spec`. :param str url: the URL of a Swagger specification. If ``local`` is True, this should be the base URL of a DOS implementation (see ``local``). :param dict config: see :meth:`bravado.client.SwaggerClient` :param http_client: see :meth:`bravado.client.SwaggerClient` :param request_headers: see :meth:`beravado.client.SwaggerClient` :param bool local: set this to True to load the local schema. If this is True, the ``url`` parameter should point to the host and base path of the implementation under test:: Client(url='https://example.com/ga4gh/dos/v1/', local=True) If False, the ``url`` parameter should point to a Swagger specification (``swagger.json``). """ self._config = config config['formats'] = [int64_format] if local: # :meth:`bravado.client.SwaggerClient.from_spec` takes a schema # as a Python dictionary, which we can conveniently expose # via :func:`ga4gh.dos.schema.present_schema`. schema = ga4gh.dos.schema.present_schema() # Set schema['host'] and schema['basePath'] to the provided # values if specified, otherwise leave them as they are url = urlparse.urlparse(url) schema['host'] = url.netloc or schema['host'] schema['basePath'] = url.path or schema['basePath'] self.models = SwaggerClient.from_spec(spec_dict=schema, config=config, http_client=http_client) else: # If ``local=False``, ``url`` is expected to be a ``swagger.json`` swagger_path = '{}/swagger.json'.format(url.rstrip("/")) self.models = SwaggerClient.from_url( swagger_path, config=config, http_client=http_client, request_headers=request_headers) self.client = self.models.DataObjectService
def before_scenario(context, step): config = { 'also_return_response': True, 'validate_responses': True, 'validate_requests': True, 'validate_swagger_spec': True, 'use_models': True, 'formats': [] } context.urls = get_env_urls(context.config.userdata.get('env')) context.clients = Dict() context.clients.action_broker = SwaggerClient.from_spec( load_file( 'swagger/action_broker_api.yaml', ), origin_url=context.urls.action_broker, config=config ) context.clients.card_broker = SwaggerClient.from_spec( load_file( 'swagger/card_broker_api.yaml', ), origin_url=context.urls.card_broker, config=config ) context.clients.card_service = SwaggerClient.from_spec( load_file( 'swagger/card_service_api.yaml', ), origin_url=context.urls.card_service, config=config ) context.clients.player_service = SwaggerClient.from_spec( load_file( 'swagger/player_service_api.yaml', ), origin_url=context.urls.player_service, config=config )
def create_openapi_client(component): """Create a OpenAPI client for a given spec.""" try: address, spec_file = COMPONENTS_DATA[component] json_spec = get_spec(spec_file) client = SwaggerClient.from_spec(json_spec, config={'also_return_response': True}) client.swagger_spec.api_url = address return client except KeyError: raise Exception('Unkown component {}'.format(component))
def get_client_from_spec(self, origin_url, spec_dict): """It fetches teh swagger clint object from dict() :param origin_url: the url used to retrieve the resource schema :param spec_dict: holds the swagger dict :return: swagger client object """ spec = SwaggerClient.from_spec(spec_dict, origin_url, config={'also_return_response': True}) return spec
def setup(self): self.log = logging.getLogger("client.Client") self.api_url = API_URL self.http_client = RequestsClient() self.http_client.session.verify = False spec = pytest.config.getoption("spec") self.client = SwaggerClient.from_spec(load_file(spec), config=self.config, http_client=self.http_client) self.client.swagger_spec.api_url = self.api_url
def setup_swagger(self): self.http_client = RequestsClient() self.http_client.session.verify = False spec = pytest.config.getoption(self.spec_option) self.client = SwaggerClient.from_spec(load_file(spec), config=self.config, http_client=self.http_client) self.client.swagger_spec.api_url = "http://{}/api/{}/".format(pytest.config.getoption("host"), pytest.config.getoption("api"))
def load_client(apikey=None): host = 'api.mpcontribs.org' if apikey else 'localhost:5000' protocol = 'https' if apikey else 'http' spec_url = f'{protocol}://{host}/apispec.json' http_client = RequestsClient() if apikey: http_client.set_api_key( host, apikey, param_in='header', param_name='x-api-key' ) loader = Loader(http_client) spec_dict = loader.load_spec(spec_url) spec_dict['host'] = host spec_dict['schemes'] = [protocol] return SwaggerClient.from_spec(spec_dict, spec_url, http_client, {'validate_responses': False})
def loop_handler(request): spec_dict = { "swagger": "2.0", "info": { "version": "0.1", "title": "Hawkular APM zipkin pyramid API" }, "host": "127.0.0.1:" + str(PORT), "schemes": [ "http" ], "basePath": "/" + BASE_PATH, "tags": [ { "name": "hello" } ], "paths": { "/hello": { "get": { "tags": [ "hello" ], "operationId": "get", "responses": { "200": { "description": "OK" }, } } } } } client = SwaggerClient.from_spec(spec_dict=spec_dict) zipkin_wrapped_client = ZipkinClientDecorator(client) zipkin_wrapped_client.hello.get().result() return Response('loop -> hello')
def client_tags_with_spaces(): return SwaggerClient.from_spec({ 'swagger': '2.0', 'info': { 'version': '', 'title': 'API' }, 'paths': { '/ping': { 'get': { 'operationId': 'ping', 'responses': { '200': { 'description': 'ping' } }, 'tags': [ 'my tag' ] } } } })
def das_client(das, swagger_spec): return SwaggerClient.from_spec(swagger_spec, origin_url=das.url)
from bravado.requests_client import RequestsClient import json # appneta login credentials email = '*****@*****.**' password = '******' # appneta PVC shard instance instance = 'demo' instance_host = '%s.pathviewcloud.com' % (instance,) http_client = RequestsClient() http_client.set_basic_auth(instance_host, email, password) with open('swagger.json') as f: spec = json.load(f) client = SwaggerClient.from_spec(spec, 'https://%s' % (instance_host,), http_client=http_client) # per https://demo.pathviewcloud.com/pvc-data/swagger/ print client.organization.all().result() # note that some client generators can access the .json file directly from a URL # however, bravado (and perhaps others) enforce presence of info=>title attribute, # which is not present in AppNeta-hosted swagger.json and has been added to the # version in this respository #swagger_spec_url = 'https://%s/pvc-data/swagger.json' % (instance_host,) #client = SwaggerClient.from_url(swagger_spec_url, http_client=http_client)
def petstore_client(petstore_dict): return SwaggerClient.from_spec(petstore_dict)
def setUp(self): # Default handlers for all swagger.py access self.resource_listing = { u"swaggerVersion": u"1.2", u"basePath": u"http://swagger.py/swagger-test", u"apis": [ { u"path": u"/api-docs/pet.json", u"description": u"Test loader when missing a file", u"api_declaration": { u"swaggerVersion": u"1.2", u"basePath": u"http://swagger.py/swagger-test", u"resourcePath": u"/pet.json", u"apis": [ { u"path": u"/pet", u"operations": [ { u"method": u"GET", u"nickname": u"listPets", u"type": u"array", u"items": { u"type": u"string" }, u"parameters": [] }, { u"method": u"POST", u"nickname": u"createPet", u"type": u"string", u"parameters": [ { u"name": u"name", u"paramType": u"query", u"type": u"string", u"required": True }, { u"name": u"birthday", u"paramType": u"query", u"type": u"string", u"format": u"date", u"required": False } ] } ] }, { u"path": u"/pet/find", u"operations": [ { u"method": u"GET", u"nickname": u"findPets", u"type": u"array", u"items": { u"type": u"string" }, u"parameters": [ { u"name": u"species", u"paramType": u"query", u"type": u"string", u"allowMultiple": True } ] } ] }, { u"path": u"/pet/{petId}", u"operations": [ { u"method": u"DELETE", u"nickname": u"deletePet", u"type": u"void", u"parameters": [ { u"name": u"petId", u"type": u"integer", u"paramType": u"path" } ] } ] }, { u"path": u"/pet/{petId}/vaccine", u"operations": [ { u"method": u"POST", u"nickname": u"postVaccine", u"type": u"void", u"parameters": [ { u"name": u"petId", u"type": u"integer", u"paramType": u"path" }, { u"name": u"vaccineFile", u"type": u"File", u"paramType": u"form" } ] } ] } ], u"models": {} } } ] } self.uut = SwaggerClient.from_spec(self.resource_listing)
} if useBravadoRemote: bravado_config['validate_swagger_spec'] = False client = SwaggerClient.from_url( host + '/swagger.json', config=bravado_config) else: from bravado_core.spec import Spec # Load local swagger.json, but adjust it to point at correct host spec_dict = json.load(open('swagger.json')) spec_dict['host'] = 'api.monarchinitiative.org' client = SwaggerClient.from_spec( spec_dict, config=bravado_config) try: result = client.bioentity.get_gene_interactions(id=gene_id).result() print('Bravado result') pp = pprint.PrettyPrinter(indent=2) pp.pprint(result) except Exception as e: print("Exception when calling client.bioentity.get_gene_interactions: %s\n" % e) # import requests # # Or alternatively without the swagger client
def client_swagger(falcon_api, swagger_spec): return SwaggerClient.from_spec(swagger_spec, http_client=FalconHttpClient(falcon_api))
def client_no_req_validation(falcon_api, swagger_spec): return SwaggerClient.from_spec(swagger_spec, http_client=FalconHttpClient(falcon_api), config={'validate_requests': False})
def client(swagger_spec): return SwaggerClient.from_spec(swagger_spec, http_client=FalconHttpClient(tests.service.api), config={'also_return_response': True})
STATIC_ROOT = os.path.join(BASE_DIR, 'static') STATICFILES_DIRS = (os.path.join(BASE_DIR, 'dist'),) WEBPACK_LOADER = { 'DEFAULT': { 'CACHE': not DEBUG, 'BUNDLE_DIR_NAME': './', 'STATS_FILE': os.path.join(BASE_DIR, 'webpack-stats.json'), } } if os.environ.get('DEPLOYMENT') == 'MATGEN': SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https') from bravado.client import SwaggerClient from bravado.requests_client import RequestsClient from bravado.swagger_model import Loader # docker containers networking within docker-compose or Fargate task apihost = 'api' if DEBUG else 'localhost' apihost = f'{apihost}:5000' spec_url = 'http://{}/apispec.json'.format(apihost) http_client = RequestsClient() loader = Loader(http_client) spec_dict = loader.load_spec(spec_url) spec_dict['host'] = apihost spec_dict['schemes'] = ['http'] swagger_client = SwaggerClient.from_spec( spec_dict, spec_url, http_client, {'validate_responses': False, 'use_models': False} )
def test_from_spec(self): client_stub = SwaggerClient.from_spec(self.resource_listing) assert isinstance(client_stub, SwaggerClient)