D7net
Home
Console
Upload
information
Create File
Create Folder
About
Tools
:
/
proc
/
3023067
/
root
/
usr
/
lib
/
python3.9
/
site-packages
/
ipalib
/
__pycache__
/
Filename :
parameters.cpython-39.pyc
back
Copy
a �ji3 � @ sV d Z ddlZddlZddlZddlZddlZddlZddlZddlm Z m Z ddl Z ddl m Z ddlZddlmZ ddlmZ ddlmZmZ ddlmZmZm Z dd lm Z m Z m Z m Z dd l!m"Z"m#Z#m$Z$ dd lm%Z%m&Z& dd l'm(Z(m)Z) dd l*m+Z+m,Z,m-Z- ddl'm.Z.m/Z/ ddl0m1Z1 ddl2m3Z3 ddl4m5Z5 dZ6dZ7e7 Z8dd� Z9e j:�rZe;Z<G dd� de�Z=dd� Z>e?� Z@dd� ZG d d � d e�ZAG d d � d eA�ZBG d d!� d!eB�ZCG d"d#� d#eA�ZDG d$d%� d%eD�ZEG d&d'� d'eD�ZFG d(d)� d)eA�ZGG d*d+� d+eG�ZHG d,d-� d-eA�ZIG d.d/� d/eA�ZJG d0d1� d1eG�ZKG d2d3� d3eK�ZLG d4d5� d5eK�ZMG d6d7� d7eA�ZNG d8d9� d9eN�ZOG d:d;� d;eN�ZPG d<d=� d=eN�ZQG d>d?� d?eA�ZRG d@dA� dAeK�ZSG dBdC� dCeH�ZTG dDdE� dEeA�ZUG dFdG� dGeK�ZVG dHdI� dIeA�ZWdJdK� ZXG dLdM� dMeA�ZYG dNdO� dOeA�ZZG dPdQ� dQeA�Z[e,ejIe5ej\j]iZ^dRdS� Z_G dTdU� dUeK�Z`dS )Va7 Parameter system for command plugins. A `Param` instance can be used to describe an argument or option that a command takes, or an attribute that a command returns. The `Param` base class is not used directly, but there are many subclasses for specific Python data types (like `Str` or `Int`) and specific properties (like `Password`). To create a `Param` instance, you must always provide the parameter *name*, which should be the LDAP attribute name if the parameter describes the attribute of an LDAP entry. For example, we could create an `Str` instance describing the user's last-name attribute like this: >>> from ipalib import Str >>> sn = Str('sn') >>> sn.name 'sn' When creating a `Param`, there are also a number of optional kwargs which which can provide additional meta-data and functionality. For example, every parameter has a *cli_name*, the name used on the command-line-interface. By default the *cli_name* is the same as the *name*: >>> sn.cli_name 'sn' But often the LDAP attribute name isn't user friendly for the command-line, so you can override this with the *cli_name* kwarg: >>> sn = Str('sn', cli_name='last') >>> sn.name 'sn' >>> sn.cli_name 'last' Note that the RPC interfaces (and the internal processing pipeline) always use the parameter *name*, regardless of what the *cli_name* might be. A `Param` also has two translatable kwargs: *label* and *doc*. These must both be `Gettext` instances. They both default to a place-holder `FixMe` instance, a subclass of `Gettext` used to mark a missing translatable string: >>> sn.label FixMe('sn') >>> sn.doc FixMe('sn') The *label* is a short phrase describing the parameter. It's used on the CLI when interactively prompting for values, and as a label for form inputs in the web-UI. The *label* should start with an initial capital. For example: >>> from ipalib import _ >>> sn = Str('sn', ... cli_name='last', ... label=_('Last name'), ... ) >>> sn.label Gettext('Last name', domain='ipa', localedir=None) The *doc* is a longer description of the parameter. It's used on the CLI when displaying the help information for a command, and as extra instruction for a form input on the web-UI. By default the *doc* is the same as the *label*: >>> sn.doc Gettext('Last name', domain='ipa', localedir=None) But you can override this with the *doc* kwarg. Like the *label*, the *doc* should also start with an initial capital and should not end with any punctuation. For example: >>> sn = Str('sn', ... cli_name='last', ... label=_('Last name'), ... doc=_("The user's last name"), ... ) >>> sn.doc Gettext("The user's last name", domain='ipa', localedir=None) Demonstration aside, you should always provide at least the *label* so the various UIs are translatable. Only provide the *doc* if the parameter needs a more detailed description for clarity. � N)�MAXINT�MININT)�x509)�_)� check_name)�ReadOnly�lock)�ConversionError�RequirementError�ValidationError)�PasswordMismatch�Base64DecodeError�CertificateFormatError�CertificateOperationError)� TYPE_ERROR�CALLABLE_ERROR� LDAP_GENERALIZED_TIME_FORMAT)�Gettext�FixMe)�json_serialize�validate_idna_domain)�load_der_x509_certificate�IPACertificate�default_backend)�strip_csr_header�apirepr)�kerberos)�DN)�DNSNamel �� l ���� c C s& | rdS t | tttjf�r dS dS d S )NFT)� isinstance�int�float�decimal�Decimal��value� r& �5/usr/lib/python3.9/site-packages/ipalib/parameters.py�_is_null� s r( c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � DefaultFroma� Derive a default value from other supplied values. For example, say you wanted to create a default for the user's login from the user's first and last names. It could be implemented like this: >>> login = DefaultFrom(lambda first, last: first[0] + last) >>> login(first='John', last='Doe') 'JDoe' If you do not explicitly provide keys when you create a `DefaultFrom` instance, the keys are implicitly derived from your callback by inspecting ``callback.func_code.co_varnames``. The keys are available through the ``DefaultFrom.keys`` instance attribute, like this: >>> login.keys ('first', 'last') The callback is available through the ``DefaultFrom.callback`` instance attribute, like this: >>> login.callback # doctest:+ELLIPSIS <function <lambda> at 0x...> >>> login.callback.func_code.co_varnames # The keys ('first', 'last') The keys can be explicitly provided as optional positional arguments after the callback. For example, this is equivalent to the ``login`` instance above: >>> login2 = DefaultFrom(lambda a, b: a[0] + b, 'first', 'last') >>> login2.keys ('first', 'last') >>> login2.callback.func_code.co_varnames # Not the keys ('a', 'b') >>> login2(first='John', last='Doe') 'JDoe' If any keys are missing when calling your `DefaultFrom` instance, your callback is not called and ``None`` is returned. For example: >>> login(first='John', lastname='Doe') is None True >>> login() is None True Any additional keys are simply ignored, like this: >>> login(last='Doe', first='John', middle='Whatever') 'JDoe' As above, because `DefaultFrom.__call__` takes only pure keyword arguments, they can be supplied in any order. Of course, the callback need not be a ``lambda`` expression. This third example is equivalent to both the ``login`` and ``login2`` instances above: >>> def get_login(first, last): ... return first[0] + last ... >>> login3 = DefaultFrom(get_login) >>> login3.keys ('first', 'last') >>> login3.callback.func_code.co_varnames ('first', 'last') >>> login3(first='John', last='Doe') 'JDoe' c G s� t |�s ttd|t|�f ��|| _t|�dkr\|j}|jd@ rHtd��|j d|j � | _ n|| _ | j D ](}t|�t urhtt dt |t|�f ��qht| � dS )z� :param callback: The callable to call when all keys are present. :param keys: Optional keys used for source values. �callbackr � z3callback: variable-length argument list not allowedN�keys)�callable� TypeErrorr �typer* �len�__code__�co_flags� ValueError� co_varnames� co_argcountr, �strr r )�selfr* r, Zfc�keyr& r& r' �__init__� s" � �zDefaultFrom.__init__c C s* t dd� | jD ��}d| jjd�|�f S )Nc s s | ]}t |�V qd S �N��repr��.0�kr& r& r' � <genexpr>� � z'DefaultFrom.__repr__.<locals>.<genexpr>�%s(%s)�, )�tupler, � __class__�__name__�join)r7 �argsr& r& r' �__repr__� s �zDefaultFrom.__repr__c sH t � fdd�| jD ��}d|v r$dS z | j|� W S tyB Y n0 dS )z� Call the callback if all keys are present. If all keys are present, the callback is called and its return value is returned. If any keys are missing, ``None`` is returned. :param kw: The keyword arguments. c 3 s | ]}� � |d �V qd S r: )�getr= ��kwr& r' r@ rA z'DefaultFrom.__call__.<locals>.<genexpr>N)rD r, r* � Exception)r7 rL Zvalsr& rK r' �__call__ s zDefaultFrom.__call__c C s | j S r: )r, �r7 r& r& r' �__json__ s zDefaultFrom.__json__N)rF � __module__� __qualname__�__doc__r9 rI rN rP r& r& r& r' r) � s Fr) c C s| t | �tur$ttdt| t | �f ��tddd�tddd�tddd�d�}| d }||v rl| dd� || fS | tddd�fS )a� Parse shorthand ``spec`` into to ``(name, kw)``. The ``spec`` string determines the parameter name, whether the parameter is required, and whether the parameter is multivalue according the following syntax: ====== ===== ======== ========== Spec Name Required Multivalue ====== ===== ======== ========== 'var' 'var' True False 'var?' 'var' False False 'var*' 'var' False True 'var+' 'var' True True ====== ===== ======== ========== For example, >>> parse_param_spec('login') ('login', {'required': True, 'multivalue': False}) >>> parse_param_spec('gecos?') ('gecos', {'required': False, 'multivalue': False}) >>> parse_param_spec('telephone_numbers*') ('telephone_numbers', {'required': False, 'multivalue': True}) >>> parse_param_spec('group+') ('group', {'required': True, 'multivalue': True}) :param spec: A spec string. �specF��required� multivalueT)�?�*�+���N)r/ r6 r. r �dict)rT �_map�endr& r& r' �parse_param_spec s � �r_ c C s t �| � | S r: )� __messages�add)�messager& r& r' r E s r c @ s� e Zd ZdZed�Zed�Zed�ZdZde dfde dfde e � fd e e fdfd e e fdfd e d fd e dfde dfde dfdedfde dfde dfde dfde dfde dfde e � fde e fdfde dfdedfdedfd e dfd e dfd e dfd e d ffZed d!� �Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!dJd>d?�Z"dKd@dA�Z#dLdBdC�Z$dDdE� Z%dFdG� Z&dHdI� Z'dS )M�Parama3 Base class for all parameters. Param attributes: ================= The behavior of Param class and subclasses can be controlled using the following set of attributes: - cli_name: option name in CLI - cli_short_name: one character version of cli_name - deprecated_cli_aliases: deprecated CLI aliases - label: very short description of the parameter. This value is used in when the Command output is printed to CLI or in a Command help - doc: parameter long description used in help - required: the parameter is marked as required for given Command - multivalue: indicates if the attribute is multivalued - primary_key: Command's parameter primary key is used for unique identification of an LDAP object and for sorting - normalizer: a custom function for Param value normalization - default_from: a custom function for generating default values of parameter instance - autofill: by default, only `required` parameters get a default value from the default_from function. When autofill is enabled, optional attributes get the default value filled too - query: this attribute is controlled by framework. When the `query` is enabled, framework assumes that the value is only queried and not inserted in the LDAP. Validation is then relaxed - custom parameter validators are skipped and only basic class validators are executed to check the parameter value - attribute: this attribute is controlled by framework and enabled for all LDAP objects parameters (unless parameter has "virtual_attribute" flag). All parameters with enabled `attribute` are being encoded and placed to an entry passed to LDAP Create/Update calls - include: a list of contexts where this parameter should be included. `Param.use_in_context()` provides further information. - exclude: a list of contexts where this parameter should be excluded. `Param.use_in_context()` provides further information. - flags: there are several flags that can be used to further tune the parameter behavior: * no_display (Output parameters only): do not display the parameter * no_create: do not include the parameter for crud.Create based commands * no_update: do not include the parameter for crud.Update based commands * no_search: do not include the parameter for crud.Search based commands * no_option: this attribute is not displayed in the CLI, usually because there's a better way of setting it (for example, a separate command) * virtual_attribute: the parameter is not stored physically in the LDAP and thus attribute `attribute` is not enabled * suppress_empty (Output parameters only): do not display parameter value when empty * ask_create: CLI asks for parameter value even when the parameter is not `required`. Applied for all crud.Create based commands * ask_update: CLI asks for parameter value even when the parameter is not `required`. Applied for all crud.Update based commands * req_update: The parameter is `required` in all crud.Update based commands * nonempty: This is an internal flag; a required attribute should be used instead of it. The value of this parameter must not be empty, but it may not be given at all. All crud.Update commands automatically convert required parameters to `nonempty` ones, so the value can be unspecified (unchanged) but cannot be deleted. * optional_create: do not require the parameter for crud.Create based commands * allow_mod_for_managed_permission: permission-mod allows changing the parameter for managed permissions - hint: this attribute is currently not used - alwaysask: when enabled, CLI asks for parameter value even when the parameter is not `required` - sortorder: used to sort a list of parameters for Command. See `Command.finalize()` for further information - confirm: if password, ask for confirmation Nzincorrect typezOnly one value is allowedF�cli_name�cli_short_nameZdeprecated_cli_aliases�label�docrV TrW Z primary_key� normalizer� default_from�autofill�queryZ attribute�include�exclude�flags�hintZ alwaysaskZ sortorder� Z option_group� cli_metavar� no_convert� deprecatedZconfirmc C s | j fS )z$The allowed datatypes for this Param)r/ rO r& r& r' � allowed_types� s zParam.allowed_typesc O sF t |�\}}t|� d|vr(|d |d< d|vr<|d |d< |�dd�r`| jdtd ff7 _n| jd| jd ff7 _|�d�}t|�r�t|t�s�t|�|d< | jD ]�\}}}|�|�} | d u�rr|tt fv �rt| �t tt t fv r�|| �} nt| �t u �r|| g�} |tu �r4t| ��s4t t|| t| �f ��n4t|ttf��rht| |��sht t||| t| �f ��| ||< q�|dvr�|�|d � q�|d �r�|d �r�|d | _n|| _n |d �r�|d | _n |d | _t|�| _| jd= | jd= || _d | jj| jf | _td d � | jD ���s J �t d d � | jD ���| j��s~t |�t dd � | jD �� } t d| jd�dd � t | �D ��f ��t|�| _ |�d�d u �r�| j|d< |�d�d u �r�| jj� � |d< |�d�d u �r�t | j�|d< |�d�d u �r�|d |d< g } | jD ]r\}}}|�||�} t | |��r<t!d|| jjf ��t"| || � d| } | d u�rt | | ��r| �#t$| | �� �qt| j%� d | j&| j'fv�r�t!d| jd| j&d| j'f ��t| �| _(|| _)| j*�r�d| _+n| j(| j) | _+| j+D ]"} t| ��s�t d | j| f ���q�| j,d u �s:t-| j,�d k�s:t!d | j| j,f ��t.| � d S ) NrV rW T�defaultri rU rZ rY rX z%s(%r)c s s | ]}t |t�V qd S r: )r r/ �r> �tr& r& r' r@ rA z!Param.__init__.<locals>.<genexpr>c s s | ]}|d V qdS �r Nr& rv r& r& r' r@ rA c s s | ]}|d V qdS rx r& rv r& r& r' r@ rA z %s: takes no such kwargs: %srC c s s | ]}t |�V qd S r: r; r= r& r& r' r@ rA rd rq rf rg z'kwarg %r conflicts with attribute on %sz_rule_%sz$%s: cannot have both %s=%r and %s=%rrl rm r& z"%s: rules must be callable; got %r� z5%s: cli_short_name can only be a single character: %s)/r_ r rJ �kwargsrD r/ r- r r) � frozenset�list�setr6 r. r r �pop� param_specr\ � _Param__kw�namerE rF �nice�allrt � issupersetrG �sorted�_Param__clonekw�upperr �hasattrr3 �setattr�append�getattrrd rl rm � class_rules�rulesrk � all_rulesre r0 r )r7 r� r� rL Z kw_from_specZdfr8 �kindru r% Zextrar� Z rule_name�ruler& r& r' r9 � s� ��� �� � �� � ��zParam.__init__c C s d| j jd�| �� �f S )zQ Return an expresion that could construct this `Param` instance. rB rC )rE rF rG �_Param__repr_iterrO r& r& r' rI P s �zParam.__repr__c c s� t | j�V | jD ] }|jV qt| j�D ]�}| j| }t|�rRt|d�rR|j}nLt|t �rft |�}n8t|t t t f�r�tt|��}n|dkr�t |�}nt|�}d||f V q*d S )NrF rd z%s=%s)r< r r� rF r� r� r- r� r r r6 rD r} r{ r r| )r7 r� r8 r% r& r& r' Z __repr_iterY s zParam.__repr_iterc K s. t |�r| jf i |��}n| �| �|��}|S )z$ One stop shopping. )r( � get_default�convert� normalize)r7 r% rL r& r& r' rN l s zParam.__call__c C s | j }|s| j}|S )z� Return the right name of an attribute depending on usage. Normally errors should use cli_name, our "friendly" name. When using the API directly or *attr return the real name. )rd r� )r7 r� r& r& r' �get_param_namev s zParam.get_param_namec c s@ t | j�D ]0}| j| }t|�r0t|d�r0|j}||fV q dS )zW Iterate through ``(key,value)`` for all kwargs passed to constructor. rF N)r� r� r- r� rF )r7 r8 r% r& r& r' rL � s zParam.kwc C s0 | j dur|j| j v S | jdur,|j| jvS dS )a� Return ``True`` if this parameter should be used in ``env.context``. If a parameter is created with niether the ``include`` nor the ``exclude`` kwarg, this method will always return ``True``. For example: >>> from ipalib.config import Env >>> param = Param('my_param') >>> param.use_in_context(Env(context='foo')) True >>> param.use_in_context(Env(context='bar')) True If a parameter is created with an ``include`` kwarg, this method will only return ``True`` if ``env.context`` is in ``include``. For example: >>> param = Param('my_param', include=['foo', 'whatever']) >>> param.include frozenset(['foo', 'whatever']) >>> param.use_in_context(Env(context='foo')) True >>> param.use_in_context(Env(context='bar')) False If a paremeter is created with an ``exclude`` kwarg, this method will only return ``True`` if ``env.context`` is not in ``exclude``. For example: >>> param = Param('my_param', exclude=['foo', 'whatever']) >>> param.exclude frozenset(['foo', 'whatever']) >>> param.use_in_context(Env(context='foo')) False >>> param.use_in_context(Env(context='bar')) True Note that the ``include`` and ``exclude`` kwargs are mutually exclusive and that at most one can be suppelied to `Param.__init__()`. For example: >>> param = Param('nope', include=['foo'], exclude=['bar']) Traceback (most recent call last): ... ValueError: Param('nope'): cannot have both include=frozenset(['foo']) and exclude=frozenset(['bar']) So that subclasses can add additional logic based on other environment variables, the entire `config.Env` instance is passed in rather than just the value of ``env.context``. NT)rl �contextrm )r7 �envr& r& r' �use_in_context� s 3 zParam.use_in_contextc C s | j r|durdS |S )a� Return a value safe for logging. This is used so that sensitive values like passwords don't get logged. For example: >>> p = Password('my_password') >>> p.safe_value(u'This is my password') u'********' >>> p.safe_value(None) is None True >>> s = Str('my_str') >>> s.safe_value(u'Some arbitrary value') u'Some arbitrary value' Nz********)�password�r7 r% r& r& r' � safe_value� s zParam.safe_valuec K s | j | jfi |��S )zD Return a new `Param` instance similar to this one. )� clone_renamer� )r7 � overridesr& r& r' �clone� s z Param.clonec K s | j || jfi |��S )zZ Return a new `Param` instance similar to this one, but named differently )� clone_retyperE )r7 r� r� r& r& r' r� � s zParam.clone_renamec K s, t | j�}|�|� ||g| j�R i |��S )z\ Return a new `Param` instance similar to this one, but of a different type )r\ r� �updater� )r7 r� �klassr� rL r& r& r' r� � s zParam.clone_retypec sF � j r t|�ttfvr |f}� j r8t� fdd�|D ��S � �|�S dS )a Normalize ``value`` using normalizer callback. For example: >>> param = Param('telephone', ... normalizer=lambda value: value.replace('.', '-') ... ) >>> param.normalize(u'800.123.4567') u'800-123-4567' If this `Param` instance was created with a normalizer callback and ``value`` is a unicode instance, the normalizer callback is called and *its* return value is returned. On the other hand, if this `Param` instance was *not* created with a normalizer callback, if ``value`` is *not* a unicode instance, or if an exception is caught when calling the normalizer callback, ``value`` is returned unchanged. :param value: A proposed value for this parameter. c 3 s | ]}� � |�V qd S r: )�_normalize_scalar�r> �vrO r& r' r@ s z"Param.normalize.<locals>.<genexpr>N)rW r/ rD r| r� r� r& rO r' r� � s �zParam.normalizec C s6 | j du r|S z | � |�W S ty0 | Y S 0 dS )zo Normalize a scalar value. This method is called once for each value in a multivalue. N)rh rM r� r& r& r' r� s zParam._normalize_scalarc st �j s�j� n �fdd�� t|�r&dS �jrlt|�ttfvrB|f}t� fdd�|D ��}t|�dkrhdS |S � |�S )a� Convert ``value`` to the Python type required by this parameter. For example: >>> scalar = Str('my_scalar') >>> scalar.type <type 'unicode'> >>> scalar.convert(43.2) u'43.2' (Note that `Str` is a subclass of `Param`.) All non-numeric, non-boolean values which evaluate to False will be converted to None. For example: >>> scalar.convert(u'') is None # An empty string True >>> scalar.convert([]) is None # An empty list True Likewise, they will be filtered out of a multivalue parameter. For example: >>> multi = Str('my_multi', multivalue=True) >>> multi.convert([1.5, '', 17, None, u'Hello']) (u'1.5', u'17', u'Hello') >>> multi.convert([None, u'']) is None # Filters to an empty list True Lastly, multivalue parameters will always return a ``tuple`` (assuming they don't return ``None`` as in the last example above). For example: >>> multi.convert(42) # Called with a scalar value (u'42',) >>> multi.convert([0, 1]) # Called with a list value (u'0', u'1') Note that how values are converted (and from what types they will be converted) completely depends upon how a subclass implements its `Param._convert_scalar()` method. For example, see `Str._convert_scalar()`. :param value: A proposed value for this parameter. c s t | t�r| S � �| �S r: )r �unicode�_convert_scalarr$ rO r& r' r� M s z Param.convert.<locals>.convertNc 3 s | ]}t |�s� |�V qd S r: )r( r� )r� r& r' r@ W s z Param.convert.<locals>.<genexpr>r )rr r� r( rW r/ rD r| r0 )r7 r% �valuesr& )r� r7 r' r� s . � z Param.convertc C s6 | j D ]}t||�r| S qt| jt| j�d��dS ��0 Convert a single scalar value. �r� �errorN)rt r r r� �ugettext� type_error)r7 r% �indexrw r& r& r' r� _ s zParam._convert_scalarc C s� |du r,| j s |r(d| jv r(t| jd��dS | jrFt| �� td�d��| jr�t |�t urpt t dt |t |�f ��t |�dk r�td��|D ]}| �|� q�n | �|� dS ) z� Check validity of ``value``. :param value: A proposed value for this parameter. :param supplied: True if this parameter was supplied explicitly. NZnonempty�r� zthis option is deprecatedr� r% ry z,value: empty tuple must be converted to None)rV rn r r� rs r r� r rW r/ rD r. r r0 r3 �_validate_scalar)r7 r% Zsuppliedr� r& r& r' �validatei s$ � � zParam.validatec C sh | j D ]}t||�r q6qtt| j| j|t|�f ��| jD ]&}|t|�}|d ur<t| � � |d��q<d S �Nr� ) rt r r. r r� r/ r� r� r r� )r7 r% r� rw r� r� r& r& r' r� � s � zParam._validate_scalarc K sN | j durH| j f i |��}|durHz| �| �|��W S tyF Y n0 | jS )a/ Return the static default or construct and return a dynamic default. (In these examples, we will use the `Str` and `Bytes` classes, which both subclass from `Param`.) The *default* static default is ``None``. For example: >>> s = Str('my_str') >>> s.default is None True >>> s.get_default() is None True However, you can provide your own static default via the ``default`` keyword argument when you create your `Param` instance. For example: >>> s = Str('my_str', default=u'My Static Default') >>> s.default u'My Static Default' >>> s.get_default() u'My Static Default' If you need to generate a dynamic default from other supplied parameter values, provide a callback via the ``default_from`` keyword argument. This callback will be automatically wrapped in a `DefaultFrom` instance if it isn't one already (see the `DefaultFrom` class for all the gory details). For example: >>> login = Str('login', default=u'my-static-login-default', ... default_from=lambda first, last: (first[0] + last).lower(), ... ) >>> isinstance(login.default_from, DefaultFrom) True >>> login.default_from.keys ('first', 'last') Then when all the keys needed by the `DefaultFrom` instance are present, the dynamic default is constructed and returned. For example: >>> kw = dict(last=u'Doe', first=u'John') >>> login.get_default(**kw) u'jdoe' Or if any keys are missing, your *static* default is returned. For example: >>> kw = dict(first=u'John', department=u'Engineering') >>> login.get_default(**kw) u'my-static-login-default' N)ri r� r� rM ru )r7 rL ru r& r& r' r� � s 4 zParam.get_defaultc C s |S r: r& r� r& r& r' �sort_key� s zParam.sort_keyc C s� i }| j D ]`\}}}|ttfv r"q tt| |�t�rHtt| |g ��||< q t| |d�}|d u r^q t|�||< q | jj |d< | j |d< | j j |d< |S )N� �classr� r/ ) rz r- r) r r� r{ r| r rE rF r� r/ )r7 Z json_dict�ar? Z_d�valr& r& r' rP � s zParam.__json__)N)N)N)(rF rQ rR rS r/ r r� � scalar_errorr� r6 r{ r �boolr- r) r r� rz �propertyrt r9 rI r� rN r� rL r� r� r� r� r� r� r� r� r� r� r� r� r� rP r& r& r& r' rc J sj R � 9! C =rc c @ sP e Zd ZdZeZed�Zej de e g d��fde e g d��ff Z d dd �Z dS ) �BoolzG A parameter for boolean values (stored in the ``bool`` type). zmust be True or False�truths)ry �1T�trueZTRUE� falsehoods)r �0FZfalseZFALSENc C s| t |�| jv r|S t|t�r$|�� }|| jv r2dS || jv r@dS t |�ttfv rdt | j t | j �d��t | j t | j �d��dS )r� TFr� N)r/ rt r r6 �lowerr� r� rD r| r r� r� r� r� �r7 r% r� r& r& r' r� � s �zBool._convert_scalar)N) rF rQ rR rS r� r/ r r� rc rz r{ r� r& r& r& r' r� � s �r� c s e Zd ZdZ� fdd�Z� ZS )�FlagaR A boolean parameter that always gets filled in with a default value. This `Bool` subclass forces ``autofill=True`` in `Flag.__init__()`. If no default is provided, it also fills in a default value of ``False``. Lastly, unlike the `Bool` class, the default must be either ``True`` or ``False`` and cannot be ``None``. For example: >>> flag = Flag('my_flag') >>> (flag.autofill, flag.default) (True, False) To have a default value of ``True``, create your `Flag` intance with ``default=True``. For example: >>> flag = Flag('my_flag', default=True) >>> (flag.autofill, flag.default) (True, True) Also note that creating a `Flag` instance with ``autofill=False`` will have no effect. For example: >>> flag = Flag('my_flag', autofill=False) >>> flag.autofill True c sj d|d< d|vrd|d< t |d �turH|d }ttdt|t |�f ��tt| �j|g|�R i |�� d S )NTrj ru F)r/ r� r. r �superr� r9 )r7 r� r� rL ru �rE r& r' r9 % s �z Flag.__init__)rF rQ rR rS r9 � __classcell__r& r& r� r' r� s r� c @ s e Zd ZdZddd�ZdS )�Numberz< Base class for the `Int` and `Decimal` parameters. Nc C s� t |�| jv r|S t |�tttfv rDz | � |�W S tyB Y n0 t |�ttfv rht| j t | j �d��t| j t | j �d��dS r� ) r/ rt r� r! r r3 rD r| r r� r� r� r� r� r& r& r' r� 6 s �zNumber._convert_scalar)N)rF rQ rR rS r� r& r& r& r' r� 1 s r� c s� e Zd ZdZeZefZed�Ze Z e Z e Z e Z e Z ejdeee �fdeee �ff Zedd� �Z� fdd�Zdd d �Zd d � Zdd� Z� ZS )�IntzF A parameter for integer values (stored in the ``int`` type). �must be an integer�minvalue�maxvaluec C sx t | �tjv r| S t | �tu r&t| �S t | �tu rld| v rFtt| ��S tjrbt� d| �rbt| d�S t| d�S t | ��d S )N�.z0[0-9]+� r ) r/ r� rt r! r r� �six�PY3�re�matchr3 r$ r& r& r' � convert_int[ s zInt.convert_intc s� t t| �j|g|�R i |�� | j| jkrV| jd urV| jd urVtd| j| j| jf ��| j| jk rztd| j� d| j� ���| j| jkr�td| j� d| j� ���d S )Nz2%s: minvalue > maxvalue (minvalue=%r, maxvalue=%r)z minvalue z* outside range of safe JSON integer limit z maxvalue ) r� r� r9 r� r� r3 r� �MIN_SAFE_INTEGER�MAX_SAFE_INTEGER�r7 r� r� rL r� r& r' r9 m s& �� �� ��z Int.__init__Nc C s: z t �|�W S ty4 t| �� t| j�d��Y n0 dS r� �r� r� r3 r r� r� r� r� r& r& r' r� � s �zInt._convert_scalarc C s4 t |t�sJ �|| jk r,|d�t| jd� S dS dS )�' Check min constraint. z must be at least %(minvalue)d�r� N)r r r� r\ �r7 r r% r& r& r' �_rule_minvalue� s �zInt._rule_minvaluec C s4 t |t�sJ �|| jkr,|d�t| jd� S dS dS )�' Check max constraint. zcan be at most %(maxvalue)d�r� N)r r r� r\ r� r& r& r' �_rule_maxvalue� s �zInt._rule_maxvalue)N)rF rQ rR rS r r/ rt r r� r r � MAX_UINT32r� r� rc rz � staticmethodr� r9 r� r� r� r� r& r& r� r' r� G s& � r� c s� e Zd ZdZejZed�Ze j dejdfdejdfde dfde dfd e d ff Z � fd d �Zd d� Zdd� Zdd� Zdd� Zdd� Zdd� Zd � fdd� Z� fdd �Z� ZS ) r# aj A parameter for floating-point values (stored in the ``Decimal`` type). Python Decimal type helps overcome problems tied to plain "float" type, e.g. problem with representation or value comparison. In order to safely transfer the value over RPC libraries, it is being converted to string which is then converted back to Decimal number. zmust be a decimal numberr� Nr� � precision� exponentialF� numberclass)z-Normalz+Zeroz+Normalc s� dD ]x}|� |�}|d u r qt|ttf�rzt�|�}W n: tyr } z"td||t|�f ��W Y d }~n d }~0 0 |||< qtt| �j |g|�R i |�� | j d ur�| j d ur�| j | j kr�td| j | j | j f ��| j d ur�| j dk r�td| j ��d S )N)r� r� ru z %s: cannot parse kwarg %s: %sz2%s: minvalue > maxvalue (minvalue=%s, maxvalue=%s)r z %s: precision must be at least 0)rJ r r6 r! r" r# rM r3 r� r9 r� r� r� r� )r7 r� r� rL Zkwparamr% �er� r& r' r9 � s6 �� � � ��zDecimal.__init__c C s8 t |�tju sJ �|| jk r0|d�t| jd� S dS dS )r� z must be at least %(minvalue)sr� N)r/ r" r# r� r\ r� r& r& r' r� � s �zDecimal._rule_minvaluec C s8 t |�tju sJ �|| jkr0|d�t| jd� S dS dS )r� zcan be at most %(maxvalue)sr� N)r/ r" r# r� r\ r� r& r& r' r� � s �zDecimal._rule_maxvaluec C s> |� � }|| jvr:t| �� td�t|d�| j�d� d��d S )NzWnumber class '%(cls)s' is not included in a list of allowed number classes: %(allowed)srC )�cls�allowedr� )Z number_classr� r r� r r\ rG )r7 r% r� r& r& r' �_enforce_numberclass� s ���z Decimal._enforce_numberclassc C s� t |�tju sJ �| jd ur|t�d�t| j� }z|�|�}W n: tjyz } z t| �� t |�d��W Y d }~n d }~0 0 |S )N� r� ) r/ r" r# r� r �quantize�DecimalExceptionr r� r� )r7 r% Z quantize_expr� r& r& r' �_enforce_precision� s � zDecimal._enforce_precisionc C s� t |�tju sJ �| js|z(||�� kr6|�t�d��n|�� }W n: tjyz } z t| � � t |�d��W Y d }~n d }~0 0 |S )Nry r� ) r/ r" r# r� Z to_integralr� r� r� r r� r� �r7 r% r� r& r& r' �_remove_exponent s ��� zDecimal._remove_exponentc C s" | � |� | �|�}| �|�}|S )z� This method is run in conversion and normalization methods to test that the Decimal number conforms to Parameter boundaries and then normalizes the value. )r� r� r� r� r& r& r' �_test_and_normalize s zDecimal._test_and_normalizec s~ t |ttf�rXzt�|�}W n: tjyV } z t| �� t|�d��W Y d }~n d }~0 0 t |tj�rn| � |�S t t| �� |�S r� ) r r6 r! r" r# r� r r� r� r� r� r� �r7 r% r� r� r� r& r' r� s � zDecimal._convert_scalarc s& t |tj�r| �|�S tt| ��|�S r: )r r" r# r� r� r� r� r� r& r' r� * s zDecimal._normalize_scalar)N)rF rQ rR rS r" r# r/ r r� rc rz r r� rD r9 r� r� r� r� r� r� r� r� r� r& r& r� r' r# � s& � r# c s\ e Zd ZdZejdedfdedfdedfdefdff ZdZdZ � fdd�Z d d � Z � Z S ) �Dataa+ Base class for the `Bytes` and `Str` parameters. Previously `Str` was as subclass of `Bytes`. Now the common functionality has been split into this base class so that ``isinstance(foo, Bytes)`` wont be ``True`` when ``foo`` is actually an `Str` instance (which is confusing). � minlengthN� maxlength�length�pattern_errmsgc s� t t| �j|g|�R i |�� | jd u sJ| jd u r<| jd u sJtd| j ��| jd urr| jdk rrtd| j| jf ��| jd ur�| jdk r�td| j| jf ��d | j| jfvr�| j| jkr�td| j| j| jf ��n | j| jkr�td| j| jf ��d S )Nz1%s: cannot mix length with minlength or maxlengthry z"%s: minlength must be >= 1; got %rz"%s: maxlength must be >= 1; got %rz6%s: minlength > maxlength (minlength=%r, maxlength=%r)z1%s: minlength == maxlength; use length=%d instead)r� r� r9 r� r� r� r3 r� r� r� r& r' r9 C s> ������ �� ��z Data.__init__c C sX t |�| jv sJ �| j�|�du rP| jr:| jt| jd� S |d�t| jd� S ndS dS )z2 Check pattern (regex) contraint. N)�patternz must match pattern "%(pattern)s")r/ rt r� r� � re_errmsgr\ r� r� r& r& r' � _rule_patternd s � zData._rule_pattern) rF rQ rR rS rc rz r r6 r� r� r9 r� r� r& r& r� r' r� 0 s � !r� c sf e Zd ZdZeZed�Zej defdff Z � fdd�Z dd� Z d d � Z d d � Z d� fd d� Z� ZS )�Bytesa( A parameter for binary data (stored in the ``str`` type). This class is named *Bytes* instead of *Str* so it's aligned with the Python v3 ``(str, unicode) => (bytes, str)`` clean-up. See: http://docs.python.org/3.0/whatsnew/3.0.html Also see the `Str` parameter. zmust be binary datar� Nc sX |� dd �d u rd | _nt�|d �| _|� dd �| _tt| �j|g|�R i |�� d S �Nr� r� )rJ r� �compiler� r� r� r9 r� r� r& r' r9 � s zBytes.__init__c C s: t |�tu sJ �t|�| jk r2|d�t| jd� S dS dS )�- Check minlength constraint. z$must be at least %(minlength)d bytes�r� N)r/ �bytesr0 r� r\ r� r& r& r' �_rule_minlength� s �zBytes._rule_minlengthc C s: t |�tu sJ �t|�| jkr2|d�t| jd� S dS dS )�- Check maxlength constraint. z"can be at most %(maxlength)d bytes�r� N)r/ r� r0 r� r\ r� r& r& r' �_rule_maxlength� s �zBytes._rule_maxlengthc C s: t |�tu sJ �t|�| jkr2|d�t| jd� S dS dS )�* Check length constraint. z must be exactly %(length)d bytes�r� N)r/ r� r0 r� r\ r� r& r& r' � _rule_length� s �zBytes._rule_lengthc s` t |t�rPzt�|�}W n6 ttfyN } ztt|�d��W Y d }~n d }~0 0 tt | �� |�S )N��reason) r r� �base64� b64decoder. r3 r r6 r� r� r� r� r� r& r' r� � s $zBytes._convert_scalar)N)rF rQ rR rS r� r/ r r� r� rz r9 r� r r r� r� r& r& r� r' r� t s � r� c s6 e Zd ZejZed�Zee e fZ d� fdd� Z � Z S )� Certificatezmust be a certificateNc s� t |t�r,z|�d�}W n ty* Y n0 t |t�r|zt�|�}W n6 ttfyz } zt t |�d��W Y d}~n d}~0 0 t |t�r�z t |�}W n2 ty� } zt t |�d��W Y d}~n d}~0 0 t t| ��|�S )z� :param value: either DER certificate or base64 encoded certificate :returns: bytes representing value converted to DER format �asciir N�r� )r r� �decode�UnicodeDecodeErrorr� r r r. r3 r r6 r r r� r r� r� r� r& r' r� � s $ $zCertificate._convert_scalar)N)rF rQ rR � crypto_x509r r/ r r� r r� r� rt r� r� r& r& r� r' r � s r c s@ e Zd ZejZed�Zejee fZ dd� Z d� fdd� Z � Z S )�CertificateSigningRequestz%must be a certificate signing requestc C sx z|� d� W n ty$ | Y S 0 t|�}z t�|�W S tjyr } z ttd�| d��W Y d}~n d}~0 0 dS )a� Tries to get the DER representation of whatever we receive as an input :param value: bytes instance containing something we hope is a certificate signing request :returns: base64-decoded representation of whatever we found in case input had been something else than DER or something which resembles DER, in which case we would just return input zutf-8znot a valid CSR: %sr N) r r r r r �binascii�Errorr r r� r& r& r' Z__extract_der_from_input� s �z2CertificateSigningRequest.__extract_der_from_inputNc s� t |t�r:z|�d�}W n ty8 ttd�d��Y n0 t |t�r�| �|�}ztj |t � d�}W n6 t y� } z ttd�| d��W Y d}~n d}~0 0 t t | ��|�S )a :param value: either DER csr, base64-encoded csr or an object implementing the cryptography.CertificateSigningRequest interface :returns: an object with the cryptography.CertificateSigningRequest interface r znot a valid CSRr )Zbackendz0Failure decoding Certificate Signing Request: %sN)r r� �encoder r r r� �2_CertificateSigningRequest__extract_der_from_inputr Zload_der_x509_csrr r3 r� r r� r� r� r& r' r� � s$ � �� z)CertificateSigningRequest._convert_scalar)N)rF rQ rR r r r/ r r� r� r� rt r r� r� r& r& r� r' r � s r c sz e Zd ZdZejdefdfdedff ZeZ e d�Z � fdd�Z dd d �Z d d � Zd d� Zdd� Zdd� Zdd� Z� ZS )�Stra1 A parameter for Unicode text (stored in the ``unicode`` type). This class is named *Str* instead of *Unicode* so it's aligned with the Python v3 ``(str, unicode) => (bytes, str)`` clean-up. See: http://docs.python.org/3.0/whatsnew/3.0.html Also see the `Bytes` parameter. r� N�noextrawhitespaceTzmust be Unicode textc s\ |� dd �d u rd | _nt�|d tj�| _|� dd �| _tt| �j|g|�R i |�� d S r� )rJ r� r� �UNICODEr� r� r r9 r� r� r& r' r9 - s z Str.__init__c C sl t |�| jv r|S t |�tttjfv r0| � |�S t |�ttfv rTt| j t | j �d��t| j t | j �d��dS r� ) r/ rt r r! r" r# rD r| r r� r� r� r� r� r& r& r' r� 5 s �zStr._convert_scalarc C sB t |�tu sJ �| jdu r dS t|�t|�� �kr:|d�S dS dS )z7 Do not allow leading/trailing spaces. FNz+Leading and trailing spaces are not allowed)r/ r� r r0 �stripr� r& r& r' �_rule_noextrawhitespaceB s zStr._rule_noextrawhitespacec C s: t |�tu sJ �t|�| jk r2|d�t| jd� S dS dS )r� z)must be at least %(minlength)d charactersr� N)r/ r� r0 r� r\ r� r& r& r' r� N s �zStr._rule_minlengthc C s: t |�tu sJ �t|�| jkr2|d�t| jd� S dS dS )r� z'can be at most %(maxlength)d charactersr� N)r/ r� r0 r� r\ r� r& r& r' r Z s �zStr._rule_maxlengthc C s: t |�tu sJ �t|�| jkr2|d�t| jd� S dS dS )r z%must be exactly %(length)d charactersr N)r/ r� r0 r� r\ r� r& r& r' r f s �zStr._rule_lengthc C s |� � S r: )r� r� r& r& r' r� r s z Str.sort_key)N)rF rQ rR rS r� rz r6 r� r� r/ r r� r9 r� r r� r r r� r� r& r& r� r' r s � r c s. e Zd ZdZ� fdd�Zd� fdd� Z� ZS )�IA5Strz# An IA5String per RFC 4517 c s" t t| �j|g|�R i |�� d S r: )r� r r9 r� r� r& r' r9 z s zIA5Str.__init__Nc sN t |t�r>|D ].}t|�dkrt| �� td�t|d� d��qtt| �� |�S )N� z&The character %(char)r is not allowed.)�charr� ) r r6 �ordr r� r r\ r� r r� )r7 r% r� r r� r& r' r� } s ��zIA5Str._convert_scalar)N)rF rQ rR rS r9 r� r� r& r& r� r' r u s r c sB e Zd ZdZejdefdfdedff ZdZd � fdd� Z � Z S ) �PasswordzE A parameter for passwords (stored in the ``unicode`` type). r� Nr FTc sJ t |ttf�r:t|�dkr:|\}}||kr6t| jd��|}tt| ��|�S )Nrp r� ) r rD r| r0 r r� r� r r� )r7 r% r� Zp1Zp2r� r& r' r� � s zPassword._convert_scalar)N) rF rQ rR rS r� rz r6 r� r� r� r� r& r& r� r' r � s �r c s< e Zd ZdZejdee� ff Z� fdd�Zdd� Z� Z S )�Enumz; Base class for parameters with enumerable values. r� c s� t dd� |�dt� �D ��|d< tt| �j|g|�R i |�� t| j�D ]>\}}t|�| j vrHd| j |f }t t || j|t|�f ��qHt | j�dk r�td| j ��d S )Nc S s g | ] }t |��qS r& )r6 r� r& r& r' � <listcomp>� rA z!Enum.__init__.<locals>.<listcomp>r� rq z %s values[%d]ry z$%s: list of values must not be empty)r6 rJ rD r� r r9 � enumerater� r/ rt r� r. r r0 r3 )r7 r� r� rL �ir� �nr� r& r' r9 � s ��z Enum.__init__c K sb || j vrZt| j �dkr0|d�t| j d d� S d�dd� | j D ��}|d�t|d � S nd S d S ) Nry zmust be '%(value)s'r r$ rC c s s | ]}d | V qdS )z'%s'Nr& )r> r% r& r& r' r@ � rA z$Enum._rule_values.<locals>.<genexpr>zmust be one of %(values)s)r� )r� r0 r\ rG )r7 r r% rL r� r& r& r' � _rule_values� s zEnum._rule_values) rF rQ rR rS rc rz rD r9 r" r� r& r& r� r' r � s � r c @ s e Zd ZdZeZdS )� BytesEnumzB Enumerable for binary data (stored in the ``str`` type). N�rF rQ rR rS r� r/ r& r& r& r' r# � s r# c @ s e Zd ZdZeZdS )�StrEnumay Enumerable for Unicode text (stored in the ``unicode`` type). For example: >>> enum = StrEnum('my_enum', values=(u'One', u'Two', u'Three')) >>> enum.validate(u'Two', 'cli') is None True >>> enum.validate(u'Four', 'cli') Traceback (most recent call last): ... ValidationError: invalid 'my_enum': must be one of 'One', 'Two', 'Three' Nr$ r& r& r& r' r% � s r% c @ s* e Zd ZdZeZefZejZddd�Z dS )�IntEnumzC Enumerable for integer data (stored in the ``int`` type). Nc C s: z t �|�W S ty4 t| �� t| j�d��Y n0 dS r� r� r� r& r& r' r� � s �zIntEnum._convert_scalar)N) rF rQ rR rS r r/ rt r� r� r� r& r& r& r' r& � s r& c @ s( e Zd ZdZeZddd�Zddd�ZdS ) �AnyzS A parameter capable of holding values of any type. For internal use only. Nc C s |S r: r& r� r& r& r' r� � s zAny._convert_scalarc C s0 | j D ]$}|t|�}|d urt| j|d��qd S r� )r� r� r r� )r7 r% r� r� r� r& r& r' r� � s zAny._validate_scalar)N)N)rF rQ rR rS �objectr/ r� r� r& r& r& r' r' � s r' c @ s. e Zd ZdZdZejdedfdedff ZdS )�FilezhText file parameter type. Accepts file names and loads their content into the parameter value. �r�stdin_if_missingFr N�rF rQ rR rS Z open_moder� rz r� r& r& r& r' r) � s �r) c @ s. e Zd ZdZdZejdedfdedff ZdS )� BinaryFilez Binary file parameter type �rbr+ Fr Nr, r& r& r& r' r- s �r- c s@ e Zd ZdZedddddgZejZed�Z d � fd d � Z � Z S ) �DateTimea� DateTime parameter type. Accepts LDAP Generalized time without in the following format: '%Y%m%d%H%M%SZ' Accepts subset of values defined by ISO 8601: '%Y-%m-%dT%H:%M:%SZ' '%Y-%m-%dT%H:%MZ' '%Y-%m-%dZ' Also accepts above formats using ' ' (space) as a separator instead of 'T'. Refer to the `man strftime` for the explanations for the %Y,%m,%d,%H.%M,%S. z%Y-%m-%dT%H:%M:%SZz%Y-%m-%dT%H:%MZz %Y-%m-%dZz%Y-%m-%d %H:%M:%SZz%Y-%m-%d %H:%MZzmust be datetime valueNc s� t |t�r�|dkr(tjjtjjd�}|S | jD ]0}ztj�||�}|W S ty\ Y q.0 q.t d�d� | j� }t | � � |d��t t| ��|�S )N�now)Ztzz(does not match any of accepted formats: rC r� )r r6 �datetimer0 �timezoneZutc�accepted_formats�strptimer3 r rG r r� r� r/ r� )r7 r% r� �timeZ date_formatr� r� r& r' r� 1 s" ��zDateTime._convert_scalar)N) rF rQ rR rS r r3 r1 r/ r r� r� r� r& r& r� r' r/ s �r/ c @ s� e Zd ZdZdd� Zdd� Zd!dd �Zd d � Zd d � Zdd� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zd d � Zd d � Zd S )"� AccessTimez� Access time parameter type. Accepts values conforming to generalizedTime as defined in RFC 4517 section 3.3.13 without time zone information. c C sx t |�dkrtd��|�� s$td��t|dd� �}|dk sD|dkrLtd��t|dd� �}|dk sl|dkrttd ��d S ) N� z&HHMM must be exactly 4 characters longzHHMM non-numericr rp � zHH out of range�; zMM out of range)r0 r3 � isnumericr )r7 rw ZhhZmmr& r& r' � _check_HHMMQ s zAccessTime._check_HHMMc C s> |� � r*t|�}|dk s |dkr:td��n|dvr:td��d S )Nry � z day of the week out of range)ZMonZTueZWedZThuZFriZSatZSunzinvalid day of the week)r: r r3 �r7 rw r% r& r& r' � _check_dotw] s zAccessTime._check_dotwry r7 c C s� |� � std��t|�}|dv r:|dk s0|dkr�td��n�|dv r\|dk sR|dkr�td��n^|dkr�|d d kr�|d d ks�|d d kr�|dk s�|d kr�td��n|dk s�|dkr�td��d S )Nz day of the month non-numeric)ry � � r< r� r� r+ ry � z day of the month out of range)r7 � � � � rp r7 r �d i� � � �r: r3 r )r7 rw � month_numZyearr% r& r& r' � _check_dotme s $ zAccessTime._check_dotmc C s4 |� � std��t|�}|dk s(|dkr0td��d S )Nz week of the month non-numericry rB z week of the month out of rangerI r= r& r& r' � _check_wotmw s zAccessTime._check_wotmc C s4 |� � std��t|�}|dk s(|dkr0td��d S )Nz week of the year non-numericry �4 z week of the year out of rangerI r= r& r& r' � _check_woty~ s zAccessTime._check_wotyc C s4 |� � std��t|�}|dk s(|dkr0td��d S )Nzday of the year non-numericry im z day of the year out of rangerI r= r& r& r' � _check_doty� s zAccessTime._check_dotyc C s4 |� � std��t|�}|dk s(|dkr0td��d S )Nzmonth number non-numericry r+ zmonth number out of rangerI r= r& r& r' �_check_month_num� s zAccessTime._check_month_numc C s� |� d�}|D ]l}|s td��|� d�}t|�dkr<td��|D ] }||� q@t|�dkrt|d �t|d �krtd��qd S )N�,�invalid time range�-rp r ry )�splitr3 r0 r )r7 rw Z check_funcZ intervalsr r� r� r& r& r' �_check_interval� s zAccessTime._check_intervalc C s2 || dkrt d��|d7 }| �|| | j� |S )N�dayzinvalid week specifierry )r3 rU r> �r7 �tsr� r& r& r' � _check_W_spec� s zAccessTime._check_W_specc C sh || dkr4| � ||d | j� | �||d �}n0|| dkr\|d7 }| � || | j� ntd��|S )N�weekry rp rV zinvalid month specifier)rU rL rY rK r3 rW r& r& r' � _check_M_spec� s zAccessTime._check_M_specc C s� || dkr8|d7 }| � || | j� | �||d �}nd|| dkrl| � ||d | j� | �||d �}n0|| dkr�|d7 }| � || | j� ntd��|S )NZmonthry rZ rp rV zinvalid year specifier)rU rP r[ rN rY rO r3 rW r& r& r' � _check_Y_spec� s zAccessTime._check_Y_specc C s� t |�tu sJ �t|�dvr$td��|�� s4td��| �|dd� � t|dd� �}t|dd� �}| �|dd� ||� t|�dkr�| �|dd� � n| �d |dd � � t|�d kr�t|dd � �}|dk s�|d kr�td ��d S )N)r� r+ � zincomplete generalized timeztime non-numericr7 rB r r� r+ z%s00r� r] �< zseconds out of range) r/ r� r0 r3 r: rP r rK r; )r7 rw Zyear_numrJ �sr& r& r' �_check_generalized� s z AccessTime._check_generalizedc C s( |� � }|d dkrzt|�dkr(td��| �|d � |d dkrJtd��| �|d � t|d �t|d �krxtd ��n�|d d k�r d }|d d kr�| �|d�}nD|d d kr�| �|d�}n*|d dkr�| �|d�}n|d dkr�d}|d u �rtd|d ��| �||d | j � ntd��d S )Nr �absoluter7 zDinvalid format, must be 'absolute generalizedTime ~ generalizedTime'ry rp �~z invalid time range separatorr? rR ZperiodicZyearlyZmonthlyZweeklyZdailyz0period must be yearly, monthy or daily, got '%s'z!time neither absolute or periodic) rT r0 r3 r` r r\ r[ rY rU r; )r7 r5 rX r� r& r& r' �_check� s0 zAccessTime._checkc C sr z| � |� W n^ tyH } z"t| �� |jd d��W Y d }~n.d }~0 tyl t| �� td�d��Y n0 d S )Nr r� zincomplete time value)rc r3 r r� rH � IndexErrorr� )r7 r r% r� r& r& r' �_rule_required� s * �zAccessTime._rule_requiredN)ry r7 )rF rQ rR rS r; r> rK rL rN rO rP rU rY r[ r\ r` rc re r& r& r& r' r6 J s r6 c @ s e Zd ZeZddd�ZdS )�DNParamNc C s� t |�| jv r|S t |�ttfv r6t| jt| j�d��z t|�}W n8 t yz } z t| � � t|�d��W Y d}~n d}~0 0 |S r� ) r/ rt rD r| r r� r� r� r rM r� )r7 r% r� Zdnr� r& r& r' r� � s � � zDNParam._convert_scalar)N)rF rQ rR r r/ r� r& r& r& r' rf � s rf c C s> t | t�r| S t| �tur6ttdttf| t| �f ��t| �S )a� Create an `Str` instance from the shorthand ``spec``. This function allows you to create `Str` parameters (the most common) from a convenient shorthand that defines the parameter name, whether it is required, and whether it is multivalue. (For the definition of the shorthand syntax, see the `parse_param_spec()` function.) If ``spec`` is an ``str`` instance, it will be used to create a new `Str` parameter, which will be returned. For example: >>> s = create_param('hometown?') >>> s Str('hometown?') >>> (s.name, s.required, s.multivalue) ('hometown', False, False) On the other hand, if ``spec`` is already a `Param` instance, it is returned unchanged. For example: >>> b = Bytes('cert') >>> create_param(b) is b True As a plugin author, you will not call this function directly (which would be no more convenient than simply creating the `Str` instance). Instead, `frontend.Command` will call it for you when it evaluates the ``takes_args`` and ``takes_options`` attributes, and `frontend.Object` will call it for you when it evaluates the ``takes_params`` attribute. :param spec: A spec string or a `Param` instance. rT )r rc r/ r6 r. r r )rT r& r& r' � create_param s ! �rg c sd e Zd ZdZeZed�Zej de dfde dff Z � fdd�Z d� fd d � Z d d � Z d d� Z� ZS )� DNSNameParamz� Domain name parameter type. :only_absolute a domain name has to be absolute (makes it absolute from unicode input) :only_relative a domain name has to be relative zmust be DNS name� only_absoluteF� only_relativec s< t t| �j|g|�R i |�� | jr8| jr8td| j ��d S )Nz(%s: cannot be both absolute and relative)r� rh r9 ri rj r3 r� r� r� r& r' r9 K s �zDNSNameParam.__init__Nc s~ t |t�rnz t|� W n8 tyN } z t| �� t|�d��W Y d }~n d }~0 0 t|�}| jrn|�� sn|� � }t t | �� |�S r� ) r r� r r3 r r� r ri � is_absoluteZ make_absoluter� rh r� r� r� r& r' r� Q s � z DNSNameParam._convert_scalarc C s | j r|�� s|d�S d S d S )Nzmust be absolute)ri rk r� r& r& r' �_rule_only_absolute_ s z DNSNameParam._rule_only_absolutec C s | j r|�� r|d�S d S d S )Nzmust be relative)rj rk r� r& r& r' �_rule_only_relativee s z DNSNameParam._rule_only_relative)N)rF rQ rR rS r r/ r r� rc rz r� r9 r� rl rm r� r& r& r� r' rh < s � rh c @ s e Zd ZdZeZed�ZdS )�Dictz% A parameter for dictionary. zmust be dictionaryN)rF rQ rR rS r\ r/ r r� r& r& r& r' rn l s rn c sV e Zd ZdZejZed�Ze j de dff Z e dd� �Z d � fdd � Zd d � Z� ZS ) � Principalz! Kerberos principal name zmust be Kerberos principal�require_serviceFc C s | j tfS r: )r/ r� rO r& r& r' rt � s zPrincipal.allowed_typesNc sZ t |t�rJzt�|�}W n0 tyH t| �� td�t|d� d��Y n0 t t| �� |�S )Nz Malformed principal: '%(value)s'r$ r� ) r r� r ro r3 r r� r r\ r� r� r� r� r& r' r� � s �� zPrincipal._convert_scalarc C s$ | j r |js t| �� |d�d��d S )Nz Service principal is requiredr� )rp Z is_servicer r� r� r& r& r' �_rule_require_service� s �z Principal._rule_require_service)N)rF rQ rR rS r ro r/ r r� rc rz r� r� rt r� rq r� r& r& r� r' ro u s � ro c C s� g }t � }| �� tjjf| �� tjjfg}|D ]�\}}|D ]�}|j|v rJq:|�|j� t |t �sbq:|j rrtjj }n|j }tdd� |jD ��}t |t�r�|tjf7 }tj| } |jr�tj| } |�tj|j||| d�� q:q.tj|tjtjtjf d�} | S )z�Create an inspect.Signature for a command :param command: ipa plugin instance (server or client) :return: inspect.Signature instance c s s | ]}t �||�V qd S r: )� _map_typesrJ rv r& r& r' r@ � s z#create_signature.<locals>.<genexpr>)ru � annotation)Zreturn_annotation) r} �get_args�inspectZ ParameterZPOSITIONAL_OR_KEYWORDZ get_optionsZ KEYWORD_ONLYr� ra r rc rV �emptyru rD rt rh r� Z text_type�typing�UnionrW �Listr� Z Signaturern �Textr' ) ZcommandZsignature_params�seenZ args_optionsZ ipaparamsr� Zipaparamru rt �annZ signaturer& r& r' �create_signature� sB � � ���r} c sR e Zd ZdZeZefZdZej de dfde dfde dff Z d � fd d � Z � Z S ) � SerialNumberz-Certificate serial number parameter type l r� ry r� �( r� Nc s� t t| ��|� |�d�r,t| jtd�d��|�� s�|�� �d�r�zt |dd � d� W q� t y� t| jttd��d��Y q�0 nt| jttd��d��|d kr�t| jtd �d��d S ) NrS zmust be at least 0r� �0xrp � zinvalid valid hexr� r� zinvalid serial number 0) r� r~ r� � startswithr r� r �isdigitr� r r3 r� r� r& r' r� � s0 � ���� �z SerialNumber._validate_scalar)N) rF rQ rR rS r6 r/ rt Z MAX_VALUErc rz r r� r� r& r& r� r' r~ � s �r~ )arS r� r" r r r1 ru rw Z xmlrpc.clientr r r� Z cryptographyr r Zdns.nameZdnsZ ipalib.textr r� Z ipalib.baser Zipalib.plugabler r Z ipalib.errorsr r r r r r r Zipalib.constantsr r r r r Z ipalib.utilr r Z ipalib.x509r r r r r Z ipapythonr Z ipapython.dnr Zipapython.dnsutilr r� r� r� r( r� r6 r� r) r_ r} r` rc r� r� r� r� r# r� r� r r r r r r r# r% r& r' r) r- r/ r6 rf rg rh rn ro r� �Namerr r} r~ r& r& r& r' �<module> s� R |- !!*\ DG$:\! 5 3*0 %� 7