9 f]ddlZddlZddlZddlmZmZmZmZmZej dZ dZ d#dZ Gdde ZGd d ZGd d ZGd dZGddZGddZGddeeZeje_GddZGddeZGddeZGddeZGddeZGd d!eZd"ZdS)$N)builder declarationsenumserrorsutilszfactory.generatecd|DS)z8Retrieve all FactoryMetaClass-derived bases from a list.c<g|]}t|t|S) issubclass BaseFactory).0bs B/var/www/equiseq/venv/lib/python3.11/site-packages/factory/base.py z%get_factory_bases..s' ; ; ;! 1k : : ;A ; ; ;r )basess rget_factory_basesrs ; ;u ; ; ;;rcT|D]$}t||rt||cS%|S)zAFind the first definition of an attribute according to MRO order.)hasattrgetattr)namerdefaultbases rresolve_attributersC'' 4   '4&& & & & ' Nrc.eZdZdZdZfdZdZxZS)FactoryMetaClassz4Factory metaclass for handling ordered declarations.c N|jjtjkr |jdi|S|jjtjkr |jdi|S|jjtjkr |jdi|Stj d |jj)zOverride the default Factory() syntax to call the default strategy. Returns an instance of the associated class. zUnknown Meta.strategy: {}Nr ) _metastrategyrBUILD_STRATEGYbuildCREATE_STRATEGYcreate STUB_STRATEGYstubrUnknownStrategyformatclskwargss r__call__zFactoryMetaClass.__call__s 9 !5 5 539&&v&& & Y 5#8 8 83:'''' ' Y 5#6 6 638%%f%% %()D)K)K "*$*$%% %rc~t|}|r |d}nd}|dd}|dd}td|}td|t} | } | |d<t ||||} | | ||||| S)aRecord attributes as a pattern for later instance construction. This is called when a new Factory subclass is defined; it will collect attribute declaration from the class definition. Args: class_name (str): the name of the class being created bases (list of class): the parents of the class being created attrs (str => obj dict): the attributes as defined in the class definition Returns: A new class rNMetaParamsr_options_class)meta base_meta base_factoryparams)rpoprFactoryOptionssuper__new__contribute_to_class) mcs class_namerattrsparent_factoriesr3 attrs_meta attrs_paramsr2 options_classr1 new_class __class__s rr8zFactoryMetaClass.__new__/s-U33  +A.LLLYYvt,, yy400 %gu55 )*:E>RR }gGGOO UE++    % !   rc^|jjr d|jzSd|jd|jjdS)Nz<%s (abstract)>< for >)rabstract__name__modelr*s r__str__zFactoryMetaClass.__str__Zs; 9  =$s|3 3>%%% )))))V=======rrc eZdZdZejZdS)BaseMetaTN)rHrLrMrGrr#r r rrrQrQasH$HHHrrQc&eZdZdZddZdZdZdS) OptionDefaultaThe default for an option. Attributes: name: str, the name of the option ('class Meta' attribute) value: object, the default value for the option inherit: bool, whether to inherit the value from the parent factory's `class Meta` when no value is provided checker: callable or None, an optional function used to detect invalid option values at declaration time FNc>||_||_||_||_dSN)rvalueinheritchecker)selfrrVrWrXs r__init__zOptionDefault.__init__qs"    rc|j}|jr|t||j|}|t||j|}|j||||SrU)rVrWrrrX)rYr1r2rVs rapplyzOptionDefault.applywse  < 9I1Ity%88E  D$)U33E < # LLu % % % rcP|jjd|jd|jd|jdS)N(, z , inherit=))rBrHrrVrWrYs rrKzOptionDefault.__str__s3 N # # # IIItzzz4<<<1 1r)FN)rHrLrMrNrZr\rKr rrrSrSfsP     11111rrSceZdZdZedZdZdZddZdZ dZ d Z dd Z d Z d ZdZdZdZdZdZdZdS)r6cd|_d|_i|_i|_i|_t j|_t j|_d|_ d|_ dSrU) factoryr3base_declarations parametersparameters_dependenciesrDeclarationSetpre_declarationspost_declarations_countercounter_referenceras rrZzFactoryOptions.__init__s_  !#')$ ' 6 8 8!(!7!9!9 !%rct|j}tj|jdD].\}}||||/|S)Nc|dSNrr items rz-FactoryOptions.declarations..s cghicjrgetter)dictrersort_ordered_objectsrfitemsupdateas_declarations)rYrerparams rrzFactoryOptions.declarationssx !788 5do6K6K6M6MVjVjkkk U UKD%  $ $U%:%:4AR%S%S T T T T  rc d}tddd|tdddtd tjdtd d dtd d dtd idgS)z"Provide the default value for all allowed fields. Custom FactoryOptions classes should override this method to update() its return value. ct|tr+tt|dtjdS)Nz is already a ) isinstancer TypeErrorreprFactoryrH)r1rVs ris_modelz7FactoryOptions._build_default_options..is_modelsK%!122 E{{{{G$4$46  rrINT)rWrXrGF)rWr inline_argsr excluderename)rSrr#)rYrs r_build_default_optionsz%FactoryOptions._build_default_optionss    '4x H H H *eU ; ; ; *e&;T J J J -T : : : )R 6 6 6 (B 5 5 5   rc  |i}n+dt|D}|D]p}t||jrJd|jz|||}||jdt||j|q|rLtd|j dd t| dS)NcDi|]\}}|d||S)_) startswith)rkvs r z2FactoryOptions._fill_from_meta..s@Q||C((1rzCan't override field %s.z'class Meta' for z got unknown attribute(s) ,) varsrwrrrr\r5setattrr~rdjoinsortedkeys)rYr1r2 meta_attrsoptionrVs r_fill_from_metazFactoryOptions._fill_from_metas# <JJ"4jj..00J 1133 . .FtV[11 [ [3MPVP[3[ [ [1LLy11E NN6; - - - D&+u - - - -  G)<<<&1B1B*C*C!D!D!DFGG G G GrNc||_||_|||||_|jd|_||_t|jj ddD][}t|ds|j |j j |j |j j\t|jD]%\}}|||r ||j |<&|xt%jt|dD]A\}}|ds't*j||j|<B||jt3j|j\|_|_dS)N)r1r2Trrc|dSror rps rrrz4FactoryOptions.contribute_to_class..s ]abc]drrsr)rdr3rget_model_classrIrG_get_counter_referencerlreversed__mro__rrerxrrfrrw_is_declarationrrvrrSimpleParameterwrap_check_parameter_dependenciesrparse_declarationsrirj) rYrdr1r2r3r4parentrrs rr9z"FactoryOptions.contribute_to_classs ( $)<<<))++ :  DM!%!!>t|3ABB788 < $*< <Krc|jdS|j|ur.t|j|_dS|j|jj|_dS)zInitialize our counter pointer. If we're the top-level factory, instantiate a new counter Otherwise, point to the top-level factory's counter. Nseq)rkrl_Counterrd_setup_next_sequence_initialize_counterras rrz"FactoryOptions._initialize_countersi = $ F  !T ) )$)J)J)L)LMMMDMMM  " 6 6 8 8 8 2;DMMMrc\||jS)aRetrieve a new sequence ID. This will call, in order: - next_sequence from the base factory, if provided - _setup_next_sequence, if this is the 'toplevel' factory and the sequence counter wasn't initialized yet; then increase it. )rrknextras r next_sequencezFactoryOptions.next_sequences*   """}!!###rFc||j|ur'|s%td|jd|jjd||jj}|j|dS)Nz-Can't reset a sequence on descendant factory z; reset sequence on z or use `force=True`.)rrl ValueErrorrdrrkreset)rYrVforces rreset_sequencezFactoryOptions.reset_sequences   """  ! - -e -*<<<!7!?!?!?ABB B =*2GGIIE E"""""rcFt|jjdifdDjD]!\}}|vr||<"t fdjD}|fS)z5Convert an attributes dict to a (args, kwargs) tuple.c\i|](\}}|jv|jv|tju%||)Sr )rrfrSKIP)rrrrYs rrz4FactoryOptions.prepare_arguments..%sO   Q $$$/)A)Aa|O`F`F` qF`F`F`rc3BK|]}|VdSrU)r5)rarg_namer+s r z3FactoryOptions.prepare_arguments..0sC   JJx       rr )rurd_adjust_kwargsrwrr5tupler)rY attributesold_namenew_nameargsr+s` @rprepare_argumentsz FactoryOptions.prepare_argumentssj!!,,66v66    #\\^^    #'+"3"3"5"5 8 8 Hh6!!#)::h#7#7x      ,      V|rc:|}|jjtjkr|jj|g|Ri|S|jjtjkr|jj|g|Ri|S|jjtj ksJtdi|SNr ) rrr rr!rd_buildr#_creater% StubObject)rYsteprr+rIs r instantiatezFactoryOptions.instantiate7s$$&& < E$8 8 8&4<&u>t>>>v>> > \ "e&; ; ;'4<'?????? ?<(E,?????'''' 'rcp|j||jjtjk|dS)N)r$results)rd_after_postgenerationrr rr#)rYrinstancers ruse_postgeneration_resultsz)FactoryOptions.use_postgeneration_resultsBsA ** <(E,AA +     rct|ttfrdStj|rdS|d S)a1Determines if a class attribute is a field value declaration. Based on the name and value of the class attribute, return ``True`` if it looks like a declaration of a default field value, ``False`` if it is private (name starts with '_') or a classmethod or staticmethod. FTr)r} classmethod staticmethodrget_builder_phaser)rYrrVs rrzFactoryOptions._is_declarationIsM ek<8 9 9 5  $U + + 4??3''''rc\tjttjt}|D]\}}t |t jrr||}|s7tjfd|D|<|xxt|zcc<|D]}|| |dD}|r2tj d|j dd ||S)z3Find out in what order parameters should be called.c3(K|] }|V dSrUr )rdep deep_revdepss rrz?FactoryOptions._check_parameter_dependencies..es(0\0\sc1B0\0\0\0\0\0\rc g|] \}}||v | Sr r )rr field_depss rrz@FactoryOptions._check_parameter_dependencies..ks'ZZZ+4tzGYGY$GYGYGYrzCyclic definition detected on z; Params around r_) collections defaultdictsetrwr}r Parameter get_revdepsunionaddrCyclicDefinitionErrorrdr) rYrfdepsr parameter field_revdepsrcyclicrs @rrz,FactoryOptions._check_parameter_dependenciesXsR#.s33 &s++)//11 ( (OD))\%;<< ( ) 5 5j A A $%(Y0\0\0\0\m0\0\0\%] T"T"""c-&8&88"""(((CIMM$''''[Z|/A/A/C/CZZZ  5..<<<6!2!2!2455 5 rc|jS)zExtension point for loading model classes. This can be overridden in framework-specific subclasses to hook into existing model repositories, for instance. )rIras rrzFactoryOptions.get_model_classrs zrc<d|jjd|jjdS)NrDrErF)rBrHrdras rrKzFactoryOptions.__str__zs% $ 7 7 79N9N9NOOrc t|SrU)strras r__repr__zFactoryOptions.__repr__}s4yyr)NNNNNF)rHrLrMrZpropertyrrrr9rrrrrrrrrrrKrr rrr6r6s4 & & &!!X!    .GGG. f f f fD    < < < $ $ $ # # # #2 ( ( (    ( ( (4PPPrr6c&eZdZdZdZdZddZdS)rzSimple, naive counter. Attributes: for_class (obj): the class this counter related to seq (int): the next value c||_dSrUr)rYrs rrZz_Counter.__init__s rc4|j}|xjdz c_|Sror)rYrVs rrz _Counter.nexts A  rrc||_dSrUr)rY next_values rrz_Counter.resets rN)r)rHrLrMrNrZrrr rrrrsP rrceZdZdZejZejZdZeZ dZ e ddZ e dZ e dZe dZe dd Ze d Ze d Ze d Ze d Ze dZe dZe dZe dZe dZe dZe dZe dZdS)r z9Factory base support for sequences, attributes and stubs.c*tjd)z3Would be called if trying to instantiate the class.z"You cannot instantiate BaseFactory)r FactoryError)r*rr+s rr8zBaseFactory.__new__s!"FGGGrNFc>|j||dS)a<Reset the sequence counter. Args: value (int or None): the new 'next' sequence value; if None, recompute the next value from _setup_next_sequence(). force (bool): whether to force-reset parent sequence counters in a factory inheritance chain. )rN)rr)r*rVrs rrzBaseFactory.reset_sequences%   e 44444rcdS)zSet up an initial sequence value for Sequence attributes. Returns: int: the first available ID to use for instances of this factory. rr rJs rrz BaseFactory._setup_next_sequences qrc |S)z-Extension point for custom kwargs adjustment.r r)s rrzBaseFactory._adjust_kwargss  rc|jjr*tjdt |jzt j|j||}|S)zgenerate the object. Args: params (dict): attributes to use for generating the object strategy: the strategy to use zCannot generate instances of abstract factory %(f)s; Ensure %(f)s.Meta.model is set and %(f)s.Meta.abstract is either not set or False.)f) rrGrrrurHr StepBuilderr")r*r r4rs r _generatezBaseFactory._generatesk 9  F%.04s|0D0D0DEFF F "39fh??zz||rcdS)a Hook called after post-generation declarations have been handled. Args: instance (object): the generated object create (bool): whether the strategy was 'build' or 'create' results (dict or None): result of post-generation declarations Nr )r*rr$rs rrz!BaseFactory._after_postgenerations  rc||i|S)aActually build an instance of the model_class. Customization point, will be called once the full set of args and kwargs has been computed. Args: model_class (type): the class for which an instance should be built args (tuple): arguments to use when building the class kwargs (dict): keyword arguments to use when building the class r r* model_classrr+s rrzBaseFactory._build{D+F+++rc||i|S)aActually create an instance of the model_class. Customization point, will be called once the full set of args and kwargs has been computed. Args: model_class (type): the class for which an instance should be created args (tuple): arguments to use when creating the class kwargs (dict): keyword arguments to use when creating the class r rs rrzBaseFactory._createrrc B|tj|S)zABuild an instance of the associated class, with overridden attrs.)rrr!r)s rr"zBaseFactory.builds}}U16:::rc >fdt|DS)zBuild a batch of instances of the given class, with overridden attrs. Args: size (int): the number of instances to build Returns: object list: the built instances c*g|]}jdiSr )r"rrr*r+s rrz+BaseFactory.build_batch.. s+999  ##F##999rranger*sizer+s` `r build_batchzBaseFactory.build_batchs):9999U4[[9999rc B|tj|S)zBCreate an instance of the associated class, with overridden attrs.)rrr#r)s rr$zBaseFactory.create s}}U2F;;;rc >fdt|DS)zCreate a batch of instances of the given class, with overridden attrs. Args: size (int): the number of instances to create Returns: object list: the created instances c*g|]}jdiSr)r$rs rrz,BaseFactory.create_batch..s+:::  $$V$$:::rrrs` `r create_batchzBaseFactory.create_batchs);::::eDkk::::rc B|tj|S)zRetrieve a stub of the associated class, with overridden attrs. This will return an object whose attributes are those defined in this factory's declarations or in the extra kwargs. )rrr%r)s rr&zBaseFactory.stubs}}U0&999rc >fdt|DS)zStub a batch of instances of the given class, with overridden attrs. Args: size (int): the number of instances to stub Returns: object list: the stubbed instances c*g|]}jdiSrr&rs rrz*BaseFactory.stub_batch..1s+888q""6""888rrrs` `r stub_batchzBaseFactory.stub_batch's)98888E$KK8888rc |tjtjtjfvsJt ||}|di|S)a9Generate a new instance. The instance will be created with the given strategy (one of BUILD_STRATEGY, CREATE_STRATEGY, STUB_STRATEGY). Args: strategy (str): the strategy to use for generating the instance. Returns: object: the generated instance r rr%r!r#r)r*r r+actions rgeneratezBaseFactory.generate3sJE/1EuG\]]]]]h''vrc |tjtjtjfvsJt |d|z}||fi|S)aGenerate a batch of instances. The instances will be created with the given strategy (one of BUILD_STRATEGY, CREATE_STRATEGY, STUB_STRATEGY). Args: strategy (str): the strategy to use for generating the instance. size (int): the number of instances to generate Returns: object list: the generated instances z%s_batchr)r*r rr+ batch_actions rgenerate_batchzBaseFactory.generate_batchDsQE/1EuG\]]]]]sJ$9:: |D++F+++rc R|r tjn tj}|j|fi|S)zGenerate a new instance. The instance will be either 'built' or 'created'. Args: create (bool): whether to 'build' or 'create' the instance. Returns: object: the generated instance )rr#r!r)r*r$r+r s rsimple_generatezBaseFactory.simple_generateVs3-3L5((8Ls|H/////rc T|r tjn tj}|j||fi|S)a<Generate a batch of instances. These instances will be either 'built' or 'created'. Args: size (int): the number of instances to generate create (bool): whether to 'build' or 'create' the instances. Returns: object list: the generated instances )rr#r!r)r*r$rr+r s rsimple_generate_batchz!BaseFactory.simple_generate_batches6-3L5((8L!s!(D;;F;;;rrrU)rHrLrMrNrr'UnsupportedStrategyr8r6rrkrrrrrrrrr"rr$r r&rrrrrr rrr r s(CC,O 4HHH N  EH 5 5 5[ 5[[[    [  , ,[ , , ,[ ,;;[; : :[ :<<[< ; ;[ ;::[: 9 9[ 9  [ ,,[," 0 0[ 0 < <[ < <   KCcIKK K{$$V$$$rc$|j|g|Ri|SrUrrs rrzBaseDictFactory._create$sz+7777777rNrHrLrMrNr.rrrr rrr)r)sx..%%[% 88[888rr)c(eZdZGddZdS) DictFactoryceZdZeZdS)DictFactory.MetaN)rHrLrMrurIr rrr.r6rr.NrHrLrMr.r rrr4r4<rr4cXeZdZdZGddZedZedZdS)BaseListFactoryzFactory for list-like classes.ceZdZdZdS)BaseListFactory.MetaTNr,r rrr.r=r-rr.ch|rtd|z|}||S)Nz1ListFactory %r does not support Meta.inline_args.)rvalues)r*rrr+r?s rrzBaseListFactory._buildsG  KCcIKK K {6"""rc$|j|g|Ri|SrUr0rs rrzBaseListFactory._creater1rNr2r rrr;r;sx((##[#88[888rr;c(eZdZGddZdS) ListFactoryceZdZeZdS)ListFactory.MetaN)rHrLrMlistrIr rrr.rDr7rr.Nr8r rrrBrBr9rrBcJtjdtdfd}|S)z|Force the use of a different strategy. This is an alternative to setting default_strategy in the class definition. z?use_strategy() is deprecated and will be removed in the future.) stacklevelc |j_|SrU)rr )klass new_strategys r wrapped_classz#use_strategy..wrapped_classs+  r)warningswarnDeprecationWarning)rKrLs` r use_strategyrPsH  MI  rrU)rloggingrMrrrrr getLoggerloggerrrtyperrQrSr6rr rAssociatedClassErrorrr#r)r4r;rBrPr rrrWs99999999999999  - . . <<< B=B=B=B=B=tB=B=B=J%%%%%%%% 1 1 1 1 1 1 1 1Fuuuuuuuuv([<[<[<[<[<[<[<[<|     k%5     &:(((((((( + + + + +' + + +88888g888"/ 88888g888*/ r