HEX
Server: LiteSpeed
System: Linux s1049.use1.mysecurecloudhost.com 4.18.0-477.27.2.lve.el8.x86_64 #1 SMP Wed Oct 11 12:32:56 UTC 2023 x86_64
User: xedaptot (3356)
PHP: 8.3.31
Disabled: NONE
$ pwd: /proc/thread-self/root/lib/python3.6/site-packages/ipalib/__pycache__/
Upload Files
File: //proc/thread-self/root/lib/python3.6/site-packages/ipalib/__pycache__/parameters.cpython-36.pyc
3

�d[e-�@s>dZddlZddlZddlZddlZddlZddlZddlmZm	Z	ddl
Z
ddlmZ
ddlZddlmZddlmZddlmZmZddlmZmZmZdd	lmZmZmZmZdd
l m!Z!m"Z"m#Z#ddlm$Z$m%Z%ddl&m'Z'm(Z(dd
l)m*Z*m+Z+m,Z,ddl&m-Z-m.Z.ddl/m0Z0ddl1m2Z2ddl3m4Z4dWZ5dYZ6e6Z7dd�Z8e
j9�rRe:Z;Gdd�de�Z<dd�Z=e>�Z?dd�ZGdd�de�Z@Gd d!�d!e@�ZAGd"d#�d#eA�ZBGd$d%�d%e@�ZCGd&d'�d'eC�ZDGd(d)�d)eC�ZEGd*d+�d+e@�ZFGd,d-�d-eF�ZGGd.d/�d/e@�ZHGd0d1�d1e@�ZIGd2d3�d3eF�ZJGd4d5�d5eJ�ZKGd6d7�d7eJ�ZLGd8d9�d9e@�ZMGd:d;�d;eM�ZNGd<d=�d=eM�ZOGd>d?�d?eM�ZPGd@dA�dAe@�ZQGdBdC�dCeJ�ZRGdDdE�dEeG�ZSGdFdG�dGe@�ZTGdHdI�dIeJ�ZUGdJdK�dKe@�ZVdLdM�ZWGdNdO�dOe@�ZXGdPdQ�dQe@�ZYGdRdS�dSe@�ZZe+e
jHe4ej[j\iZ]dTdU�Z^dS)Za7
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)�DNSName�� ��5cCs&|rdSt|tttjf�rdSdSdS)NFT)�
isinstance�int�float�decimal�Decimal)�value�r)� /usr/lib/python3.6/parameters.py�_is_null�s
r+c@s0eZdZdZdd�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'
    cGs�t|�sttd|t|�f��||_t|�dkr\|j}|jd@rHtd��|j	d|j
�|_n||_x2|jD](}t|�tk	rjtt
dt|t|�f��qjWt|�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/�strrr)�selfr-r/Zfc�keyr)r)r*�__init__�s
zDefaultFrom.__init__cCs*tdd�|jD��}d|jjdj|�fS)Ncss|]}t|�VqdS)N)�repr)�.0�kr)r)r*�	<genexpr>�sz'DefaultFrom.__repr__.<locals>.<genexpr>z%s(%s)z, )�tupler/�	__class__�__name__�join)r:�argsr)r)r*�__repr__�szDefaultFrom.__repr__csHt�fdd�|jD��}d|kr$dSy
|j|�Stk
rBYnXdS)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.
        c3s|]}�j|d�VqdS)N)�get)r>r?)�kwr)r*r@sz'DefaultFrom.__call__.<locals>.<genexpr>N)rAr/r-�	Exception)r:rH�valsr))rHr*�__call__�s	
zDefaultFrom.__call__cCs|jS)N)r/)r:r)r)r*�__json__szDefaultFrom.__json__N)rC�
__module__�__qualname__�__doc__r<rFrKrLr)r)r)r*r,�s
Er,cCs|t|�tk	r$ttdt|t|�f��tddd�tddd�tddd�d�}|d}||krl|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)�?�*�+rN���rV)r2r9r1r�dict)rPZ_map�endr)r)r*�parse_param_specs

rYcCstj|�|S)N)�
__messages�add)�messager)r)r*rDs
rc@s�eZdZdZed�Zed�Zed�ZdZde	dfde	dfde
e
�fd	e	efdfd
e	efdfdedfd
edfdedfde
dfdedfdedfdedfdedfde
dfde
dfde
e
�fde	efdfdedfdedfdedfde	dfdedfdedfdedffZed d!��Zd"d#�Zd$d%�Zd&d'�Zd(d)�Zd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�Zd4d5�Zd6d7�Zd8d9�Zd: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�docrQTrRZprimary_key�
normalizer�default_from�autofill�queryZ	attribute�include�exclude�flagsZhintZ	alwaysaskZ	sortorderr!Zoption_group�cli_metavar�
no_convert�
deprecatedZconfirmcCs|jfS)z$The allowed datatypes for this Param)r2)r:r)r)r*�
allowed_types�szParam.allowed_typescOsXt|�\}}t|�d|kr(|d|d<d|kr<|d|d<|jdd�r`|jdtdff7_n|jd|jdff7_|jd�}t|�r�t|t�r�t|�|d<x�|jD]�\}}}|j|�}	|	dk	�rz|tt	fk�rt|	�t
ttt	fkr�||	�}	nt|	�tk�r||	g�}	|tk�r:t|	��r:t
t||	t|	�f��n6t|ttf��rpt|	|��rpt
t|||	t|	�f��|	||<q�|dkr�|j|d�q�W|d�r�|d�r�|d|_n||_n |d�r�|d|_n
|d|_t|�|_|jd=|jd=||_d	|jj|jf|_td
d�|jD���s(t�tdd�|jD��j|j��s�t|�td
d�|jD��}
t
d|jdjdd�t|
�D��f��t|�|_|jd�dk�r�|j|d<|jd�dk�r�|jjj�|d<|jd�dk�r�t |j�|d<|jd�dk�r|d|d<g}x||jD]r\}}}|j||�}	t!||��rHt"d||jjf��t#|||	�d|}|	dk	�rt!||��r|j$t%||���qWt|j&�d|j'|j(fk�r�t"d|jd|j'd|j(f��t|�|_)||_*|j+�r�f|_,n|j)|j*|_,x,|j,D]"}
t|
��s�t
d|j|
f���q�W|j-dk�p4t.|j-�dk�sLt"d|j|j-f��t/|�dS)NrQrRT�defaultrcrUrTrSz%s(%r)css|]}t|t�VqdS)N)r#r2)r>�tr)r)r*r@sz!Param.__init__.<locals>.<genexpr>css|]}|dVqdS)rNr))r>rnr)r)r*r@scss|]}|dVqdS)rNr))r>rnr)r)r*r@sz%s: takes no such kwargs: %sz, css|]}t|�VqdS)N)r=)r>r?r)r)r*r@sr^rir`raz'kwarg %r conflicts with attribute on %sz_rule_%sz$%s: cannot have both %s=%r and %s=%rrfrgz"%s: rules must be callable; got %rrz5%s: cli_short_name can only be a single character: %s)rQrR)0rYrrG�kwargsrAr2r0r#r,�	frozenset�list�setr9r1rr�pop�
param_specrW�
_Param__kw�namerBrC�nice�allrl�AssertionError�
issupersetrD�sorted�_Param__clonekw�upperr�hasattrr6�setattr�append�getattrr^rfrg�class_rules�rulesre�	all_rulesr_r3r)r:rvr�rHZkw_from_specZdfr;�kindrmr(Zextrar�Z	rule_name�ruler)r)r*r<�s�















zParam.__init__cCsd|jjdj|j��fS)zQ
        Return an expresion that could construct this `Param` instance.
        z%s(%s)z, )rBrCrD�_Param__repr_iter)r:r)r)r*rFOszParam.__repr__ccs�t|j�Vx|jD]}|jVqWx�t|j�D]�}|j|}t|�rXt|d�rX|j}nLt|t	�rlt
|�}n8t|ttt
f�r�tt|��}n|dkr�t|�}nt|�}d||fVq0WdS)NrCr^z%s=%s)r=rtr�rCr{rur0r~r#r$r9rArrrprrq)r:r�r;r(r)r)r*Z__repr_iterXs



zParam.__repr_itercKs*t|�r|jf|�}n|j|j|��}|S)z$
        One stop shopping.
        )r+�get_default�convert�	normalize)r:r(rHr)r)r*rKkszParam.__call__cCs|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.
        )r^rv)r:rvr)r)r*�get_param_nameuszParam.get_param_nameccsDx>t|j�D]0}|j|}t|�r2t|d�r2|j}||fVqWdS)zW
        Iterate through ``(key,value)`` for all kwargs passed to constructor.
        rCN)r{rur0r~rC)r:r;r(r)r)r*rH�s

zParam.kwcCs0|jdk	r|j|jkS|jdk	r,|j|jkSdS)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)rf�contextrg)r:�envr)r)r*�use_in_context�s
3

zParam.use_in_contextcCs|jr|dk	rdS|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)r:r(r)r)r*�
safe_value�szParam.safe_valuecKs|j|jf|�S)zD
        Return a new `Param` instance similar to this one.
        )�clone_renamerv)r:�	overridesr)r)r*�clone�szParam.clonecKs|j||jf|�S)zZ
        Return a new `Param` instance similar to this one, but named differently
        )�clone_retyperB)r:rvr�r)r)r*r��szParam.clone_renamecKs&t|j�}|j|�||f|j�|�S)z\
        Return a new `Param` instance similar to this one, but of a different type
        )rWr|�updater�)r:rv�klassr�rHr)r)r*r��s

zParam.clone_retypecsF�jrt|�ttfkr|f}�jr8t�fdd�|D��S�j|�SdS)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.
        c3s|]}�j|�VqdS)N)�_normalize_scalar)r>�v)r:r)r*r@	sz"Param.normalize.<locals>.<genexpr>N)rRr2rArqr�)r:r(r))r:r*r��szParam.normalizecCs2|jdkr|Sy
|j|�Stk
r,|SXdS)zo
        Normalize a scalar value.

        This method is called once for each value in a multivalue.
        N)rbrI)r:r(r)r)r*r�s

zParam._normalize_scalarcst�js�j�n�fdd��t|�r&dS�jrlt|�ttfkrB|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.
        cst|t�r|S�j|�S)N)r#�unicode�_convert_scalar)r()r:r)r*r�Ls
zParam.convert.<locals>.convertNc3s|]}t|�s�|�VqdS)N)r+)r>r�)r�r)r*r@Wsz Param.convert.<locals>.<genexpr>r)rjr�r+rRr2rArqr3)r:r(�valuesr))r�r:r*r�s.z
Param.convertcCs6x|jD]}t||�r|SqWt|jt|j�d��dS)z0
        Convert a single scalar value.
        )rv�errorN)rlr#r	rv�ugettext�
type_error)r:r(�indexrnr)r)r*r�^s
zParam._convert_scalarcCs�|dkr,|js|r(d|jkr(t|jd��dS|jrFt|j�td�d��|jr�t	|�t
k	rpttdt
|t	|�f��t
|�dkr�td��x"|D]}|j|�q�Wn
|j|�dS)	z�
        Check validity of ``value``.

        :param value: A proposed value for this parameter.
        :param supplied: True if this parameter was supplied explicitly.
        NZnonempty)rvzthis option is deprecated)rvr�r(rz,value: empty tuple must be converted to None)rQrhr
rvrkrr�rrRr2rAr1rr3r6�_validate_scalar)r:r(Zsuppliedr�r)r)r*�validatehs 
zParam.validatecCsnx6|jD]}t||�rPqWtt|j|j|t|�f��x0|jD]&}|t|�}|dk	r@t|j	�|d��q@WdS)N)rvr�)
rlr#r1rrvr2r�r�rr�)r:r(r�rnr�r�r)r)r*r��s

zParam._validate_scalarcKsJ|jdk	rD|jf|�}|dk	rDy|j|j|��Stk
rBYnX|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)rcr�r�rIrm)r:rHrmr)r)r*r��s4
zParam.get_defaultcCs|S)Nr))r:r(r)r)r*�sort_key�szParam.sort_keycCs�i}xj|jD]`\}}}|ttfkr$qtt||�t�rJtt||g��||<qt||d�}|dkr`qt|�||<qW|jj	|d<|j
|d<|jj	|d<|S)N��classrvr2)ror0r,r#r�rprqrrBrCrvr2)r:Z	json_dict�ar?Z_d�valr)r)r*rL�s
zParam.__json__)N)N)N)(rCrMrNrOr2rr��scalar_errorr�r9rpr�boolr0r,r$r�ro�propertyrlr<rFr�rKr�rHr�r�r�r�r�r�r�r�r�r�r�r�r�rLr)r)r)r*r]IsfL

	

9!
C




=r]c
@s\eZdZdZeZed�Zej	de
e
dddddg�fd	e
e
d
ddd
dg�ffZ	ddd�ZdS)�BoolzG
    A parameter for boolean values (stored in the ``bool`` type).
    zmust be True or False�truthsr�1T�trueZTRUE�
falsehoodsr�0FZfalseZFALSENcCs|t|�|jkr|St|t�r$|j�}||jkr2dS||jkr@dSt|�ttfkrdt	|j
t|j�d��t	|j
t|j
�d��dS)z0
        Convert a single scalar value.
        TF)rvr�N)r2rlr#r9�lowerr�r�rArqr	rvr�r�r�)r:r(r�r)r)r*r��s


zBool._convert_scalar)N)rCrMrNrOr�r2rr�r]rorpr�r)r)r)r*r��sr�cs eZdZdZ�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
    csdd|d<d|krd|d<t|d�tk	rH|d}ttdt|t|�f��tt|�j|f|�|�dS)NTrdrmF)r2r�r1r�superr�r<)r:rvr�rHrm)rBr)r*r<$sz
Flag.__init__)rCrMrNrOr<�
__classcell__r)r))rBr*r�sr�c@seZdZdZddd�ZdS)�Numberz<
    Base class for the `Int` and `Decimal` parameters.
    NcCs�t|�|jkr|St|�tttfkrDy
|j|�Stk
rBYnXt|�ttfkrht|j	t
|j�d��t|j	t
|j�d��dS)z0
        Convert a single scalar value.
        )rvr�N)
r2rlr�r%r$r6rArqr	rvr�r�r�)r:r(r�r)r)r*r�5s
zNumber._convert_scalar)N)rCrMrNrOr�r)r)r)r*r�0sr�cs�eZdZdZeZefZed�Ze	Z	e
Z
eZeZe
Z
ejdeee	�fdeee
�ffZedd��Z�fdd�Zdd
d�Zdd
�Zdd�Z�ZS)�IntzF
    A parameter for integer values (stored in the ``int`` type).
    zmust be an integer�minvalue�maxvaluecCsxt|�tjkr|St|�tkr&t|�St|�tkrld|krFtt|��Stjrbtj	d|�rbt|d�St|d�St
|��dS)N�.z0[0-9]+�r)r2r�rlr%r$r��six�PY3�re�matchr6)r(r)r)r*�convert_intZs

zInt.convert_intcs�tt|�j|f|�|�|j|jkrP|jdk	rP|jdk	rPtd|j|j|jf��|j|jkrttd|j�d|j����|j|jkr�td|j�d|j����dS)Nz2%s: minvalue > maxvalue (minvalue=%r, maxvalue=%r)z	minvalue z* outside range of safe JSON integer limit z	maxvalue )	r�r�r<r�r�r6rw�MIN_SAFE_INTEGER�MAX_SAFE_INTEGER)r:rvr�rH)rBr)r*r<ls zInt.__init__NcCs:y
tj|�Stk
r4t|j�t|j�d��YnXdS)z0
        Convert a single scalar value.
        )rvr�N)r�r�r6r	r�r�r�)r:r(r�r)r)r*r�s

zInt._convert_scalarcCs4t|t�st�||jkr,|d�t|jd�SdSdS)z'
        Check min constraint.
        zmust be at least %(minvalue)d)r�N)r#r$ryr�rW)r:rr(r)r)r*�_rule_minvalue�s

zInt._rule_minvaluecCs4t|t�st�||jkr,|d�t|jd�SdSdS)z'
        Check max constraint.
        zcan be at most %(maxvalue)d)r�N)r#r$ryr�rW)r:rr(r)r)r*�_rule_maxvalue�s

zInt._rule_maxvalue)N)rCrMrNrOr$r2rlrr�rr�
MAX_UINT32r�r�r]ro�staticmethodr�r<r�r�r�r�r)r))rBr*r�Fs"

r�c
s�eZdZdZejZed�Ze	j
dejdfdejdfdedfdedfd	e
dffZ
�fd
d�Zdd�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�-Normal�+Zero�+Normalcs�x~dD]v}|j|�}|dkrqt|ttf�rytj|�}Wn8tk
rr}ztd||t|�f��WYdd}~XnX|||<qWtt|�j	|f|�|�|j
dk	r�|jdk	r�|j
|jkr�td|j|j
|jf��|j
dk	r�|j
dkr�td|j��dS)	Nr�r�rmz%s: cannot parse kwarg %s: %sz2%s: minvalue > maxvalue (minvalue=%s, maxvalue=%s)rz %s: precision must be at least 0)r�r�rm)rGr#r9r%r&r'rIr6r�r<r�r�rwr�)r:rvr�rHZkwparamr(�e)rBr)r*r<�s*

$

zDecimal.__init__cCs8t|�tjkst�||jkr0|d�t|jd�SdSdS)z'
        Check min constraint.
        zmust be at least %(minvalue)s)r�N)r2r&r'ryr�rW)r:rr(r)r)r*r��s

zDecimal._rule_minvaluecCs8t|�tjkst�||jkr0|d�t|jd�SdSdS)z'
        Check max constraint.
        zcan be at most %(maxvalue)s)r�N)r2r&r'ryr�rW)r:rr(r)r)r*r��s

zDecimal._rule_maxvaluecCs>|j�}||jkr:t|j�td�t|dj|j�d�d��dS)NzWnumber class '%(cls)s' is not included in a list of allowed number classes: %(allowed)sz, )�clsZallowed)rvr�)Znumber_classr�rr�rrWrD)r:r(r�r)r)r*�_enforce_numberclass�s
zDecimal._enforce_numberclasscCs~t|�tjkst�|jdk	rztjd�t|j�}y|j|�}Wn8tjk
rx}zt|j	�t
|�d��WYdd}~XnX|S)N�
)rvr�)r2r&r'ryr�r$�quantize�DecimalExceptionr	r�r�)r:r(Zquantize_expr�r)r)r*�_enforce_precision�s
zDecimal._enforce_precisioncCs~t|�tjkst�|jszy(||j�kr6|jtjd��n|j�}Wn8tjk
rx}zt	|j
�t|�d��WYdd}~XnX|S)Nr)rvr�)r2r&r'ryr�Zto_integralr�r�r�r	r�r�)r:r(r�r)r)r*�_remove_exponentszDecimal._remove_exponentcCs"|j|�|j|�}|j|�}|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)r*�_test_and_normalizes


zDecimal._test_and_normalizecs|t|ttf�rVytj|�}Wn8tjk
rT}zt|j�t|�d��WYdd}~XnXt|tj�rl|j	|�St
t|�j|�S)N)rvr�)r#r9r%r&r'r�r	r�r�r�r�r�)r:r(r�r�)rBr)r*r�s
zDecimal._convert_scalarcs&t|tj�r|j|�Stt|�j|�S)N)r#r&r'r�r�r�)r:r()rBr)r*r�)s
zDecimal._normalize_scalar)r�r�r�)N)rCrMrNrOr&r'r2rr�r]ror$r�rAr<r�r�r�r�r�r�r�r�r�r)r))rBr*r'�s$



r'cs\eZdZdZejdedfdedfdedfdefdffZdZdZ	�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_errmsgcs�tt|�j|f|�|�|jdkp4|jdko4|jdksDtd|j��|jdk	rl|jdkrltd|j|jf��|jdk	r�|jdkr�td|j|jf��d|j|jfkr�|j|jkr�td|j|j|jf��n |j|jkr�td|j|jf��dS)Nz1%s: cannot mix length with minlength or maxlengthrz"%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�r<r�r�r�r6rw)r:rvr�rH)rBr)r*r<Bs(
z
Data.__init__cCsXt|�|jkst�|jj|�dkrP|jr:|jt|jd�S|d�t|jd�SndSdS)z2
        Check pattern (regex) contraint.
        N)�patternz must match pattern "%(pattern)s")r2rlryr�r��	re_errmsgrWr�)r:rr(r)r)r*�
_rule_patterncszData._rule_pattern)
rCrMrNrOr]ror$r9r�r�r<r�r�r)r))rBr*r�/s!r�csfeZdZdZeZed�Zej	defdffZ	�fdd�Z
dd�Zd	d
�Zdd�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�NcsR|jdd�dkrd|_ntj|d�|_|jdd�|_tt|�j|f|�|�dS)Nr�r�)rGr��compiler�r�r�r<)r:rvr�rH)rBr)r*r<�s
zBytes.__init__cCs:t|�tkst�t|�|jkr2|d�t|jd�SdSdS)z-
        Check minlength constraint.
        z$must be at least %(minlength)d bytes)r�N)r2�bytesryr3r�rW)r:rr(r)r)r*�_rule_minlength�s
zBytes._rule_minlengthcCs:t|�tkst�t|�|jkr2|d�t|jd�SdSdS)z-
        Check maxlength constraint.
        z"can be at most %(maxlength)d bytes)r�N)r2r�ryr3r�rW)r:rr(r)r)r*�_rule_maxlength�s
zBytes._rule_maxlengthcCs:t|�tkst�t|�|jkr2|d�t|jd�SdSdS)z*
        Check length constraint.
        z must be exactly %(length)d bytes)r�N)r2r�ryr3r�rW)r:rr(r)r)r*�_rule_length�s
zBytes._rule_lengthcs^t|t�rNytj|�}Wn4ttfk
rL}ztt|�d��WYdd}~XnXtt	|�j
|�S)N)�reason)r#r��base64�	b64decoder1r6r
r9r�r�r�)r:r(r�r�)rBr)r*r��s
 zBytes._convert_scalar)N)rCrMrNrOr�r2rr�r�ror<r�r�r�r�r�r)r))rBr*r�ss
r�cs6eZdZejZed�Zee	e
fZd�fdd�	Z�Z
S)�Certificatezmust be a certificateNc's�t|t�r.y|jd�}Wntk
r,YnXt|t�r|ytj|�}Wn4ttfk
rz}zt	t
|�d��WYdd}~XnXt|t�r�yt|�}Wn0tk
r�}ztt
|�d��WYdd}~XnXt
t|�j|�S)z�
        :param value: either DER certificate or base64 encoded certificate
        :returns: bytes representing value converted to DER format
        �ascii)r�N)r�)r#r��decode�UnicodeDecodeErrorr�r�r�r1r6r
r9rrr�r�r�)r:r(r�r�)rBr)r*r��s 

 
 zCertificate._convert_scalar)N)rCrMrN�crypto_x509r�r2rr�rr�r�rlr�r�r)r))rBr*r��s
r�cs@eZdZejZed�Zejee	fZ
dd�Zd�fdd�	Z�Z
S)�CertificateSigningRequestz%must be a certificate signing requestcCs6y|jd�Wntk
r"|SXt|�}tj|�S)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-8)r�r�rr�r�)r:r(r)r)r*Z__extract_der_from_input�sz2CertificateSigningRequest.__extract_der_from_inputNcs�t|t�r6y|jd�}Wntk
r4td��YnXt|t�r�|j|�}ytj|t	�d�}Wn4t
k
r�}zttd�|d��WYdd}~XnXtt
|�j|�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 CSR)Zbackendz0Failure decoding Certificate Signing Request: %s)r�N)r#r��encoder�rr��2_CertificateSigningRequest__extract_der_from_inputr�Zload_der_x509_csrrr6rr�r�r�)r:r(r�r�)rBr)r*r��s


z)CertificateSigningRequest._convert_scalar)N)rCrMrNr�r�r2rr�r�r�rlr�r�r�r)r))rBr*r��s
r�cszeZdZdZejdefdfdedffZeZ	e
d�Z�fdd�Zdd	d
�Z
dd�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 textcsV|jdd�dkrd|_ntj|dtj�|_|jdd�|_tt|�j|f|�|�dS)Nr�r�)rGr�r��UNICODEr�r�r�r<)r:rvr�rH)rBr)r*r<(s
zStr.__init__cCslt|�|jkr|St|�tttjfkr0|j|�St|�ttfkrTt|j	t
|j�d��t|j	t
|j�d��dS)z0
        Convert a single scalar value.
        )rvr�N)
r2rlr$r%r&r'rArqr	rvr�r�r�)r:r(r�r)r)r*r�0s
zStr._convert_scalarcCsBt|�tkst�|jdkrdSt|�t|j��kr:|d�SdSdS)z7
        Do not allow leading/trailing spaces.
        FNz+Leading and trailing spaces are not allowed)r2r�ryr�r3�strip)r:rr(r)r)r*�_rule_noextrawhitespace=s
zStr._rule_noextrawhitespacecCs:t|�tkst�t|�|jkr2|d�t|jd�SdSdS)z-
        Check minlength constraint.
        z)must be at least %(minlength)d characters)r�N)r2r�ryr3r�rW)r:rr(r)r)r*r�Is
zStr._rule_minlengthcCs:t|�tkst�t|�|jkr2|d�t|jd�SdSdS)z-
        Check maxlength constraint.
        z'can be at most %(maxlength)d characters)r�N)r2r�ryr3r�rW)r:rr(r)r)r*r�Us
zStr._rule_maxlengthcCs:t|�tkst�t|�|jkr2|d�t|jd�SdSdS)z*
        Check length constraint.
        z%must be exactly %(length)d characters)r�N)r2r�ryr3r�rW)r:rr(r)r)r*r�as
zStr._rule_lengthcCs|j�S)N)r�)r:r(r)r)r*r�mszStr.sort_key)N)rCrMrNrOr�ror9r�r�r2rr�r<r�r�r�r�r�r�r�r)r))rBr*r�s



r�cs.eZdZdZ�fdd�Zd�fdd�	Z�ZS)�IA5Strz#
    An IA5String per RFC 4517
    cstt|�j|f|�|�dS)N)r�r�r<)r:rvr�rH)rBr)r*r<uszIA5Str.__init__NcsRt|t�rBx6|D].}t|�dkrt|j�td�t|d�d��qWtt|�j	|�S)N�z&The character %(char)r is not allowed.)�char)rvr�)
r#r9�ordr	r�rrWr�r�r�)r:r(r�r�)rBr)r*r�xs

zIA5Str._convert_scalar)N)rCrMrNrOr<r�r�r)r))rBr*r�psr�csBeZdZdZejdefdfdedffZdZd	�fdd�	Z	�Z
S)
�PasswordzE
    A parameter for passwords (stored in the ``unicode`` type).
    r�Nr�FTcsJt|ttf�r:t|�dkr:|\}}||kr6t|jd��|}tt|�j|�S)Nr!)rv)	r#rArqr3rrvr�r�r�)r:r(r�Zp1Zp2)rBr)r*r��szPassword._convert_scalar)N)rCrMrNrOr�ror9r�r�r�r�r)r))rBr*r��s
r�cs<eZdZdZejdee�ffZ�fdd�Zdd�Z�Z	S)�Enumz;
    Base class for parameters with enumerable values.
    r�cs�tdd�|jdt��D��|d<tt|�j|f|�|�xLt|j�D]>\}}t|�|j	krDd|j
|f}tt||j|t|�f��qDWt
|j�dkr�td|j
��dS)NcSsg|]}t|��qSr))r9)r>r�r)r)r*�
<listcomp>�sz!Enum.__init__.<locals>.<listcomp>r�riz
%s values[%d]rz$%s: list of values must not be empty)r9rGrAr�r�r<�	enumerater�r2rlrwr1rr3r6)r:rvr�rH�ir��n)rBr)r*r<�s z
Enum.__init__cKsb||jkrZt|j�dkr0|d�t|jdd�Sdjdd�|jD��}|d�t|d	�SndSdS)
Nrzmust be '%(value)s'r)r(z, css|]}d|VqdS)z'%s'Nr))r>r(r)r)r*r@�sz$Enum._rule_values.<locals>.<genexpr>zmust be one of %(values)s)r�)r�r3rWrD)r:rr(rHr�r)r)r*�_rule_values�s
zEnum._rule_values)
rCrMrNrOr]rorAr<r�r�r)r))rBr*r��s
r�c@seZdZdZeZdS)�	BytesEnumzB
    Enumerable for binary data (stored in the ``str`` type).
    N)rCrMrNrOr�r2r)r)r)r*r��sr�c@seZdZdZeZdS)�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'
    N)rCrMrNrOr�r2r)r)r)r*r��s
r�c@s*eZdZdZeZefZejZddd�Z	dS)�IntEnumzC
    Enumerable for integer data (stored in the ``int`` type).
    NcCs:y
tj|�Stk
r4t|j�t|j�d��YnXdS)z0
        Convert a single scalar value.
        )rvr�N)r�r�r6r	r�r�r�)r:r(r�r)r)r*r��s

zIntEnum._convert_scalar)N)
rCrMrNrOr$r2rlr�r�r�r)r)r)r*r��s
r�c@s(eZdZdZeZddd�Zddd�ZdS)	�AnyzS
    A parameter capable of holding values of any type. For internal use only.
    NcCs|S)Nr))r:r(r�r)r)r*r��szAny._convert_scalarcCs4x.|jD]$}|t|�}|dk	rt|j|d��qWdS)N)rvr�)r�r�rrv)r:r(r�r�r�r)r)r*r��s
zAny._validate_scalar)N)N)rCrMrNrO�objectr2r�r�r)r)r)r*r�s
rc@s.eZdZdZdZejdedfdedffZdS)�FilezhText file parameter type.

    Accepts file names and loads their content into the parameter value.
    �r�stdin_if_missingFr�N)rCrMrNrO�	open_moder�ror�r)r)r)r*r�s
rc@s.eZdZdZdZejdedfdedffZdS)�
BinaryFilezBinary file parameter type
    �rbrFr�N)rCrMrNrOrr�ror�r)r)r)r*rs
rcs@eZdZdZedddddgZejZed�Z	d�fd	d
�	Z
�ZS)�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 tjj�}|Sx6|jD],}ytjj||�}|Stk
rRYq(Xq(Wtd�dj|j�}t	|j
�|d��tt|�j
|�S)NZnowz(does not match any of accepted formats: z, )rvr�)r#r9�datetimeZutcnow�accepted_formatsZstrptimer6rrDr	r�r�rr�)r:r(r��timeZdate_formatr�)rBr)r*r�,s


zDateTime._convert_scalar)N)rCrMrNrOrr
r	r2rr�r�r�r)r))rBr*rsrc@s�eZdZdZdd�Zdd�Zd!dd	�Zd
d�Zdd
�Zdd�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�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.
    cCsxt|�dkrtd��|j�s$td��t|dd��}|dksD|dkrLtd��t|dd��}|dksl|dkrttd	��dS)
N�z&HHMM must be exactly 4 characters longzHHMM non-numericrr!�zHH out of range�;zMM out of range)r3r6�	isnumericr$)r:rnZhhZmmr)r)r*�_check_HHMMLszAccessTime._check_HHMMcCs>|j�r*t|�}|dks |dkr:td��n|dkr:td��dS)
Nr�zday of the week out of range�Mon�Tue�Wed�Thu�Fri�Sat�Sunzinvalid day of the week)rrrrrrr)rr$r6)r:rnr(r)r)r*�_check_dotwXs
zAccessTime._check_dotwrr
cCs�|j�std��t|�}|dkr:|dks0|d	kr�td
��n�|dkr\|dksR|dkr�td
��n^|dkr�|ddkr�|ddks�|ddkr�|dks�|dkr�td
��n|dks�|dkr�td
��dS)Nzday of the month non-numericr��rr�r�r.�zday of the month out of ranger
��	��r!r�di���)rrrrr�r�r.)r
rrr )rr6r$)r:rn�	month_numZyearr(r)r)r*�_check_dotm`s

$
zAccessTime._check_dotmcCs4|j�std��t|�}|dks(|dkr0td��dS)Nzweek of the month non-numericrrzweek of the month out of range)rr6r$)r:rnr(r)r)r*�_check_wotmrs
zAccessTime._check_wotmcCs4|j�std��t|�}|dks(|dkr0td��dS)Nzweek of the year non-numericr�4zweek of the year out of range)rr6r$)r:rnr(r)r)r*�_check_wotyys
zAccessTime._check_wotycCs4|j�std��t|�}|dks(|dkr0td��dS)Nzday of the year non-numericrimzday of the year out of range)rr6r$)r:rnr(r)r)r*�_check_doty�s
zAccessTime._check_dotycCs4|j�std��t|�}|dks(|dkr0td��dS)Nzmonth number non-numericrr.zmonth number out of range)rr6r$)r:rnr(r)r)r*�_check_month_num�s
zAccessTime._check_month_numcCs�|jd�}xx|D]p}|s td��|jd�}t|�dkr>td��x|D]}||�qDWt|�dkrt|d�t|d�krtd��qWdS)N�,zinvalid time range�-r!rr)�splitr6r3r$)r:rnZ
check_funcZ	intervalsr�r�r�r)r)r*�_check_interval�s



zAccessTime._check_intervalcCs2||dkrtd��|d7}|j|||j�|S)N�dayzinvalid week specifierr)r6r/r)r:�tsr�r)r)r*�
_check_W_spec�s
zAccessTime._check_W_speccCsh||dkr4|j||d|j�|j||d�}n0||dkr\|d7}|j|||j�ntd��|S)N�weekrr!r0zinvalid month specifier)r/r'r2r&r6)r:r1r�r)r)r*�
_check_M_spec�szAccessTime._check_M_speccCs�||dkr8|d7}|j|||j�|j||d�}nd||dkrl|j||d|j�|j||d�}n0||dkr�|d7}|j|||j�ntd��|S)NZmonthrr3r!r0zinvalid year specifier)r/r+r4r)r2r*r6)r:r1r�r)r)r*�
_check_Y_spec�szAccessTime._check_Y_speccCs�t|�tkst�t|�d
kr$td��|j�s4td��|j|dd��t|dd��}t|dd��}|j|dd	�||�t|�dkr�|j	|d	d��n|j	d
|d	d��t|�dkr�t|dd��}|dks�|dkr�td��dS)Nr�r.�zincomplete generalized timeztime non-numericr
rrr�z%s00�<zseconds out of range)r�r.r6)
r2r�ryr3r6rr+r$r&r)r:rnZyear_numr%�sr)r)r*�_check_generalized�s zAccessTime._check_generalizedcCs(|j�}|ddkrzt|�dkr(td��|j|d�|ddkrJtd��|j|d	�t|d�t|d	�krxtd
��n�|ddk�rd}|ddkr�|j|d�}nD|dd
kr�|j|d�}n*|ddkr�|j|d�}n|ddkr�d}|dk�rtd|d��|j||d|j	�ntd��dS)NrZabsoluter
zDinvalid format, must be 'absolute generalizedTime ~ generalizedTime'rr!�~zinvalid time range separatorrzinvalid time rangeZperiodicZyearlyZmonthlyZweeklyZdailyz0period must be yearly, monthy or daily, got '%s'z!time neither absolute or periodic)
r.r3r6r9r$r5r4r2r/r)r:rr1r�r)r)r*�_check�s0

zAccessTime._checkcCsry|j|�Wn^tk
rF}zt|j�|jdd��WYdd}~Xn(tk
rlt|j�td�d��YnXdS)Nr)rvr�zincomplete time value)r;r6rr�rE�
IndexErrorr�)r:rr(r�r)r)r*�_rule_required�s&zAccessTime._rule_requiredN)rr
)rCrMrNrOrrr&r'r)r*r+r/r2r4r5r9r;r=r)r)r)r*rEs
rc@seZdZeZddd�ZdS)�DNParamNcCs~t|�|jkr|St|�ttfkr6t|jt|j�d��yt|�}Wn6t	k
rx}zt|j
�t|�d��WYdd}~XnX|S)z0
        Convert a single scalar value.
        )rvr�N)r2rlrArqr	rvr�r�rrIr�)r:r(r�Zdnr�r)r)r*r��szDNParam._convert_scalar)N)rCrMrNrr2r�r)r)r)r*r>�sr>cCs>t|t�r|St|�tk	r6ttdttf|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.
    rP)r#r]r2r9r1rr�)rPr)r)r*�create_param
s!
r?csdeZdZdZeZed�Zej	de
dfde
dffZ	�fdd�Zd�fd	d
�	Zdd�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_relativecs6tt|�j|f|�|�|jr2|jr2td|j��dS)Nz(%s: cannot be both absolute and relative)r�r@r<rArBr6rw)r:rvr�rH)rBr)r*r<FszDNSNameParam.__init__Ncs~t|t�rnyt|�Wn6tk
rL}zt|j�t|�d��WYdd}~XnXt|�}|jrn|j�rn|j	�}t
t|�j|�S)N)rvr�)
r#r�rr6r	r�rrA�is_absoluteZ
make_absoluter�r@r�)r:r(r�r�)rBr)r*r�Ls
zDNSNameParam._convert_scalarcCs |jr|j�r|d�SdSdS)Nzmust be absolute)rArC)r:rr(r)r)r*�_rule_only_absoluteZsz DNSNameParam._rule_only_absolutecCs|jr|j�r|d�SdSdS)Nzmust be relative)rBrC)r:rr(r)r)r*�_rule_only_relative`sz DNSNameParam._rule_only_relative)N)rCrMrNrOrr2rr�r]ror�r<r�rDrEr�r)r))rBr*r@7sr@c@seZdZdZeZed�ZdS)�Dictz%
    A parameter for dictionary.
    zmust be dictionaryN)rCrMrNrOrWr2rr�r)r)r)r*rFgsrFcsVeZdZdZejZed�Ze	j
dedffZ
edd��Z
d�fdd	�	Zd
d�Z�ZS)
�	Principalz!
    Kerberos principal name
    zmust be Kerberos principal�require_serviceFcCs
|jtfS)N)r2r�)r:r)r)r*rl{szPrincipal.allowed_typesNcs\t|t�rLytj|�}Wn2tk
rJt|j�td�t|d�d��YnXt	t|�j
|�S)Nz Malformed principal: '%(value)s')r()rvr�)r#r�rrGr6r	r�rrWr�r�)r:r(r�)rBr)r*r�s
zPrincipal._convert_scalarcCs&|jr"|jr"t|j�|d�d��dS)NzService principal is required)rvr�)rHZ
is_servicerr�)r:rr(r)r)r*�_rule_require_service�szPrincipal._rule_require_service)N)rCrMrNrOrrGr2rr�r]ror�r�rlr�rIr�r)r))rBr*rGpsrGc	Csg}t�}|j�tjjf|j�tjjfg}x�|D]�\}}x�|D]�}|j|krNq>|j|j�t	|t
�sfq>|jrvtjj}n|j
}tdd�|jD��}t	|t�r�|tjf7}tj|}	|jr�tj|	}	|jtj|j|||	d��q>Wq0Wtj|tjtjtjfd�}
|
S)z�Create an inspect.Signature for a command

    :param command: ipa plugin instance (server or client)
    :return: inspect.Signature instance
    css|]}tj||�VqdS)N)�
_map_typesrG)r>rnr)r)r*r@�sz#create_signature.<locals>.<genexpr>)rmZ
annotation)Zreturn_annotation)rrZget_args�inspectZ	ParameterZPOSITIONAL_OR_KEYWORDZget_optionsZKEYWORD_ONLYrvr[r#r]rQ�emptyrmrArlr@r�Z	text_type�typingZUnionrRZListr�Z	SignaturerFZTextr)ZcommandZsignature_params�seenZargs_optionsZ	ipaparamsr�ZipaparamrmrlZannZ	signaturer)r)r*�create_signature�s8






rOll��ll����)_rOr�r&r�r	rKrMZ
xmlrpc.clientrrr�Zcryptographyrr�Zdns.nameZdnsZipalib.textrr�Zipalib.baserZipalib.plugablerrZ
ipalib.errorsr	r
rrr
rrZipalib.constantsrrrrrZipalib.utilrrZipalib.x509rrrrrZ	ipapythonrZipapython.dnrZipapython.dnsutilrr�r�r�r+r�r9r�r,rYrrrZr]r�r�r�r�r'r�r�r�r�r�r�r�r�r�r�r�rrrrrr>r?r@rFrGrv�NamerJrOr)r)r)r*�<module>ds�	|-!!*\DG$6\!
53*0	%
@ Telegram