fʟdZdZddlZddlZddlZddlZddlZddlZddlm Z ddl m Z ddl m Z ddl mZddl mZdd l mZdd l mZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ddlm$Z$ddlm%Z%ddlm&Z&ddlm'Z'ddlm(Z(ddlm)Z)dd lm*Z*dd!lm+Z+Gd"d#e,Z-e-Z-Gd$d%e,Z.Gd&d'e.Z/d(Z0Gd)d*e,Z1Gd+d,e Z2Gd-d.e2Z3Gd/d0e3Z4Gd1d2e,Z5Gd3d4e,Z6eeGd5d6e6e2Z7Gd7d8e7Z8Gd9d:e8Z9eeeGd;de;e*Z<eeeGd?d@e5e2Z=GdAdBe=Z>GdCdDe>Z?GdEdFe?Z@GdGdHe;e*ZAGdIdJe@ZBGdKdLeBZCGdMdNe;e*ZDGdOdPe=ZEGdQdRejZGeGfdSZHdYdTZIGdUdVe2ZJeeGdWdXe,ZKy)ZzBootstrapping fields restructuredtextN)isinf)notify) Attribute) Interface)Invalid) implementer) providedBy)InterfaceClass) IInterface)IMethod)ConstraintNotSatisfied)IBeforeObjectAssignedEvent)IContextAwareDefaultFactory) IFromBytes) IFromUnicode) IValidatable) NotAContainer)NotAnInterface) NotAnIterator)RequiredMissing)SchemaNotCorrectlyImplemented)SchemaNotFullyImplemented)SchemaNotProvided)StopValidation)TooBig)TooLong)TooShort)TooSmall)ValidationError) WrongTypeceZdZdZy) _NotGivency)Nz )selfs t/var/dept/share/cheung/public_html/OutSchool/python/env/lib/python3.12/site-packages/zope/schema/_bootstrapfields.py__repr__z_NotGiven.__repr__<sN)__name__ __module__ __qualname__r(r%r)r'r#r#:sr)r#c eZdZddZdZdZy)ValidatedPropertyNc.||_||_||_yN)_name_check _allow_none)r&namecheck allow_nones r'__init__zValidatedProperty.__init__Es  %r)c|duxr |jxs||jk(}|s0|j|j||n|j|||j|j <yr0)r3 missing_valuer2validate__dict__r1)r&instvaluebypass_validations r'__set__zValidatedProperty.__set__Jsg d] /t// +*** !{{& D%( e$$) djj!r)c<||S|j|jSr0)r;r1)r&r<owners r'__get__zValidatedProperty.__get__Vs <K}}TZZ((r)NF)r*r+r,r7r?rBr%r)r'r.r.Cs& *)r)r.ceZdZdZy)DefaultPropertycX||S|jjd}||j|jStj|r||j }n|}|j |j |||S||jk7r|j||S)NdefaultFactory) r;getr1rr contextr2r9r:)r&r<rArGr=s r'rBzDefaultProperty.__get__^s <K**+;<  !==, , ' 1 1. A"4<<0E"$E ;; " KKe $ d(( ( MM%  r)N)r*r+r,rBr%r)r'rErE\sr)rEcXi}|D]"}||}tj|s|||<$|S)z?Return a dictionary containing all the Fields in a schema. )rr )schemafieldsr4attrs r' getFieldsrNss?F d|  " "4 (F4L  Mr)cLeZdZedZedZedZedZy)_DocStringHelpersc|jj}tj}|ddD]8}t |j }|st ||z }t ||}:t |dk\r|dj |d<|tjkr%tdt |D] }|||d||<|r|ds|jd|r|ds|jd|S)Nr) expandtabs splitlinessysmaxsizelenlstripminrangepopappend) docstringlinesmarginlinecontentindentis r'docstring_to_linesz$_DocStringHelpers.docstring_to_liness $$&113!"I -D$++-(GTW,VV,  - u:?Qx(E!H CKK 1c%j) - 8FG,a -E!H IIaLE!H  R r)c||j}|jdvrd}|dvrd}||rdndz }d||jdS)N) __builtin__builtinsrS)zzope.schema._bootstrapfieldszzope.schema._fieldz zope.schema.z:class:``)r+r*)kindmods r'make_class_directivez&_DocStringHelpers.make_class_directivesHoo ??9 9C H HC csr!"%t}}55r)cd|d|S)N:z: r%)clsr4r=s r' make_fieldz_DocStringHelpers.make_fields  %((r)c 2t|ttfr!|j||j |St|t st d||j|dj|Dcgc]}|j |c}Scc}w)Nz%make_class_field() can't handle kind z, ) isinstancetyper rqrmtuple TypeErrorjoin)rpr4rkts r'make_class_fieldz"_DocStringHelpers.make_class_fields dT>2 3>>$(@(@(FG G$&=ACE E~~  IIDAqs//2A BD DAs1BN) r*r+r, staticmethodrerm classmethodrqryr%r)r'rPrP~sT866))DDr)rPc eZdZdZdZdZeZdZe dZ dZdZ dZ ddddddddef fd Z dZd Zd Zd Zd Zd ZdZdZdZddZdZdZfdZxZS)FieldNrdefaultrSTFc d} djtj|xsddd} |r | r|d| } n|} n|r| } tt||| ||_||_||_||_ |||_ ||_ ||_ txjdz c_ tj|_ | |jur| |_yy)aPass in field values as keyword parameters. Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument. Here are some examples: >>> from zope.schema._bootstrapfields import Field >>> f = Field() >>> f.__doc__, str(f.title), str(f.description) ('', '', '') >>> f = Field(title=u'sample') >>> str(f.__doc__), str(f.title), str(f.description) ('sample', 'sample', '') >>> f = Field(title=u'sample', description=u'blah blah\nblah') >>> str(f.__doc__), str(f.title), str(f.description) ('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah') rS Nz rR)rwrPresuperr}r7title descriptionrequiredreadonly constraintr~rGorder_Field__missing_value_markerr9) r&rrr*rrrr~rGr9__doc__doc_description __class__s r'r7zField.__init__s:))  0 01C DSb I  (-? %G eT#Hg6 &     !(DO ,  q [[  ; ; ;!.D   ? LL*55dll!35 6 :: LL*;; , - ; -LD&D$-Euh' R  ^f45 R  U\\^, - r)ctt| }tj |}||j z }|j ddj|S)NrSr)rr}rrPrerr]rw)r&docr_rs r'rz Field.getDocsPE4')!44S9 &&(( Ryyr)r0)r*r+r,rrIr9r#rrrEr~r_Element__tagged_valuesr7rrr:rrrrrrHrrrr __classcell__rs@r'r}r}s EGM ' Ei(GHI" cB4 $4J</|  (&0&.7.,\  r)r}ceZdZfdZxZS) Containerctt| |t|ds t |yy#t $rt |j||wxYw)N __contains__)rrrriterrvrrr&r=rs r'rzContainer._validatesY i(/un- MU . M#E*??eLL Ms /%Ar*r+r,rrrs@r'rrsMMr)rceZdZfdZxZS)Iterablectt| | t|y#t$rt |j ||wxYwr0)rrrrrvrrrs r'rzIterable._validatesH h'. I K I&;;D%H H Is "%Arrs@r'rrsIIr)rcVeZdZdZeddZeddZdfd ZfdZxZ S) OrderablezValues of ordered fields can be sorted. They can be restricted to a range of values. Orderable is a mixin used in combination with Field. rZT)r6maxc rd|_d|_tt|di|||_||_||_yNr%)rZrrrr7r~)r&rZrr~kwrs r'r7zOrderable.__init__s> i'-"- r)c2tt| ||j5||jkr&t ||jj |||j 6||j kDr&t||j j ||yyr0)rrrrZrrrrrs r'rzOrderable._validates i(/ 88 EDHH$45$((+@@uM M 88 EDHH$4)>>tUK K%5 r))NNN) r*r+r,rr.rZrr7rrrs@r'rrs3 Ed 3C Ed 3C"LLr)rc6eZdZdZdZdZdfd ZfdZxZS) MinMaxLenznExpresses constraints on the length of a field. MinMaxLen is a mixin used in combination with Field. rNc H||_||_tt|di|yr) min_length max_lengthrrr7)r&rrrrs r'r7zMinMaxLen.__init__s#$$ i'-"-r)cVtt| ||j>t ||jkr&t ||jj |||j?t ||jkDr&t||jj ||yyr0) rrrrrXrrrrrs r'rzMinMaxLen._validates i(/ ?? &3u:+G5$//2GGe  ?? &3u:+G%1FFe ,H &r))rN) r*r+r,rrrr7rrrs@r'rrs#JJ.  r)rc0eZdZdZeZdZfdZdZxZ S)Textz1A field containing text used for human discourse.NFCcn|jd|j|_tt||i|y)Nunicode_normalization)r\rrrr7)r&argsrrs r'r7z Text.__init__s4%'VV #T%?%?&A" dD"D/B/r)ct|tr,|jr tj|j|}|j ||S)a >>> from zope.schema import Text >>> t = Text(constraint=lambda v: 'x' in v) >>> t.fromUnicode(b"foo x spam") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... zope.schema._bootstrapinterfaces.WrongType: ('foo x spam', , '') >>> result = t.fromUnicode(u"foo x spam") >>> isinstance(result, bytes) False >>> str(result) 'foo x spam' >>> t.fromUnicode(u"foo spam") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... zope.schema._bootstrapinterfaces.ConstraintNotSatisfied: (u'foo spam', '') )rsstrr unicodedata normalizer:rs r' fromUnicodezText.fromUnicodesC( eS !))#--..7 e r)) r*r+r,rrrrr7rrrs@r'rr s; E!0 r)rceZdZdZdZy)TextLinezA text field with no newlines.cd|vxrd|vS)Nr r%rs r'rzTextLine.constraint3s5 6T%66r)N)r*r+r,rrr%r)r'rr0s (7r)rc:eZdZdZeZfdZfdZxZS)Passwordz2A text field containing a text used as a password.cL||jurytt|||y)a Update the password. We use a special marker value that a widget can use to tell us that the password didn't change. This is needed to support edit forms that don't display the existing password and want to work together with encryption. N)UNCHANGED_PASSWORDrrr)r&rIr=rs r'rz Password.set<s' D++ +  h!'51r)c t|j|j}||jur|ryt t ||S#t$rd}Y1wxYwrC)boolrHrIAttributeErrorrrrr:)r&r=existingrs r'r:zPassword.validateJs\ DHHT\\23H D++ + Xt-e44  H s$A AA) r*r+r,rrrrr:rrs@r'rr7s< 255r)rc,eZdZdZeZdZdZdZdZ y)Boolz A field representing a Bool. .. versionchanged:: 4.8.0 Implement :class:`zope.schema.interfaces.IFromBytes` ct|trt|ts t|}tj ||yr0)rsintrr}rrs r'rzBool._validate`s. eS !*UD*AKE e$r)ct|trt|ts t|}tj |||yr0)rsrrr}rrs r'rzBool.setgs. eS !*UD*AKE $&r)c@|dk(xs|dk(}|j||S)u >>> from zope.schema._bootstrapfields import Bool >>> from zope.schema.interfaces import IFromUnicode >>> b = Bool() >>> IFromUnicode.providedBy(b) True >>> b.fromUnicode('True') True >>> b.fromUnicode('') False >>> b.fromUnicode('true') True >>> b.fromUnicode('false') or b.fromUnicode('False') False >>> b.fromUnicode(u'☃') False Truetrue)r:)r&r=vs r'rzBool.fromUnicodels'* VO .u ar)cB|j|jdS)u >>> from zope.schema._bootstrapfields import Bool >>> from zope.schema.interfaces import IFromBytes >>> b = Bool() >>> IFromBytes.providedBy(b) True >>> b.fromBytes(b'True') True >>> b.fromBytes(b'') False >>> b.fromBytes(b'true') True >>> b.fromBytes(b'false') or b.fromBytes(b'False') False >>> b.fromBytes(u'☃'.encode('utf-8')) False utf-8rdecoders r' fromByteszBool.fromBytess$ W 566r)N) r*r+r,rrrrrrrr%r)r'rrUs" E%' 27r)rceZdZdZy)InvalidNumberLiteralzInvalid number literal.Nr*r+r,rr%r)r'rrs!r)rcneZdZdZej Zeee je e jfZeZdZdZy)Numbera A field representing a :class:`numbers.Number` and implementing :class:`zope.schema.interfaces.INumber`. The :meth:`fromUnicode` method will attempt to use the smallest or strictest possible type to represent incoming strings:: >>> from zope.schema._bootstrapfields import Number >>> f = Number() >>> f.fromUnicode(u"1") 1 >>> f.fromUnicode(u"125.6") 125.6 >>> f.fromUnicode(u"1+0j") (1+0j) >>> f.fromUnicode(u"1/2") Fraction(1, 2) >>> f.fromUnicode(str(2**11234) + '.' + str(2**256)) ... # doctest: +ELLIPSIS Decimal('590...936') >>> f.fromUnicode(u"not a number") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidNumberLiteral: Invalid literal for Decimal: 'not a number' Similarly, :meth:`fromBytes` will do the same for incoming byte strings:: >>> from zope.schema._bootstrapfields import Number >>> f = Number() >>> f.fromBytes(b"1") 1 >>> f.fromBytes(b"125.6") 125.6 >>> f.fromBytes(b"1+0j") (1+0j) >>> f.fromBytes(b"1/2") Fraction(1, 2) >>> f.fromBytes((str(2**11234) + '.' + str(2**256)).encode('ascii')) ... # doctest: +ELLIPSIS Decimal('590...936') >>> f.fromBytes(b"not a number") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidNumberLiteral: Invalid literal for Decimal: 'not a number' .. versionadded:: 4.6.0 .. versionchanged:: 4.8.0 Implement :class:`zope.schema.interfaces.IFromBytes` cd}|jD]c} ||}|tur>> from zope.schema._bootstrapfields import Complex >>> f = Complex() >>> f.fromUnicode(u"1") 1 >>> f.fromUnicode(u"125.6") 125.6 >>> f.fromUnicode(u"1+0j") (1+0j) >>> f.fromUnicode(u"1/2") Fraction(1, 2) >>> f.fromUnicode(str(2**11234) + '.' + str(2**256)) ... # doctest: +ELLIPSIS inf >>> f.fromUnicode(u"not a number") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidNumberLiteral: Invalid literal for Decimal: 'not a number' Similarly for :meth:`fromBytes`: >>> from zope.schema._bootstrapfields import Complex >>> f = Complex() >>> f.fromBytes(b"1") 1 >>> f.fromBytes(b"125.6") 125.6 >>> f.fromBytes(b"1+0j") (1+0j) >>> f.fromBytes(b"1/2") Fraction(1, 2) >>> f.fromBytes((str(2**11234) + '.' + str(2**256)).encode('ascii')) ... # doctest: +ELLIPSIS inf >>> f.fromBytes(b"not a number") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidNumberLiteral: Invalid literal for Decimal: 'not a number' .. versionadded:: 4.6.0 N) r*r+r,rrrrrrrrrrr%r)r'rrs(.^ OOEw 0B0BCr)rcFeZdZdZej Zeee jfZ y)Reala A field representing a :class:`numbers.Real` and implementing :class:`zope.schema.interfaces.IReal`. The :meth:`fromUnicode` method is like that for :class:`Complex`, but doesn't allow Decimals or complex numbers:: >>> from zope.schema._bootstrapfields import Real >>> f = Real() >>> f.fromUnicode("1") 1 >>> f.fromUnicode("125.6") 125.6 >>> f.fromUnicode("1+0j") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidNumberLiteral: Invalid literal for Fraction: '1+0j' >>> f.fromUnicode("1/2") Fraction(1, 2) >>> f.fromUnicode(str(2**11234) + '.' + str(2**256)) ... # doctest: +ELLIPSIS inf >>> f.fromUnicode("not a number") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidNumberLiteral: Invalid literal for Decimal: 'not a number' .. versionadded:: 4.6.0 N) r*r+r,rrrrrrrrrr%r)r'rr/s%: LLEy'9'9:r)rcDeZdZdZej ZeejfZ y)Rationala A field representing a :class:`numbers.Rational` and implementing :class:`zope.schema.interfaces.IRational`. The :meth:`fromUnicode` method is like that for :class:`Real`, but does not allow arbitrary floating point numbers:: >>> from zope.schema._bootstrapfields import Rational >>> f = Rational() >>> f.fromUnicode("1") 1 >>> f.fromUnicode("1/2") Fraction(1, 2) >>> f.fromUnicode("125.6") Fraction(628, 5) >>> f.fromUnicode("1+0j") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidNumberLiteral: Invalid literal for Fraction: '1+0j' >>> f.fromUnicode(str(2**11234) + '.' + str(2**256)) ... # doctest: +ELLIPSIS Fraction(195..., 330...) >>> f.fromUnicode("not a number") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidNumberLiteral: Invalid literal for Decimal: 'not a number' .. versionadded:: 4.6.0 N) r*r+r,rrrrrrrrr%r)r'rrQs%:   E 2 23r)rceZdZdZy)InvalidIntLiteralzInvalid int literal.Nrr%r)r'rrsr)rc2eZdZdZej ZefZe Z y)Integrala} A field representing a :class:`numbers.Integral` and implementing :class:`zope.schema.interfaces.IIntegral`. The :meth:`fromUnicode` method only allows integral values:: >>> from zope.schema._bootstrapfields import Integral >>> f = Integral() >>> f.fromUnicode("125") 125 >>> f.fromUnicode("125.6") #doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidIntLiteral: invalid literal for int(): 125.6 Similarly for :meth:`fromBytes`: >>> from zope.schema._bootstrapfields import Integral >>> f = Integral() >>> f.fromBytes(b"125") 125 >>> f.fromBytes(b"125.6") #doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidIntLiteral: invalid literal for int(): 125.6 .. versionadded:: 4.6.0 N) r*r+r,rrrrrrrr r%r)r'rrws"8   E&)r)rceZdZdZeZefZy)IntzkA field representing a native integer type. and implementing :class:`zope.schema.interfaces.IInt`. N)r*r+r,rrrrr%r)r'rrs E&r)rceZdZdZy)InvalidDecimalLiteralzRaised by decimal fieldsNrr%r)r'r!r!rr)r!cFeZdZdZej Zej fZeZ y)ra: A field representing a native :class:`decimal.Decimal` and implementing :class:`zope.schema.interfaces.IDecimal`. The :meth:`fromUnicode` method only accepts values that can be parsed by the ``Decimal`` constructor:: >>> from zope.schema._field import Decimal >>> f = Decimal() >>> f.fromUnicode("1") Decimal('1') >>> f.fromUnicode("125.6") Decimal('125.6') >>> f.fromUnicode("1+0j") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidDecimalLiteral: Invalid literal for Decimal(): 1+0j >>> f.fromUnicode("1/2") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidDecimalLiteral: Invalid literal for Decimal(): 1/2 >>> f.fromUnicode(str(2**11234) + '.' + str(2**256)) ... # doctest: +ELLIPSIS Decimal('5901...936') >>> f.fromUnicode("not a number") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidDecimalLiteral: could not convert string to float: not a number Likewise for :meth:`fromBytes`:: >>> from zope.schema._field import Decimal >>> f = Decimal() >>> f.fromBytes(b"1") Decimal('1') >>> f.fromBytes(b"125.6") Decimal('125.6') >>> f.fromBytes(b"1+0j") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidDecimalLiteral: Invalid literal for Decimal(): 1+0j >>> f.fromBytes(b"1/2") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidDecimalLiteral: Invalid literal for Decimal(): 1/2 >>> f.fromBytes((str(2**11234) + '.' + str(2**256)).encode("ascii")) ... # doctest: +ELLIPSIS Decimal('5901...936') >>> f.fromBytes(b"not a number") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... InvalidDecimalLiteral: could not convert string to float: not a number N) r*r+r,rrrrrr!r r%r)r'rrs&6n OOE"??,-r)rceZdZfdZxZS)_ObjectsBeingValidatedcHtt| t|_yr0)rr$r7rids_being_validated)r&rs r'r7z_ObjectsBeingValidated.__init__s $d46#&5 r))r*r+r,r7rrs@r'r$r$s ))r)r$cLi}|tur|St|}|j}||vr|S|j| |j dD]a}||}t j |r tj |r.t||}|j|}|j|c |j||S#t$r} | ||<Yd} ~ d} ~ wt$r(} t| j|d||<Yd} ~ d} ~ wwxYw#|j|wxYw)a Validate that *value* conforms to the schema interface *schema*. All :class:`zope.schema.interfaces.IField` members of the *schema* are validated after being bound to *value*. (Note that we do not check for arbitrary :class:`zope.interface.Attribute` members being present.) :return: A `dict` mapping field names to `ValidationError` subclasses. A non-empty return value means that validation failed. T)allN)ridr&addrr r rrrr:r rrrremove) rKr=_validating_objectserrorsid_valuer&r4 attribute field_valueerrors r'get_schema_validation_errorsr2s+F  %yH-AA&& H% -LLTL* 8Dt I!!), 8**95")%"6K )u 5I&&{3 8& ""8, M# %$t ! 88 &&y$7t  8 ""8,sH0D-AC0D D CD D %DDD  DD#ct||}g}|r|s |j||||fS||fS#t$rY||fSwxYw)a Validate that *value* conforms to the schema interface *schema*. This includes checking for any schema validation errors (using `get_schema_validation_errors`). If that succeeds, and *validate_invariants* is true, then we proceed to check for any declared invariants. Note that this does not include a check to see if the *value* actually provides the given *schema*. :return: If there were any validation errors, either schema or invariant, return a two tuple (schema_error_dict, invariant_error_list). If there were no errors, returns a two-tuple where both members are empty. )r2validateInvariantsr)rKr=validate_invariantsschema_error_dictinvariant_errorss r'get_validation_errorsr8"sq"5VUC #4   % %e-= > / 00 / 00   / 00 s . ==cHeZdZdZdZeffd ZfdZfdZfdZ xZ S)ObjectzD Implementation of :class:`zope.schema.interfaces.IObject`. Nc |tur |j}tj|st ||j ||_|j dd|_tt|*di|y)a> Object(schema=, *, validate_invariants=True, **kwargs) Create an `~.IObject` field. The keyword arguments are as for `~.Field`. .. versionchanged:: 4.6.0 Add the keyword argument *validate_invariants*. When true (the default), the schema's ``validateInvariants`` method will be invoked to check the ``@invariant`` properties of the schema. .. versionchanged:: 4.6.0 The *schema* argument can be ommitted in a subclass that specifies a ``schema`` attribute. r5TNr%) r#rKr r rr*r\r5rr:r7)r&rKrrs r'r7zObject.__init__Lsd Y [[F$$V,!7 7 #%66*?#F  fd$*r*r)ctt| }|jtj d|j |S)Nz Must Provide)rr:rr]rPryrK)r&r_rs r'rzObject.getExtraDocLineshs:fd46 &77 DKK) * r)ctt| ||jj |s&t |j|j ||t|j||j\}}|s|rGt|j|z}t||j||j ||} |y#~~~~wxYwr0) rr:rrKr rrr8r5listvaluesrr*)r&r=r6r7r- exceptionrs r'rzObject._validatens fd%e,{{%%e,#DKK7LLe /D KK   $ $/ ++  0+22458HHF5 !  #"4/  !1$%s CC ct||j|}t||j}tt |||yr0)BeforeObjectAssignedEventr*rrrr:r)r&rr=eventrs r'rz Object.sets:*%Gu   fd.r)) r*r+r,rrKr#r7rrrrrs@r'r:r:Fs,F'+8 B / /r)r:ceZdZdZdZy)rBzDAn object is going to be assigned to an attribute on another object.c.||_||_||_yr0)rr4rI)r&rr4rIs r'r7z"BeforeObjectAssignedEvent.__init__s   r)N)r*r+r,rr7r%r)r'rBrBs Nr)rB)T)Lr __docformat__rrrrV threadingrmathr zope.eventrzope.interfacerrrr r zope.interface.interfacer zope.interface.interfacesr r zope.schema._bootstrapinterfacesrrrrrrrrrrrrrrrrrrr r!rr#r.rErNrPr}rrrrrrrrrrrrrrrrrr!rlocalr$r2r8r:rBr%r)r'rOsZ"  $$"&%30-CGH799:;:<JF>;3455<6 K ))2'.8D8Dvs Is l M M Iy I#L#LL2 \#9e##L7t75x5< \:&A75A7'A7H":" \:&Y7YY7'Y7x1Df1Dh;7;D4t4D O*x*D!(!J:.f:.z)Y__)6L5M6r!1HR/UR/j '()r)