def _get_schema( schema: Optional[Union[str, Type[Schema]]]) -> Optional[Schema]: """Get the schema instance of a schema name or class. In case of OneOfSchema classes, the first dispatched schema is being returned. Args: schema: Either Returns: A schema instance. """ if schema is None: return None # NOTE: # In case of a "OneOfSchema" instance, we don't really have any fields on this Schema # as it is just there for dispatching. The real fields are on the dispatched classes. # We just take the first one and go with that, as we have no way of letting the user chose # the dispatching-key by himself (this is a limitation of ReDoc). _schema: Schema = resolve_schema_instance(schema) if _schema_is_multiple(schema): type_schemas = _schema.type_schemas # type: ignore[attr-defined] first_key = list(type_schemas.keys())[0] _schema = resolve_schema_instance(type_schemas[first_key]) return _schema
def resolve_nested_schema(self, schema): """Return the Open API representation of a marshmallow Schema. Adds the schema to the spec if it isn't already present. Typically will return a dictionary with the reference to the schema's path in the spec unless the `schema_name_resolver` returns `None`, in which case the returned dictoinary will contain a JSON Schema Object representation of the schema. :param schema: schema to add to the spec """ schema_instance = resolve_schema_instance(schema) schema_key = make_schema_key(schema_instance) if schema_key not in self.refs: schema_cls = self.resolve_schema_class(schema) name = self.schema_name_resolver(schema_cls) if not name: try: json_schema = self.schema2jsonschema(schema) except RuntimeError: raise APISpecError( "Name resolver returned None for schema {schema} which is " "part of a chain of circular referencing schemas. Please" " ensure that the schema_name_resolver passed to" " MarshmallowPlugin returns a string for all circular" " referencing schemas.".format(schema=schema) ) if getattr(schema, "many", False): return {"type": "array", "items": json_schema} return json_schema name = create_schema_name(schema=schema_instance) if name not in self.spec.components._schemas: self.spec.components.schema(name, schema=schema) return self.get_ref_dict(schema_instance)
def code_samples( path, method, request_schema, operation_spec, code_templates=[], ): # pylint: disable=dangerous-default-value """Create a list of rendered code sample Objects These are not specified by OpenAPI but are specific to ReDoc.""" if not code_templates: with CODE_TEMPLATES_LOCK: if not code_templates: code_templates.append(_build_code_templates()) headers = [] for param in operation_spec.get('parameters', []): if isinstance(param, dict) and param['in'] == 'header': headers.append(param) return [{ 'lang': language, 'source': template.render( request_endpoint=path, request_method=method, request_schema=(resolve_schema_instance(request_schema) if request_schema is not None else None), headers=headers, ).strip(), } for language, template in code_templates[0].items()]
def code_samples( # pylint: disable=dangerous-default-value path: str, method: HTTPMethod, request_schema: RequestSchema, operation_spec: OperationSpecType, code_templates=[], ) -> List[Dict[str, str]]: """Create a list of rendered code sample Objects These are not specified by OpenAPI but are specific to ReDoc.""" if not code_templates: with CODE_TEMPLATES_LOCK: if not code_templates: code_templates.append(_build_code_templates()) parameters = operation_spec.get('parameters', []) headers = _filter_params(parameters, 'header') query_params = _filter_params(parameters, 'query') return [{ 'lang': language, 'source': template.render( request_endpoint=path, request_method=method, request_schema=(resolve_schema_instance(request_schema) if request_schema is not None else None), endpoint_parameters=_transform_params(parameters), headers=headers, query_params=query_params, ).strip(), } for language, template in code_templates[0].items()]
def schema_loads(schema, data: Dict[str, Any]) -> Optional[Dict[str, Any]]: """Validate a schema and populate it with the defaults. Examples: >>> from marshmallow import Schema >>> from cmk.gui.plugins.openapi import fields >>> class Foo(Schema): ... integer = fields.Integer(required=True) ... hello = fields.String(enum=['World'], required=True) ... default_value = fields.String(missing='was populated') If not all required fields are passed, a ProblemException is being raised. >>> schema_loads(Foo, {}) Traceback (most recent call last): ... connexion.exceptions.ProblemException >>> schema_loads(Foo, {'hello': 'Bob', 'integer': 10}) Traceback (most recent call last): ... connexion.exceptions.ProblemException If validation passes, missing keys are populated with default values as well. >>> expected = { ... 'default_value': 'was populated', ... 'hello': 'World', ... 'integer': 10, ... } >>> res = schema_loads(Foo, {'hello': 'World', 'integer': "10"}) >>> assert res == expected, res Args: schema: A marshmallow schema class, schema instance or name of a schema. data: A dictionary with data that should be checked against the schema. Returns: A new dictionary with the values converted and the defaults populated. """ if schema is None: return None schema_ = resolve_schema_instance(schema) result = schema_.load(data) if result.errors: raise ProblemException( status=400, title="The request could not be validated.", detail="There is an error in your submitted data.", ext={'errors': result.errors}, ) return result.data
def code_samples(path, method, request_schema, code_templates=[]): # pylint: disable=dangerous-default-value """Create a list of rendered code sample Objects These are not specified by OpenAPI but are specific to ReDoc.""" if not code_templates: with CODE_TEMPLATES_LOCK: if not code_templates: code_templates.append(_build_code_templates()) return [{ 'lang': language, 'source': template.render( request_endpoint=path, request_method=method, request_schema=resolve_schema_instance(request_schema), ).strip(), } for language, template in code_templates[0].items()]
def _schema_is_multiple(schema: Optional[Union[str, Type[Schema]]]) -> bool: if schema is None: return False _schema = resolve_schema_instance(schema) return bool(getattr(_schema, 'type_schemas', None))
def _schema_is_multiple(schema: Optional[Union[str, Schema]]) -> bool: if schema is None: return False _schema = resolve_schema_instance(schema) return hasattr(_schema, 'type_schemas') and _schema.type_schemas