B `O@sddlZddlZddlZddlZddlZddlmZddlmZm Z m Z ddl m Z ddl mZddlmZmZGdddZGd d d ZGd d d Zdd dZddZdddZee GdddZddZdS)N) implementer)ConfigurationConflictErrorConfigurationErrorConfigurationExecutionError) IActionInfo)undefer)is_nonstr_iterreraisec@sHeZdZeddZdddZdd Zd d ZeeeZeZ d d Z dS)ActionConfiguratorMixincCs.|j}|s*|jr|jd}ntdddd}|S)Nr)info_ainfo ActionInfo)selfr r^/home/kop/projects/devel/pgwui/test_venv/lib/python3.7/site-packages/pyramid/config/actions.py action_infos  z#ActionConfiguratorMixin.action_infoNrrc Kst|s t|dkri}|j}|j} |js.d}|r|z:t||dk rV|||x|D]} | |j| q\WWd| Xn2|} | t |||||| |j |d|j jf| dS)aRegister an action which will be executed when :meth:`pyramid.config.Configurator.commit` is called (or executed immediately if ``autocommit`` is ``True``). .. warning:: This method is typically only used by :app:`Pyramid` framework extension authors, not by :app:`Pyramid` application developers. The ``discriminator`` uniquely identifies the action. It must be given, but it can be ``None``, to indicate that the action never conflicts. It must be a hashable value. The ``callable`` is a callable object which performs the task associated with the action when the action is executed. It is optional. ``args`` and ``kw`` are tuple and dict objects respectively, which are passed to ``callable`` when this action is executed. Both are optional. ``order`` is a grouping mechanism; an action with a lower order will be executed before an action with a higher order (has no effect when autocommit is ``True``). ``introspectables`` is a sequence of :term:`introspectable` objects (or the empty sequence if no introspectable objects are associated with this action). If this configurator's ``introspection`` attribute is ``False``, these introspectables will be ignored. ``extra`` provides a facility for inserting extra keys and values into an action dictionary. Nr) discriminatorcallableargskworderr includepathintrospectables)hashAssertionError autocommitrZ introspectionbeginrregister introspectorendupdatedictr action_stateaction) rrrrrrrextrarrintrospectabler$rrrr$s8,     zActionConfiguratorMixin.actioncCs6|j}y |j}Wn tk r0t}||_YnX|S)N)registryr#AttributeError ActionState)rr'staterrr_get_action_statets  z)ActionConfiguratorMixin._get_action_statecCs ||j_dS)N)r'r#)rr*rrr_set_action_state}sz)ActionConfiguratorMixin._set_action_statecCs4|z|jj|jdWd|Xt|_dS)a Commit any pending configuration actions. If a configuration conflict is detected in the pending configuration actions, this method will raise a :exc:`ConfigurationConflictError`; within the traceback of this error will be information about the source of the conflict, usually including file names and line numbers of the cause of the configuration conflicts. .. warning:: You should think very carefully before manually invoking ``commit()``. Especially not as part of any reusable configuration methods. Normally it should only be done by an application author at the end of configuration in order to override certain aspects of an addon. )rN)rr#execute_actionsrr r))rrrrcommits  zActionConfiguratorMixin.commit)NrNrr) __name__ __module__ __qualname__propertyrr$r+r,r#Z_ctxr.rrrrr s  O  r c@s0eZdZddZddZd dd Zdd d ZdS)r)cCsg|_t|_dS)N)actionsset _seen_files)rrrr__init__szActionState.__init__cCs||jkrdS|j|dS)aoCheck whether a callable needs to be processed. The ``spec`` refers to a unique identifier for the callable. Return True if processing is needed and False otherwise. If the callable needs to be processed, it will be marked as processed, assuming that the caller will process the callable if it needs to be processed. FT)r5add)rspecrrr processSpecs  zActionState.processSpecNrrc Ks>|dkr i}| } | t||||||||d|j| dS)zKAdd an action with the given discriminator, callable, and argumentsN)rrrrrr rr)r!r"r3append) rrrrrrrr rr%r$rrrr$s zActionState.actionTc Cs,zg}g}tg}t}x|jrB||jt|j|d}g|_t|d}|dkrVP|d}|d} |d} |d} |dd} y|dk r|| | WnDtk rt \} }}zt t t | || |Wd~ ~~XYnX|dk rx| D]}| || qW| |qW||_|S|r&g|_XdS) aJExecute the configuration actions This calls the action callables after resolving conflicts For example: >>> output = [] >>> def f(*a, **k): ... output.append(('f', a, k)) >>> context = ActionState() >>> context.actions = [ ... (1, f, (1,)), ... (1, f, (11,), {}, ('x', )), ... (2, f, (2,)), ... ] >>> context.execute_actions() >>> output [('f', (1,), {}), ('f', (2,), {})] If the action raises an error, we convert it to a ConfigurationExecutionError. >>> output = [] >>> def bad(): ... bad.xxx >>> context.actions = [ ... (1, f, (1,)), ... (1, f, (11,), {}, ('x', )), ... (2, f, (2,)), ... (3, bad, (), {}, (), 'oops') ... ] >>> try: ... v = context.execute_actions() ... except ConfigurationExecutionError, v: ... pass >>> print(v) exceptions.AttributeError: 'function' object has no attribute 'xxx' in: oops Note that actions executed before the error still have an effect: >>> output [('f', (1,), {}), ('f', (2,), {})] The execution is re-entrant such that actions may be added by other actions with the one caveat that the order of any added actions must be equal to or larger than the current action. >>> output = [] >>> def f(*a, **k): ... output.append(('f', a, k)) ... context.actions.append((3, g, (8,), {})) >>> def g(*a, **k): ... output.append(('g', a, k)) >>> context.actions = [ ... (1, f, (1,)), ... ] >>> context.execute_actions() >>> output [('f', (1,), {}), ('g', (8,), {})] )r*Nrrrr rr)iterConflictResolverStater3extendresolveConflictsnextget Exceptionsysexc_infor rrr:)rclearrZ all_actionsZexecuted_actionsZ action_iterZconflict_stater$rrrr rtvtbr&rrrr-sL@        zActionState.execute_actions)NrNrrNr)TN)r/r0r1r6r9r$r-rrrrr)s r)c@seZdZddZdS)r<cCsi|_g|_d|_d|_dS)Nr)resolved_ainfosremaining_actions min_orderstart)rrrrr6NszConflictResolverState.__init__N)r/r0r1r6rrrrr<Msr<c#s|dkrt}|jt||j}dd}dd}tt||jd|d}xt||D]\}g}i}|j dk rވ|j krd |j g}x>|D]6\} } x,t | d  d D]} |d | qWqWtd |xX|D]P\} } | | f} t| d } | | d <| dkr|| q|| g}|| qWi}x8|D]*\} }fd d}|j|d|d|dd} }| \}} |j| }|dk r|\}}|d|d }}| d}|dt||ks||kr|| |g}|| d n || | d| d }}xV|D]N\}} | d}|dt||ksP||kr || |g}|| d q WqHW|rt|xXt|tddD]B\} } | d|_ | d|_|j| | | f|j| d <| VqWqZWdS)aResolve conflicting actions Given an actions list, identify and try to resolve conflicting actions. Actions conflict if they have the same non-None discriminator. Conflicting actions can be resolved if the include path of one of the actions is a prefix of the includepaths of the other conflicting actions and is unequal to the include paths in the other conflicting actions. Actions are resolved on a per-order basis because some discriminators cannot be computed until earlier actions have executed. An action in an earlier order may execute successfully only to find out later that it was overridden by another action with a smaller include path. This will result in a conflict as there is no way to revert the original action. ``state`` may be an instance of ``ConflictResolverState`` that can be used to resume execution and resolve the new actions against the list of executed actions from a previous call. NcSs|\}}|dpd|fS)Nrrr)rFnrrr orderandpos}sz%resolveConflicts..orderandposcSs|\}}|dpdS)Nrrr)rFrLrrr orderonlysz#resolveConflicts..orderonly)rK)keyz^Actions were added to order={} after execution had moved on to order={}. Conflicting actions: r  z rcs |dd|d}}||fS)Nrrr)ainfopathi)rrrbypathsz resolveConflicts..bypathrrQrr)r<rIr=normalize_actionssorted enumeraterK itertoolsgroupbyrJformatstrrstripsplitr:rjoinr setdefaultitemssortrHr@lenroperator itemgetterremove)r3r*rMrNZsactionsZ actiongroupoutputuniquerrTr$linerRrL conflictsZainfosrUrest_Z prev_ainfoZpactionZbasepathZbaseinforr)rrr>`sr                r>cCs2g}x(|D] }t|ts t|}||q W|S)z3Convert old-style tuple actions to new-style dicts.) isinstancer"expand_action_tupler:)r3resultrFrrrrVs   rVrc Cs$|dkr i}t||||||||dS)N)rrrrrr rr)r")rrrrrr rrrrrrps rpc@seZdZddZddZdS)rcCs||_||_||_||_dS)N)filerjfunctionsrc)rrrrjrsrtrrrr6szActionInfo.__init__cCs2|jd}ddd|D}d|j|j|fS)NrPcss|]}d|VqdS)z %sNr).0xrrr sz%ActionInfo.__str__..zLine %s of file %s: %s)rtr^r_rjrr)rZsrclinesrtrrr__str__s zActionInfo.__str__N)r/r0r1r6rxrrrrrsrcs,fdd}tdr"t||_|S)zWrapper to provide the right conflict info report data when a method that calls Configurator.action calls another that does the same. Not a documented API but used by some external systems.cs|jdkrg|_|dd}|ddd}t|rHt|dkrHt|}|dkry.wrapperr/)hasattr functoolsupdate_wrapperZ __docobj__)rrr)rr action_methods    r)N)NrNrNrr)rrYrdrBrZzope.interfacerZpyramid.exceptionsrrrZpyramid.interfacesrZpyramid.registryrZ pyramid.utilrr r r)r<r>rVrprrrrrrs4    0