@|h:*$ddlmZGddZy))resolve_schema_instancec:eZdZdZdZdZdZdZdZdZ dZ y ) SchemaResolveraResolve marshmallow Schemas in OpenAPI components and translate to OpenAPI `schema objects `_, `parameter objects `_ or `reference objects `_. c ||_||_y)N)openapi_version converter)selfrrs f/var/www/html/test/engine/venv/lib/python3.12/site-packages/apispec/ext/marshmallow/schema_resolver.py__init__zSchemaResolver.__init__s."c |jD]}t|tsd|vr|j|d|d<|jj dk\r9|j |jdid|vr|j|d|jdijD]}|j|y)zResolve marshmallow Schemas in a dict mapping operation to OpenApi `Operation Object https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#operationObject`_ parameters callbacks requestBody responsesN) values isinstancedictresolve_parametersrmajorresolve_callbackgetresolve_schemaresolve_response)r operationskwargs operationresponses r resolve_operationsz!SchemaResolver.resolve_operationss $**, 0Ii.y(*.*A*Al++ ,'##))Q.%%immK&DE I-'' -(@A%MM+r:AAC 0%%h/ 0 0r c|jD]9}t|ts|jD]}|j|;y)a Resolve marshmallow Schemas in a dict mapping callback name to OpenApi `Callback Object https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#callbackObject`_. This is done recursively, so it is possible to define callbacks in your callbacks. Example: :: # Input { "userEvent": { "https://my.example/user-callback": { "post": { "requestBody": { "content": {"application/json": {"schema": UserSchema}} } }, } } } # Output { "userEvent": { "https://my.example/user-callback": { "post": { "requestBody": { "content": { "application/json": { "schema": {"$ref": "#/components/schemas/User"} } } } }, } } } N)rrrr )r rcallbackpaths r rzSchemaResolver.resolve_callback%sKP"((* 2H(D)$OO-2D++D12 2r c \g}|D]}t|trpt|jditsPd|vrLt|j d}||j j |fd|j di|z }|j||j||S)aResolve marshmallow Schemas in a list of OpenAPI `Parameter Objects `_. Each parameter object that contains a Schema will be translated into one or more Parameter Objects. If the value of a `schema` key is marshmallow Schema class, instance or a string that resolves to a Schema Class each field in the Schema will be expanded as a separate Parameter Object. Example: :: # Input class UserSchema(Schema): name = fields.String() id = fields.Int() [{"in": "query", "schema": "UserSchema"}] # Output [ { "in": "query", "name": "id", "required": False, "schema": {"type": "integer"}, }, { "in": "query", "name": "name", "required": False, "schema": {"type": "string"}, }, ] If the Parameter Object contains a `content` key a single Parameter Object is returned with the Schema translated into a Schema Object or Reference Object. Example: :: # Input [ { "in": "query", "name": "pet", "content": {"application/json": {"schema": "PetSchema"}}, } ] # Output [ { "in": "query", "name": "pet", "content": { "application/json": {"schema": {"$ref": "#/components/schemas/Pet"}} }, } ] :param list parameters: the list of OpenAPI parameter objects to resolve. schemainlocation) rrrrpoprschema2parametersrappend)r rresolved parameterschema_instances r rz!SchemaResolver.resolve_parametersRsB# +I9d+"9==2#>EI%"9)--:Q"R`_. Schemas may appear in either a Media Type Object or a Header Object. Example: :: # Input { "content": {"application/json": {"schema": "PetSchema"}}, "description": "successful operation", "headers": {"PetHeader": {"schema": "PetHeaderSchema"}}, } # Output { "content": { "application/json": {"schema": {"$ref": "#/components/schemas/Pet"}} }, "description": "successful operation", "headers": { "PetHeader": {"schema": {"$ref": "#/components/schemas/PetHeader"}} }, } :param dict response: the response object to resolve. headersN)rr)r rheaders r rzSchemaResolver.resolve_responsesJ6 H%  "9-446 ,##F+ , !r ct|tsyd|vr|j|d|d<|jjdk\r:d|vr5|dj D]}d|vs|j|d|d< yyy)a+Resolve marshmallow Schemas in an OpenAPI component or header - modifies the input dictionary to translate marshmallow Schemas to OpenAPI Schema Objects or Reference Objects. OpenAPIv3 Components: :: # Input { "description": "user to add to the system", "content": {"application/json": {"schema": "UserSchema"}}, } # Output { "description": "user to add to the system", "content": { "application/json": {"schema": {"$ref": "#/components/schemas/User"}} }, } :param dict|str data: either a parameter or response dictionary that may contain a schema, or a reference provided as string Nr%rcontent)rrresolve_schema_dictrrr)r datar2s r rzSchemaResolver.resolve_schemas0$%  t !55d8nEDN    % % *D #I557XG7*,0,D,DWXEV,W)X! +r c t|tr|jddk(rd|vr|j|d|d<|jddk(r=d|vr9|dj Dcic]\}}||j|c}}|d<dD],}||vs||Dcgc]}|j|c}||<.d|vr|j|d|d<|S|j j |Scc}}wcc}w)aResolve a marshmallow Schema class, object, or a string that resolves to a Schema class or a schema reference or an OpenAPI Schema Object containing one of the above to an OpenAPI Schema Object or Reference Object. If the input is a marshmallow Schema class, object or a string that resolves to a Schema class the Schema will be translated to an OpenAPI Schema Object or Reference Object. Example: :: # Input "PetSchema" # Output {"$ref": "#/components/schemas/Pet"} If the input is a dictionary representation of an OpenAPI Schema Object recursively search for a marshmallow Schemas to resolve. For `"type": "array"`, marshmallow Schemas may appear as the value of the `items` key. For `"type": "object"` Marshmalow Schemas may appear as values in the `properties` dictionary. Examples: :: # Input {"type": "array", "items": "PetSchema"} # Output {"type": "array", "items": {"$ref": "#/components/schemas/Pet"}} # Input {"type": "object", "properties": {"pet": "PetSchcema", "user": "UserSchema"}} # Output { "type": "object", "properties": { "pet": {"$ref": "#/components/schemas/Pet"}, "user": {"$ref": "#/components/schemas/User"}, }, } :param string|Schema|dict schema: the schema to resolve. typearrayitemsobject properties)oneOfanyOfallOfnot)rrrr3r8rresolve_nested_schema)r r%kvkeywordss r r3z"SchemaResolver.resolve_schema_dictsZ fd #zz&!W,F1B"&":":6'?"Kwzz&!X-,&2H!'| 4 : : <(1t//22(|$7 f$=CG_'89003'F7O   $ 8 8 Gu M~~33F;;( 's .C:"DN) __name__ __module__ __qualname____doc__r r rrrrr3r r rrs0#0&+2ZOb,@#XJ>rJs+b<b