jɁ|UdZddlmZddlZddlZddlZddlmZddl m Z ddl m Z m Z mZmZmZmZmZmZddlmZmZddlmZmZd d lmZmZd d lmZd d lm Z d d l!m"Z"d dlm#Z#m$Z$ej%dkrddlm&Z&nddl m&Z&ej'Z(ej)ddGddZ*ej)ddGddZ+ej)ddGddZ,ej)ddGddZ-e rGdde&Z.Gdde&Z/Gdd e&Z0Gd!d"e&Z1e/ej2ze.zej3zZ4d#e5d$<e1ej6ze0zej7zZ8d#e5d%<e9eeefe:eefze ezZ;d#e5d&<ed'e4e;z(Z<ed)e8e;z(Z=ed*Z>d#e5d+<ed,d,d-dld9Z?ed,d,d-dmd<Z?ed,d,d=dnd?Z?d@dedAdodCZ?edDZ@edEdFZAGdGdHejBe&eAZCGdIdJe&e@ZDGdKdLe&e@ZEGdMdNe&ZFGdOdPe&ZGGdQdRe&ZHGdSdTe&ZIee@ge@fZJd#e5dU< ee@ejKege@fZLd#e5dV< eEe@eDe@zZMd#e5dW<eHeIzeFzeGzZNd#e5dX<eLe@eJe@zZOd#e5dY<edpd[ZPedqd^ZPedrd`ZPdsdbZPedcZQe r e eQd,fZRn$ej)ddGdedfZRe r e eQd,fZSn$ej)ddGdgdhZSediZTGdjdkZUdS)tzBThis module contains related classes and functions for validation.) annotationsN)Callable) partialmethod) TYPE_CHECKING AnnotatedAnyLiteral TypeAliasTypeVarcastoverload)PydanticUndefined core_schema)SelfTypeForm) _decorators _generics)GetCoreSchemaHandler)PydanticUserError) version_short)ArbitraryTypeWarningPydanticDeprecatedSince212) )ProtocolT)frozenslotsc>eZdZUdZded<dd ZeddZdS)AfterValidatoraT!!! abstract "Usage Documentation" [field *after* validators](../concepts/validators.md#field-after-validator) A metadata class that indicates that a validation should be applied **after** the inner validation logic. Attributes: func: The validator function. Example: ```python from typing import Annotated from pydantic import AfterValidator, BaseModel, ValidationError MyInt = Annotated[int, AfterValidator(lambda v: v + 1)] class Model(BaseModel): a: MyInt print(Model(a=1).a) #> 2 try: Model(a='a') except ValidationError as e: print(e.json(indent=2)) ''' [ { "type": "int_parsing", "loc": [ "a" ], "msg": "Input should be a valid integer, unable to parse string as an integer", "input": "a", "url": "https://errors.pydantic.dev/2/v/int_parsing" } ] ''' ``` Kcore_schema.NoInfoValidatorFunction | core_schema.WithInfoValidatorFunctionfunc source_typerhandlerrreturncore_schema.CoreSchemac||}t|jdd}|r5ttj|j}tj||Sttj|j}tj||S)Nafterfieldmodetypeschema)_inspect_validatorr"r rWithInfoValidatorFunction"with_info_after_validator_functionNoInfoValidatorFunction no_info_after_validator_function)selfr#r$r.info_argr"s NC:\Projects\Muse2API\.venv\Lib\site-packages\pydantic/functional_validators.py__get_pydantic_core_schema__z+AfterValidator.__get_pydantic_core_schema__Ks%%%digGLLL  U =tyIIDA$vVVV V ;TYGGD?VTTT T decorator>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]rc$||jS)Nr"r<clsr9s r6_from_decoratorzAfterValidator._from_decoratorUss ''''r8Nr#rr$rr%r&r9r:r%r)__name__ __module__ __qualname____doc____annotations__r7 classmethodr?r8r6r r sh((TVUUUUUUU((([(((r8r cLeZdZUdZded<eZded<dd ZeddZ dS)BeforeValidatora!!! abstract "Usage Documentation" [field *before* validators](../concepts/validators.md#field-before-validator) A metadata class that indicates that a validation should be applied **before** the inner validation logic. Attributes: func: The validator function. json_schema_input_type: The input type used to generate the appropriate JSON Schema (in validation mode). The actual input type is `Any`. Example: ```python from typing import Annotated from pydantic import BaseModel, BeforeValidator MyInt = Annotated[int, BeforeValidator(lambda v: v + 1)] class Model(BaseModel): a: MyInt print(Model(a=1).a) #> 2 try: Model(a='a') except TypeError as e: print(e) #> can only concatenate str (not "int") to str ``` r!r"rjson_schema_input_typer#r$rr%r&cv||}|jturdn||j}t|jdd}|r6t t j|j}t j|||St t j |j}t j |||S)Nbeforer)r*r.json_schema_input_schema) rKrgenerate_schemar/r"r rr0#with_info_before_validator_functionr2!no_info_before_validator_functionr4r#r$r. input_schemar5r"s r6r7z,BeforeValidator.__get_pydantic_core_schema__s%%*.??? D(()DEE  &dihWMMM   =tyIIDB)5   ;TYGGD@Vl r8r9r:rc:||j|jjSN)r"rKr"inforKr=s r6r?zBeforeValidator._from_decorator(s#,>#H    r8Nr@rA rBrCrDrErFrrKr7rGr?rHr8r6rJrJZsv@VUUU"33333,   [   r8rJcLeZdZUdZded<eZded<dd ZeddZ dS)PlainValidatoraw!!! abstract "Usage Documentation" [field *plain* validators](../concepts/validators.md#field-plain-validator) A metadata class that indicates that a validation should be applied **instead** of the inner validation logic. !!! note Before v2.9, `PlainValidator` wasn't always compatible with JSON Schema generation for `mode='validation'`. You can now use the `json_schema_input_type` argument to specify the input type of the function to be used in the JSON schema when `mode='validation'` (the default). See the example below for more details. Attributes: func: The validator function. json_schema_input_type: The input type used to generate the appropriate JSON Schema (in validation mode). The actual input type is `Any`. Example: ```python from typing import Annotated from pydantic import BaseModel, PlainValidator def validate(v: object) -> int: if not isinstance(v, (int, str)): raise ValueError(f'Expected int or str, got {type(v)}') return int(v) + 1 MyInt = Annotated[ int, PlainValidator(validate, json_schema_input_type=str | int), # (1)! ] class Model(BaseModel): a: MyInt print(Model(a='1').a) #> 2 print(Model(a=1).a) #> 2 ``` 1. In this example, we've specified the `json_schema_input_type` as `Union[str, int]` which indicates to the JSON schema generator that in validation mode, the input type for the `a` field can be either a [`str`][] or an [`int`][]. r!r"rrKr#r$rr%r&c ddlm} ||}|dtjd|||}n #|$rd}YnwxYw||j}t|jdd}|r6ttj |j}tj ||| Sttj |j}tj ||| S) Nr)PydanticSchemaGenerationError serializationc||SNrHvhs r6z=PlainValidator.__get_pydantic_core_schema__..!!A$$r8)functionr. return_schemaplainr)r*)r_rO)pydanticr^getr#wrap_serializer_function_ser_schemarPrKr/r"r r0"with_info_plain_validator_functionr2 no_info_plain_validator_function) r4r#r$r^r.r_rTr5r"s r6r7z+PlainValidator.__get_pydantic_core_schema__s? ;::::: !W[))F#JJ?..!")"9"9+"F"FMM- ! ! ! MMM !..t/JKK %digGLLL   =tyIIDA+)5   ;TYGGD?+)5 sA AAAr9r:rc:||j|jjSrVrWr=s r6r?zPlainValidator._from_decoratorrYr8Nr@rA) rBrCrDrErFrrKr7rGr?rHr8r6r\r\sw,,\VUUU"%%%%%''''R   [   r8r\cLeZdZUdZded<eZded<dd ZeddZ dS) WrapValidatora!!! abstract "Usage Documentation" [field *wrap* validators](../concepts/validators.md#field-wrap-validator) A metadata class that indicates that a validation should be applied **around** the inner validation logic. Attributes: func: The validator function. json_schema_input_type: The input type used to generate the appropriate JSON Schema (in validation mode). The actual input type is `Any`. ```python from datetime import datetime from typing import Annotated from pydantic import BaseModel, ValidationError, WrapValidator def validate_timestamp(v, handler): if v == 'now': # we don't want to bother with further validation, just return the new value return datetime.now() try: return handler(v) except ValidationError: # validation failed, in this case we want to return a default value return datetime(2000, 1, 1) MyTimestamp = Annotated[datetime, WrapValidator(validate_timestamp)] class Model(BaseModel): a: MyTimestamp print(Model(a='now').a) #> 2032-01-02 03:04:05.000006 print(Model(a='invalid').a) #> 2000-01-01 00:00:00 ``` zScore_schema.NoInfoWrapValidatorFunction | core_schema.WithInfoWrapValidatorFunctionr"rrKr#r$rr%r&cv||}|jturdn||j}t|jdd}|r6t t j|j}t j|||St t j |j}t j |||S)Nwrapr)r*rN) rKrrPr/r"r rWithInfoWrapValidatorFunction!with_info_wrap_validator_functionNoInfoWrapValidatorFunctionno_info_wrap_validator_functionrSs r6r7z*WrapValidator.__get_pydantic_core_schema__,s%%*.??? D(()DEE  &dif7KKK   A49MMD@)5   ?KKD>)5 r8r9r:rc:||j|jjSrVrWr=s r6r?zWrapValidator._from_decoratorDrYr8Nr@rArZrHr8r6rqrqsv$$L^]]]"333330   [   r8rqceZdZddZdS)_OnlyValueValidatorClsMethodr>rvaluer%cdSrarHr4r>r{s r6__call__z%_OnlyValueValidatorClsMethod.__call__Or8Nr>rr{rr%rrBrCrDr~rHr8r6rzrzNs??????r8rzceZdZd dZdS) _V2ValidatorClsMethodr>rr{rXcore_schema.ValidationInfo[Any]r%cdSrarHr4r>r{rXs r6r~z_V2ValidatorClsMethod.__call__Rrr8Nr>rr{rrXrr%rrrHr8r6rrQsffffffr8rceZdZd dZdS) _OnlyValueWrapValidatorClsMethodr>rr{r$(core_schema.ValidatorFunctionWrapHandlerr%cdSrarHr4r>r{r$s r6r~z)_OnlyValueWrapValidatorClsMethod.__call__Urr8N)r>rr{rr$rr%rrrHr8r6rrTsrrrrrrr8rceZdZd d Zd S) _V2WrapValidatorClsMethodr>rr{r$rrXrr%cdSrarHr4r>r{r$rXs r6r~z"_V2WrapValidatorClsMethod.__call__Xs #r8N) r>rr{rr$rrXrr%rrrHr8r6rrWs(      r8rr _V2Validator_V2WrapValidator_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType)bound_V2WrapValidatorType)rMr(rsriFieldValidatorModes.) check_fieldsrKr)strfieldsr+Literal['wrap']r bool | NonerKrr%6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]cdSrarHr)r+rrKrs r6field_validatorrzs >ASr8Literal['before', 'plain']RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]cdSrarHrs r6rrs Z]Y\r8)r+rLiteral['after']cdSrarH)r)r+rrs r6rrs Z]Y\r8r()r+rrKCallable[[Any], Any]cXt|st|trtdddvrturtddtur dkrt |gRt dDstd d dfd }|S)u!!! abstract "Usage Documentation" [field validators](../concepts/validators.md#field-validators) Decorate methods on the class indicating that they should be used to validate fields. Example usage: ```python from typing import Any from pydantic import ( BaseModel, ValidationError, field_validator, ) class Model(BaseModel): a: str @field_validator('a') @classmethod def ensure_foobar(cls, v: Any): if 'foobar' not in v: raise ValueError('"foobar" not found in a') return v print(repr(Model(a='this is foobar good'))) #> Model(a='this is foobar good') try: Model(a='snap') except ValidationError as exc_info: print(exc_info) ''' 1 validation error for Model a Value error, "foobar" not found in a [type=value_error, input_value='snap', input_type=str] ''' ``` For more in depth examples, see [Field Validators](../concepts/validators.md#field-validators). Errors raised in a field validator become part of the model's [`ValidationError`][pydantic_core.ValidationError]. In a running application, [Logfire](../integrations/logfire.md) can record the input each failed validation rejected — see [Troubleshooting validation errors](../errors/troubleshooting.md). Args: *fields: The field names the validator should apply to. mode: Specifies whether to validate the fields before or after validation. check_fields: Whether to check that the fields actually exist on the model. json_schema_input_type: The input type of the function. This is only used to generate the appropriate JSON Schema (in validation mode) and can only specified when `mode` is either `'before'`, `'plain'` or `'wrap'`. Raises: PydanticUserError: - If the decorator is used without any arguments (at least one field name must be provided). - If the provided field names are not strings. - If `json_schema_input_type` is provided with an unsupported `mode`. - If the decorator is applied to an instance method. zThe `@field_validator` decorator cannot be used without arguments, at least one field must be provided. For example: `@field_validator('', ...)`.zdecorator-missing-argumentscode)rMrirsz;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typeric3@K|]}t|tVdSra) isinstancer).0r)s r6 z"field_validator..s,::%z%%%::::::r8zThe provided field names to the `@field_validator` decorator should be strings. For example: `@field_validator('', '', ...).`zdecorator-invalid-fieldsfHCallable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any]r%(_decorators.PydanticDescriptorProxy[Any]ctj|rtddtj|}tj}tj||S)NzFThe `@field_validator` decorator cannot be applied to instance methodszvalidator-instance-methodr)rr+rrK)ris_instance_method_from_sigr%ensure_classmethod_based_on_signatureFieldValidatorDecoratorInfoPydanticDescriptorProxy)rdec_inforrrKr+s r6deczfield_validator..decs}  21 5 5 #X0   =a @ @:type[_ModelType]r{rr$%ModelWrapValidatorHandler[_ModelType]r%rcdSrarHrs r6r~z&ModelWrapValidatorWithoutInfo.__call__ s Sr8N)r>rr{rr$rr%rrrHr8r6rrs2      r8rceZdZdZdd Zd S)ModelWrapValidatorzSA `@model_validator` decorated function signature. This is used when `mode='wrap'`.r>rr{rr$rrXcore_schema.ValidationInfor%rcdSrarHrs r6r~zModelWrapValidator.__call__/s Sr8N) r>rr{rr$rrXrr%rrrHr8r6rr,s.]]      r8rceZdZdZddZdS)#FreeModelBeforeValidatorWithoutInfoA `@model_validator` decorated function signature. This is used when `mode='before'` and the function does not have info argument. r{rr%cdSrarH)r4r{s r6r~z,FreeModelBeforeValidatorWithoutInfo.__call__As cr8N)r{rr%rrrHr8r6rr<s2r8rceZdZdZddZdS) ModelBeforeValidatorWithoutInforr>rr{r%cdSrarHr}s r6r~z(ModelBeforeValidatorWithoutInfo.__call__P cr8NrrrHr8r6rrKs2r8rceZdZdZd dZdS) FreeModelBeforeValidatorUA `@model_validator` decorated function signature. This is used when `mode='before'`.r{rrXrr%cdSrarH)r4r{rXs r6r~z!FreeModelBeforeValidator.__call__^rr8N)r{rrXrr%rrrHr8r6rr[s.__r8rceZdZdZd dZd S) ModelBeforeValidatorrr>rr{rXrr%cdSrarHrs r6r~zModelBeforeValidator.__call__ls cr8NrrrHr8r6rris.__      r8rModelAfterValidatorWithoutInfoModelAfterValidator_AnyModelWrapValidator_AnyModelBeforeValidator_AnyModelAfterValidator|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cdSrarHr+s r6model_validatorr 3r8Literal['before']rCallable[[_AnyModelBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cdSrarHrs r6rrrr8}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cdSrarHrs r6rrrr8"Literal['wrap', 'before', 'after']cdfd }|S)a!!! abstract "Usage Documentation" [Model Validators](../concepts/validators.md#model-validators) Decorate model methods for validation purposes. Example usage: ```python from typing_extensions import Self from pydantic import BaseModel, ValidationError, model_validator class Square(BaseModel): width: float height: float @model_validator(mode='after') def verify_square(self) -> Self: if self.width != self.height: raise ValueError('width and height do not match') return self s = Square(width=1, height=1) print(repr(s)) #> Square(width=1.0, height=1.0) try: Square(width=1, height=2) except ValidationError as e: print(e) ''' 1 validation error for Square Value error, width and height do not match [type=value_error, input_value={'width': 1, 'height': 2}, input_type=dict] ''' ``` For more in depth examples, see [Model Validators](../concepts/validators.md#model-validators). Cross-field rules like the one above tend to fail on combinations of values you didn't anticipate. The resulting [`ValidationError`][pydantic_core.ValidationError] includes the input that failed; [Logfire](../integrations/logfire.md) can retain these failures with their trace context so you can investigate patterns in a running application (see [Troubleshooting validation errors](../errors/troubleshooting.md)). Args: mode: A required string literal that specifies the validation mode. It can be one of the following: 'wrap', 'before', or 'after'. Returns: A decorator that can be used to decorate a function to be used as a model validator. rrr%rctj|}dkrAt|tr,t jt dtddtj}tj ||S)Nr(zUsing `@model_validator` with mode='after' on a classmethod is deprecated. Instead, use an instance method. See the documentation at https://pydantic.dev/docs/validation/z,/concepts/validators/#model-after-validator.)categorymessage stacklevelr) rrrrGwarningswarnrrModelValidatorDecoratorInfor)rrr+s r6rzmodel_validator..decs  =a @ @ 7??z![99? M3SUbUdUdSSS     :EEE21h???r8)rrr%rrH)r+rs` r6rrs/n@@@@@@ Jr8AnyType)rcPeZdZdZed dZedd ZejZd S) InstanceOfuGeneric type for annotating a type that is an instance of a given class. Example: ```python from pydantic import BaseModel, InstanceOf class Foo: ... class Bar(BaseModel): foo: InstanceOf[Foo] Bar(foo=Foo()) try: Bar(foo=42) except ValidationError as e: print(e) """ [ │ { │ │ 'type': 'is_instance_of', │ │ 'loc': ('foo',), │ │ 'msg': 'Input should be an instance of Foo', │ │ 'input': 42, │ │ 'ctx': {'class': 'Foo'}, │ │ 'url': 'https://errors.pydantic.dev/0.38.0/v/is_instance_of' │ } ] """ ``` itemrr%c0t||fSra)rr>rs r6__class_getitem__zInstanceOf.__class_getitem__sT3355[) )r8sourcerr$rr&cddlm}tjt j|p|} ||}tjd||d<tj||S#|$r|cYSwxYw)NrGENERATE_SCHEMA_ERRORSc||SrarHrbs r6rez9InstanceOf.__get_pydantic_core_schema__../rfr8rgr.r_) python_schema json_schema)#pydantic._internal._generate_schemarris_instance_schemar get_originrljson_or_python_schema)r>rr$rinstance_of_schemaoriginal_schemas r6r7z'InstanceOf.__get_pydantic_core_schema__s S R R R R R"-!? @TU[@\@\@f`f!g!g  x")'&// 7B6e..777"?3#8GYgvwwww* * * *)))) *s A++A54A5N)rrr%rrrr$rr%r&) rBrCrDrErGrr7object__hash__rHr8r6rrsf  @  * * *  *  x x x  x(?r8rc@eZdZdZd dZed d ZejZd S)SkipValidationaIf this is applied as an annotation (e.g., via `x: Annotated[int, SkipValidation]`), validation will be skipped. You can also use `SkipValidation[int]` as a shorthand for `Annotated[int, SkipValidation]`. This can be useful if you want to use a type annotation for documentation/IDE/type-checking purposes, and know that it is safe to skip validation for one or more of the fields. Because this converts the validation schema to `any_schema`, subsequent annotation-applied transformations may not have the expected effects. Therefore, when used, this annotation should generally be the final annotation applied to a type. rrr%c8t|tfSra)rr rs r6rz SkipValidation.__class_getitem__GsT>#3#334 4r8rr$rr&c tj5tjdt||dddn #1swxYwYdfdgi}t j|t jdS)Nignore pydantic_js_annotation_functionsc|SrarH)_crdrs r6rez=SkipValidation.__get_pydantic_core_schema__..Os11_K]K]r8c||SrarHrbs r6rez=SkipValidation.__get_pydantic_core_schema__..Srfr8r)metadatar_)rcatch_warnings simplefilterrr any_schemarl)r>rr$rrs @r6r7z+SkipValidation.__get_pydantic_core_schema__Js(** 2 2%h0DEEE")'&// 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2;=]=]=]=]<^_H)!)M.. s&AA A N)rrr%rr ) rBrCrDrErrGr7r r rHr8r6r r :sU  5 5 5 5      ?r8r  _FromTypeTc"eZdZdZddZddZdS) ValidateAsaA helper class to validate a custom type from a type that is natively supported by Pydantic. Args: from_type: The type natively supported by Pydantic to use to perform validation. instantiation_hook: A callable taking the validated type as an argument, and returning the populated custom type. Example: ```python {lint="skip"} from typing import Annotated from pydantic import BaseModel, TypeAdapter, ValidateAs class MyCls: def __init__(self, a: int) -> None: self.a = a def __repr__(self) -> str: return f"MyCls(a={self.a})" class Model(BaseModel): a: int ta = TypeAdapter( Annotated[MyCls, ValidateAs(Model, lambda v: MyCls(a=v.a))] ) print(ta.validate_python({'a': 1})) #> MyCls(a=1) ``` instantiation_hookCallable[[_FromTypeT], Any] from_typeTypeForm[_FromTypeT]r%Nonec"||_||_dSra)rr)r4rrs r6__init__zValidateAs.__init__s""4r8rrr$rr&cddlm}||j}tj|j|} ||}n#|$rtj}YnwxYwtjd||d<|S)Nrrr-c||SrarHrbs r6rez9ValidateAs.__get_pydantic_core_schema__..s!!A$$r8rr_)rrrrr3rrrl)r4rr$rfrom_type_schemar. ser_schemas r6r7z'ValidateAs.__get_pydantic_core_schema__sNNNNNN"74>22=  ##    2 JJ% 2 2 2$/11JJJ 2#."Q&&z# # #  s ?AAN)rrrrr%r r )rBrCrDrEr"r7rHr8r6rr]sGB5555r8r) r)rrrr+rrrrKrr%r) r)rrrr+rrrrKrr%r) r)rrrr+rrrr%r) r)rrrr+rrrrKrr%r)r+rr%r)r+rr%r)r+rr%r)r+rr%r)VrE __future__r _annotations dataclassessysrcollections.abcr functoolsrtypingrrrr r r r r pydantic_corerrtyping_extensionsrr _internalrrannotated_handlersrerrorsrversionrrr version_inforinspect_validatorr/ dataclassr rJr\rqrzrrrr0r2rrFrtrvrrG staticmethodrrrrrrrValidatorFunctionWrapHandlerrrrrrrrrValidationInforrrrrrrr rrrHr8r6r:s HHH222222 $$$$$$######]]]]]]]]]]]]]]]]]]]]88888888,,,,,,,,--------444444%%%%%%""""""FFFFFFFFg******* 2d$///9(9(9(9(9(9(9(0/9(xd$///? ? ? ? ? ? ? 0/? Dd$///` ` ` ` ` ` ` 0/` Fd$///G G G G G G G 0/G T)o@@@@@x@@@ggggggggsssss8sssH   / 0 & '  - . "  3 4 * +  1 2,7sC}+E UXZ]U]H^+^anoras+sssss)0,66***&#7#9AQTmAmnnn!()K!LLLLL !$"% AAAAA A !$"% ]]]]] ] ! # ]]]]] ]!( $"3 nnnnnnbW\ " " w~666       H(S_J`    HZ$8"     *-        (        h        x        8   -5j\:5M,NNNNN"*:{7QRU7V*WYc*c!dddddZ$6z$BEbcmEn$nnnnn)*&& &9%DGefpGq%qqqqq      GGGGT ')  A#7C<(JJ[&&&:#:#:#:#:#:#:#'&:#z!#w|,NN[&&&#######'&#>W\ " " ;;;;;;;;;;r8