def _get_config_parser(config_file=almdrlib.constants.DEFAULT_CONFIG_FILE):
parser = configparser.ConfigParser()
try:
read_ok = parser.read(config_file)
if config_file not in read_ok:
raise AlmdrlibValueError(f"'{config_file}' doesn't exist")
except configparser.MissingSectionHeaderError:
raise ConfigException(f"Invalid format in file {config_file}")
return parser
def serialize(self, kwargs, headers=None):
if not all(name in kwargs for name in self._required_properties):
raise AlmdrlibValueError(
f"'{self._required_properties}' parameters are required. " +
f"'{kwargs}' were provided.")
result = {
k: kwargs.pop(k)
for k in self._properties.keys() if k in kwargs
}
if self.required and not bool(result):
raise AlmdrlibValueError(
"At least one the " +
f"{self._properties.keys()} parameters must be specified.")
if self._explode:
kwargs['data'] = json.dumps(result)
else:
kwargs['data'] = json.dumps({self._name: result})
def configure(
profile=almdrlib.constants.DEFAULT_PROFILE,
account_id=None,
access_key_id=None, secret_key=None,
global_endpoint=None,
endpoint_map_file=None,
residency=None):
if not access_key_id:
raise AlmdrlibValueError("Missing access_key_id")
if not secret_key:
raise AlmdrlibValueError("Missing secret_key")
parser = _get_config_parser(almdrlib.constants.DEFAULT_CONFIG_FILE)
try:
parser.add_section(profile)
except configparser.DuplicateSectionError:
# section alread exists.
pass
except configparser.ValueError:
# almdrlib.constants.DEFAULT_PROFILE was passed as the section name
pass
parser.set(profile, 'access_key_id', access_key_id)
parser.set(profile, 'secret_key', secret_key)
if account_id:
parser.set(profile, 'account_id', account_id)
if global_endpoint:
parser.set(profile, 'global_endpoint', global_endpoint)
if endpoint_map_file:
parser.set(profile, 'endpoint_map_file', endpoint_map_file)
if residency:
parser.set(profile, 'residency', residency)
with open(almdrlib.constants.DEFAULT_CONFIG_FILE, 'w') as configfile:
parser.write(configfile)
def serialize(self, headers, kwargs):
#
# Get content parameters.
#
if OpenAPIKeyWord.CONTENT_TYPE_PARAM in headers:
content_type = headers[OpenAPIKeyWord.CONTENT_TYPE_PARAM]
payloadBodyParam = self._content[content_type]
elif len(self._content) == 1:
content_type, payloadBodyParam = next(iter(self._content.items()))
headers[OpenAPIKeyWord.CONTENT_TYPE_PARAM] = content_type
else:
raise AlmdrlibValueError(
f"'{OpenAPIKeyWord.CONTENT_TYPE_PYTHON_PARAM}'" +
"parameter is required.")
payloadBodyParam.serialize(kwargs, headers)
def _initialize_operations(self):
self._operations = {}
for path, path_spec in self.paths.items():
for method, op_spec in path_spec.items():
operation_id = op_spec.get(OpenAPIKeyWord.OPERATION_ID)
summary = op_spec.pop(OpenAPIKeyWord.SUMMARY, "")
description = op_spec.pop(OpenAPIKeyWord.DESCRIPTION, "")
if not operation_id:
logging.warn(
f"'{OpenAPIKeyWord.OPERATION_ID}' not found in: \
'[{method}] {path}'"
)
continue
if operation_id in self._operations:
raise AlmdrlibValueError(f"Duplication {operation_id} \
specified for {self._name} API")
# Initialize parameters (path, header, query)
params = [
PathParameter(spec=s, session=self._session)
for s in op_spec.get(OpenAPIKeyWord.PARAMETERS, [])
]
# Initialize operation's body
body = self._initalize_request_body(
op_spec.pop(OpenAPIKeyWord.REQUEST_BODY, None)
)
# Initialize operation's response
response = OperationResponse(
op_spec.pop(OpenAPIKeyWord.RESPONSES, None)
)
self._operations[operation_id] = Operation(
path,
params,
summary,
description,
method,
op_spec,
body,
response,
session=self._session,
server=self._server
)
def validate(self, data):
try:
self._validator.validate(data)
except jsonschema.exceptions.ValidationError as e:
raise AlmdrlibValueError(
f"{e.message}. Schema: {json.dumps(e.schema)}")
